增删该查联系人的 service

比眉伴天荒 2022-08-05 07:27 136阅读 0赞

package com.android.contacts;  
  
import java.util.ArrayList;  
import java.util.List;  
  
import neolink.telephony.GroupInfo;  
import neolink.telephony.PrivateContactContract;  
import neolink.telephony.PrivateIntents;  
import neolink.telephony.PrivateMode;  
import android.app.Service;  
import android.content.ContentProviderOperation;  
import android.content.ContentProviderResult;  
import android.content.ContentResolver;  
import android.content.ContentUris;  
import android.content.ContentValues;  
import android.content.Context;  
import android.content.Intent;  
import android.content.OperationApplicationException;  
import android.content.SharedPreferences;  
import android.content.pm.PackageManager.NameNotFoundException;  
import android.database.Cursor;  
import android.net.Uri;  
import android.net.Uri.Builder;  
import android.os.Handler;  
import android.os.HandlerThread;  
import android.os.IBinder;  
import android.os.Looper;  
import android.os.Message;  
import android.os.RemoteException;  
import android.os.ServiceManager;  
import android.os.SystemProperties;  
import android.provider.BaseColumns;  
import android.provider.ContactsContract;  
import android.provider.Settings;  
import android.provider.ContactsContract.Contacts;  
import android.provider.ContactsContract.Groups;  
import android.provider.ContactsContract.RawContacts;  
import android.provider.ContactsContract.CommonDataKinds.GroupMembership;  
import android.provider.ContactsContract.CommonDataKinds.Phone;  
import android.provider.ContactsContract.CommonDataKinds.StructuredName;  
import android.provider.ContactsContract.Contacts.Data;  
import android.telephony.PhoneNumberUtils;  
import android.text.TextUtils;  
import android.util.Log;  
import android.pctool.ConfigurationManager;  
import android.pctool.ConfigurationManager.ConfigurationException;  
import android.pctool.ConfigurationManager.ValueList;  
import com.neolink.internal.telephony.IPrivateTelephony;  
import com.neolink.internal.telephony.IPrivateRegistry;  
/\*\*  
\*  
\* @author xuhong.tian on 11.14 that add the import contacts and group  
\*  
\*/  
  
public class ContactsImportService extends Service \{  
private static final String TAG = "ContactsImportService";  
  
private static final int EVENT\_IMPORT\_CONTACTS = 1;  
private static final int EVENT\_IMPORT\_GROUPMEMBER = 2;  
private static final int EVENT\_IMPORT\_GROUP = 3;  
private static final int EVENT\_IMPPRT\_DIG\_NORMAO\_CONTACTS\_AND\_GROUP=4;  
private static final int EVENT\_DO\_FINISH = 5;  
private int mMode = PrivateMode.MODE\_UNKNOWN;  
  
private ContentResolver mContentResolver;  
private GroupHandler mHandler;  
private Context mContext;  
private String controlSync = new String();  
  
private ContactsHandler mContactsHander;  
private static final String READ\_GROUP\_MEMBER\_KEY\_PDT = "T1327";  
private static final String READ\_GROUP\_MEMBER\_KEY\_MPT = "T20104";  
private static final String READ\_DIG\_NORMAL\_DATA\_KEY="T31101";  
private static final String READ\_CONTACTS\_MPT\_KEY="T21801";  
private static final String READ\_CONTACTS\_PDT\_KEY="T1316";  
  
  
private static final String PREF\_FILE\_PDT = "default\_group\_pdt";  
private static final String PREF\_FILE\_MPT = "default\_group\_mpt";  
private static final String PREF\_FILE\_MODE = "default\_mode";  
private static final String PREF\_FILE\_NUMBER = "default\_group\_number";  
  
private String pctoolsFlag;  
private boolean importGroupDone = false;  
private boolean importContactsDone = false;  
  
private int i;  
private final static String\[\] COLUMNS = new String\[\] \{ Groups.ACCOUNT\_NAME,  
Groups.ACCOUNT\_TYPE, Groups.DATA\_SET, Groups.\_ID, Groups.TITLE,  
Groups.SUMMARY\_COUNT, Groups.GROUP\_NUMBER,  
Groups.GROUP\_CURRENT\_MODE, Groups.GROUP\_BY\_IMPORT\_TYPE, Groups.\_ID,  
Groups.GROUP\_DEFAULT  
  
\};  
  
@Override  
public IBinder onBind(Intent intent) \{  
// TODO Auto-generated method stub  
return null;  
\}  
  
public void onCreate() \{  
Log.d(TAG, "onCreate ...");  
mContentResolver = getContentResolver();  
HandlerThread handlerThread = new HandlerThread(TAG);  
handlerThread.start();  
  
HandlerThread contactshandlerThread = new HandlerThread(  
"ContactsHandler");  
contactshandlerThread.start();  
  
mHandler = new GroupHandler(handlerThread.getLooper());  
mContactsHander = new ContactsHandler(contactshandlerThread.getLooper());  
\}  
  
public int onStartCommand(Intent intent, int flags, int startId) \{  
Log.d(TAG, "onStartCommand intent:" + intent + " flags:" + flags  
\+ " startId:" + startId);  
int result = super.onStartCommand(intent, flags, startId);  
mContext = getBaseContext();  
  
if (intent != null) \{  
pctoolsFlag = SystemProperties.get("pctool.update.flag");  
Log.d(TAG, "pctoolsFlag>>" + pctoolsFlag  
\+ ">>pctoolsFlag.length()=" + pctoolsFlag.length());  
  
String action = intent.getAction();  
if ("com.neolink.modechange".equals(action)) \{  
mMode = intent  
.getIntExtra(PrivateIntents.EXTRA\_PRIVATE\_MODE, 0);  
Log.d(TAG, "mMode" + mMode);  
if (PrivateMode.MODE\_PDT\_DIGITAL\_NORMAL == mMode) \{  
  
deleteOldGroupInfo("");  
//importDigNormalContactsAndGroup();  
mContactsHander.sendEmptyMessage(EVENT\_IMPPRT\_DIG\_NORMAO\_CONTACTS\_AND\_GROUP);  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
  
\} else if (PrivateMode.MODE\_MPT1327\_ANALOG\_TRUNKING == mMode) \{  
mHandler.sendEmptyMessage(EVENT\_IMPORT\_GROUP);  
if (pctoolsFlag.charAt(6) == '1') \{  
mContactsHander.sendEmptyMessage(EVENT\_IMPORT\_CONTACTS);  
\}  
  
\} else if (PrivateMode.MODE\_MPT1327\_ANALOG\_NORMAL == mMode) \{  
deleteOldGroupInfo("");  
mContentResolver.notifyChange(  
Groups.CONTENT\_GROUP\_FOR\_PHONE, null, false);  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
  
\} else if (PrivateMode.MODE\_PDT\_DIGITAL\_TRUNKING == mMode) \{  
  
mHandler.sendEmptyMessage(EVENT\_IMPORT\_GROUP);  
if (pctoolsFlag.charAt(6) == '1') \{  
mContactsHander.sendEmptyMessage(EVENT\_IMPORT\_CONTACTS);  
\}  
\} else\{  
deleteOldGroupInfo("");  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
\}  
  
\} else if (action.equals(Intent.ACTION\_BOOT\_COMPLETED)) \{  
/\*\*  
\* add by xuhong.tian remove the bootcompleted operation  
\*/  
// if (!TextUtils.isEmpty(pctoolsFlag)) \{  
//  
// if (pctoolsFlag.charAt(6) == '1') \{  
// mContactsHander.sendEmptyMessage(EVENT\_IMPORT\_CONTACTS);  
// \} else \{  
// mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
// \}  
// \} else \{  
// Log.d(TAG, "pctoolsFlag>> error");  
// mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
// \}  
  
\} else if ("com.neolink.action.dynamic\_group".equals(action)) \{  
  
boolean dynamicFlag = intent.getBooleanExtra("group\_changed",  
true);// true >add，false  
// > delete  
String group\_name = (String) intent.getExtra("group\_name", "");  
String group\_number = (String) intent.getExtra("group\_number",  
"");  
Log.d(TAG, "group\_name==" + group\_name + "group\_number=="  
\+ group\_number + "dynamicFlag==" + dynamicFlag);  
if (dynamicFlag) \{  
if (!TextUtils.isEmpty(group\_number)) \{  
  
deleteDynamicGroup("");  
addDynamicGroup(group\_name, group\_number);  
mContentResolver.notifyChange(  
Groups.CONTENT\_GROUP\_FOR\_PHONE, null, false);  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
\}  
\} else \{  
deleteDynamicGroup("");  
mContentResolver.notifyChange(  
Groups.CONTENT\_GROUP\_FOR\_PHONE, null, false);  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
\}  
\}  
return result;  
\} else \{  
mHandler.sendEmptyMessage(EVENT\_IMPORT\_GROUP);  
\}  
return 0;  
\}  
  
private class GroupHandler extends Handler \{  
public GroupHandler(Looper looper) \{  
super(looper);  
\}  
  
public void handleMessage(Message msg) \{  
Log.d(TAG, "welcomein GroupHandler handleMessage" + msg.what);  
switch (msg.what) \{  
  
case EVENT\_IMPORT\_GROUP:  
removeMessages(EVENT\_DO\_FINISH);  
  
synchronized (controlSync) \{  
  
deleteOldGroupInfo("");  
importGroupContacts();  
// updateDefaultGroup("");  
mContentResolver.notifyChange(  
Groups.CONTENT\_GROUP\_FOR\_PHONE, null, false);  
importGroupDone = true;  
Log.d(TAG, "updateimportGroupMember()======"+updateimportGroupMember());  
if (updateimportGroupMember()) \{  
mContactsHander  
.sendEmptyMessage(EVENT\_IMPORT\_GROUPMEMBER);  
importGroupDone = false;  
\}  
\}  
break;  
case EVENT\_DO\_FINISH:  
Log.d(TAG, "don kill the ContactsImportService");  
  
ContactsImportService.this.stopSelf();  
break;  
\}  
\}  
\}  
  
private class ContactsHandler extends Handler \{  
public ContactsHandler(Looper looper) \{  
super(looper);  
\}  
  
public void handleMessage(Message msg) \{  
  
Log.d(TAG, "welcome in mContactsHander" + msg.what);  
switch (msg.what) \{  
case EVENT\_IMPORT\_CONTACTS: \{  
removeMessages(EVENT\_DO\_FINISH);  
synchronized (controlSync) \{  
importPrivateContacts();  
importContactsDone = true;  
/\* Log.d(TAG, "updateimportGroupMember()======"  
\+ updateimportGroupMember());  
//if (updateimportGroupMember()) \{  
//\}  
\*/ \}  
break;  
\}  
  
case EVENT\_IMPORT\_GROUPMEMBER: \{  
removeMessages(EVENT\_DO\_FINISH);  
importPrivateGroupMember();  
break;  
\}  
case EVENT\_IMPPRT\_DIG\_NORMAO\_CONTACTS\_AND\_GROUP: \{  
removeMessages(EVENT\_DO\_FINISH);  
importDigNormalContactsAndGroup();  
break;  
\}  
\}  
\}  
  
\}  
  
private void importPrivateGroupMember() \{  
// TODO Auto-generated method stub  
  
Log.d(TAG, "importPrivateGroupMember..........start+mode="+ContactsApplication.getApplication().mMode);  
ConfigurationManager.Item contactsMemberItem = null;  
ContentValues values = new ContentValues();  
ConfigurationManager manager = new ConfigurationManager();  
try \{  
  
if (ContactsApplication.getApplication().mMode == PrivateMode.MODE\_MPT1327\_ANALOG\_TRUNKING) \{  
contactsMemberItem = manager  
.getItemInfo(READ\_GROUP\_MEMBER\_KEY\_MPT);  
\} else if (ContactsApplication.getApplication().mMode == PrivateMode.MODE\_PDT\_DIGITAL\_TRUNKING) \{  
contactsMemberItem = manager  
.getItemInfo(READ\_GROUP\_MEMBER\_KEY\_PDT);  
\} else \{  
Log.d(TAG, "get current mode error or do not import");  
\}  
\} catch (ConfigurationException e) \{  
  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
e.printStackTrace();  
\}  
Log.d(TAG, "contactsMemberItem=="+contactsMemberItem);  
ArrayList<String> groupNumberAndNumberinfo = new ArrayList<String>();  
if (contactsMemberItem != null) \{  
List<ValueList> groupMemberItemList = contactsMemberItem.valueList;  
  
if (groupMemberItemList != null && groupMemberItemList.size() > 0) \{  
  
Log.d(TAG, "groupMemberItemList.size()=="+groupMemberItemList.size());  
for (ValueList valueList : groupMemberItemList) \{ // group\_number,number  
// ,  
Log.d(TAG, "Pctools group Body is :" + valueList.value  
\+ "id==" + valueList.id);  
String groupMemberinfoString = valueList.value;  
if (!TextUtils.isEmpty(groupMemberinfoString)) \{  
groupNumberAndNumberinfo.add(groupMemberinfoString);  
\} else \{  
continue;  
\}  
\}  
  
\} else \{  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
return;  
\}  
  
\} else \{  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
return;  
\}  
  
if (!groupNumberAndNumberinfo.isEmpty()) \{  
for (int i = 0; i < groupNumberAndNumberinfo.size(); i++) \{  
String groupNumberAndNumberinfoString = groupNumberAndNumberinfo  
.get(i);  
String\[\] groupNumberAndNumberinfoSplit = groupNumberAndNumberinfoString  
.split(",");  
ArrayList<ContentProviderOperation> rawContactOperations = new ArrayList<ContentProviderOperation>();  
int count = 0;  
for (int j = 1; j < groupNumberAndNumberinfoSplit.length; j++) \{  
  
int group\_id = -1;  
if (!TextUtils.isEmpty(groupNumberAndNumberinfoSplit\[0\])) \{  
group\_id = getGroupId(groupNumberAndNumberinfoSplit\[0\]);  
Log.d(TAG, "group\_id==" + group\_id);  
\} else \{  
break;  
\}  
if (!TextUtils.isEmpty(groupNumberAndNumberinfoSplit\[j\])) \{  
Log.d(TAG, "Cotnactsnumber="  
\+ groupNumberAndNumberinfoSplit\[j\]);  
int rawcontacts\_id = getContactId(groupNumberAndNumberinfoSplit\[j\]);  
Log.d(TAG, "rawContactId==" + rawcontacts\_id);  
  
// Build an insert operation to add the contact to  
// the group  
final ContentProviderOperation.Builder insertBuilder = ContentProviderOperation  
.newInsert(android.provider.ContactsContract.Data.CONTENT\_URI);  
insertBuilder.withValue(Data.RAW\_CONTACT\_ID,  
rawcontacts\_id);  
insertBuilder.withValue(Data.MIMETYPE,  
GroupMembership.CONTENT\_ITEM\_TYPE);  
insertBuilder.withValue(GroupMembership.GROUP\_ROW\_ID,  
group\_id);  
insertBuilder.withYieldAllowed(true);  
rawContactOperations.add(insertBuilder.build());  
\} else \{  
continue;  
\}  
try \{  
mContentResolver.applyBatch(ContactsContract.AUTHORITY,  
rawContactOperations);  
\} catch (Exception e) \{  
Log.e(TAG, Log.getStackTraceString(e));  
\}  
rawContactOperations.clear();  
\}  
  
\}  
  
\} else \{  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
return;  
\}  
importGroupDone = false;  
importContactsDone = false;  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
Log.d(TAG, "importPrivateGroupMember............done...end");  
\}  
  
  
private int importGroupContacts() \{  
  
Log.d(TAG, "Contacts GROUP import done............start");  
pctoolsFlag = SystemProperties.get("pctool.update.flag");  
//int mMode = -1;  
// if (pctoolsFlag.charAt(0) == '1') \{  
// mMode = PrivateMode.MODE\_MPT1327\_ANALOG\_TRUNKING;  
// \} else if (pctoolsFlag.charAt(0) == '0') \{  
// mMode = PrivateMode.MODE\_PDT\_DIGITAL\_TRUNKING;  
// \}  
  
final IPrivateTelephony privateTelephony = IPrivateTelephony.Stub  
.asInterface(ServiceManager.checkService("privatephone"));  
try \{  
  
List<GroupInfo> groupinList = privateTelephony.getAllGroups();  
Log.d(TAG, "getprivateManager groupinList===" + groupinList);  
String name = "";  
String num = "";  
String group\_type = "";  
int type = -1;  
boolean isHaveDefault = true;  
if (groupinList != null) \{  
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();  
for (GroupInfo groupInfo : groupinList) \{  
  
name = rmsemicolon(groupInfo.groupName);  
num = rmsemicolon(groupInfo.groupNumber);  
group\_type = rmsemicolon(String  
.valueOf(groupInfo.groupType));  
ContentProviderOperation.Builder builder = ContentProviderOperation  
.newInsert(Groups.CONTENT\_URI);  
builder.withValue(Groups.ACCOUNT\_TYPE,  
"sprd.com.android.account.phone");  
builder.withValue(  
Groups.ACCOUNT\_NAME,  
getApplicationContext().getString(  
R.string.show\_privategroupcontacts));  
builder.withValue(Groups.GROUP\_RESPONSE\_FLAG, groupInfo.responseGroup);  
if (Integer.valueOf(group\_type) == 2) \{ // dynamic group type  
builder.withValue(Groups.TITLE, getString(R.string.dynamic\_group\_name));  
\} else \{  
builder.withValue(Groups.TITLE, name);  
\}  
builder.withValue(Groups.GROUP\_NUMBER, num);  
builder.withValue(Groups.GROUP\_TYPE,  
Integer.valueOf(group\_type));  
builder.withValue(Groups.GROUP\_DEFAULT, 0);  
builder.withValue(Groups.GROUP\_BY\_IMPORT\_TYPE,  
Groups.GROUP\_IMPORT\_TYPE);  
builder.withValue(Groups.GROUP\_CURRENT\_MODE,  
Settings.Secure.getInt(ContactsApplication  
.getApplication().getContentResolver(),  
Settings.Secure.PRIVATE\_PHONE\_MODE,  
PrivateMode.MODE\_UNKNOWN));  
/\*  
\* builder.withValue(Groups.GROUP\_LOCATION,  
\* getCurrentLocatin());  
\*/  
  
String saveDeaultid = "";  
Log.d(TAG, "ContactsApplication.getApplication().mMode=="+ContactsApplication.getApplication().mMode);  
if (ContactsApplication.getApplication().mMode == PrivateMode.MODE\_PDT\_DIGITAL\_TRUNKING) \{ // PDT  
String saveDeaultid\_pdt = getPreferredDefaultGroupNumber(PREF\_FILE\_PDT);  
if (saveDeaultid\_pdt.equals(num)) \{  
builder.withValue(Groups.GROUP\_DEFAULT,  
Groups.GROUP\_DEFAULT\_FLAG);  
isHaveDefault = false;  
updateDefaultGroup(num);  
\}  
  
\} else if (ContactsApplication.getApplication().mMode == PrivateMode.MODE\_MPT1327\_ANALOG\_TRUNKING) \{// mpt  
String saveDeaultid\_mpt = getPreferredDefaultGroupNumber(PREF\_FILE\_MPT);  
if (saveDeaultid\_mpt.equals(num)) \{  
builder.withValue(Groups.GROUP\_DEFAULT,  
Groups.GROUP\_DEFAULT\_FLAG);  
isHaveDefault = false;  
updateDefaultGroup(num);  
\}  
\}  
operationList.add(builder.build());  
\}  
try \{  
  
mContentResolver.applyBatch(ContactsContract.AUTHORITY,  
operationList);  
Log.d(TAG, "mContentResolver done....");  
\} catch (RemoteException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
Log.d(TAG, "importGroupContacts RemoteException");  
\} catch (OperationApplicationException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
  
Log.d(TAG,  
"importGroupContacts OperationApplicationException");  
\}  
  
\} else \{  
Log.d(TAG, "importGroupContacts group list is null.");  
\}  
  
if (isHaveDefault) \{  
if (groupinList != null && groupinList.get(0) != null) \{  
updateDefaultGroup(groupinList.get(0).groupNumber);  
\}  
\}  
  
\} catch (Exception e1) \{  
// TODO Auto-generated catch block  
e1.printStackTrace();  
Log.d(TAG, "getprivateManager groupinList11>>");  
\}  
// mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
Log.d(TAG, "Contacts GROUP import done..........end..");  
return 0;  
\}  
  
private void importPrivateContacts() \{  
Log.d(TAG, "..........................importPrivateContacts..");  
/\*\*  
\* new read contacts method start  
\*/  
ConfigurationManager.Item contactsItem = null;  
ContentValues values = new ContentValues();  
ArrayList<String> pctoolsName = new ArrayList<String>();  
ArrayList<String> pctoolsNumber = new ArrayList<String>();  
ConfigurationManager manager = new ConfigurationManager();  
try \{  
  
if (ContactsApplication.getApplication().mMode == PrivateMode.MODE\_MPT1327\_ANALOG\_TRUNKING) \{  
contactsItem = manager  
.getItemInfo(READ\_CONTACTS\_MPT\_KEY);  
\} else if (ContactsApplication.getApplication().mMode == PrivateMode.MODE\_PDT\_DIGITAL\_TRUNKING) \{  
contactsItem = manager  
.getItemInfo(READ\_CONTACTS\_PDT\_KEY);  
\} else \{  
Log.d(TAG, "get current mode error or do not import");  
\}  
\} catch (ConfigurationException e) \{  
e.printStackTrace();  
\}  
if (contactsItem != null) \{  
List<ValueList> contactsItemList = contactsItem.valueList;  
  
if (contactsItemList != null && contactsItemList.size() > 0) \{  
  
Log.d(TAG,  
"contactsItemList.size()=="  
\+ contactsItemList.size());  
/\*\*  
\* when the new data is not empty and start delete the old data  
\*/  
deleteOldImportContacts(mMode);  
for (ValueList valueList : contactsItemList) \{ // group\_number,number  
// ,  
Log.d(TAG, "contacts Body is :" + valueList.value  
\+ "id==" + valueList.id);  
String contactsIteminfoString = valueList.value;  
if (!TextUtils.isEmpty(contactsIteminfoString)) \{  
  
String\[\] contactsIteminfoStringSplit = contactsIteminfoString  
.split(",");  
if (contactsIteminfoStringSplit\[2\] != null) \{  
pctoolsName  
.add(rmsemicolon(contactsIteminfoStringSplit\[2\]));  
\}  
if (contactsIteminfoStringSplit\[3\] != null) \{  
pctoolsNumber  
.add(rmsemicolon(contactsIteminfoStringSplit\[3\]));  
\}  
\} else \{  
continue;  
\}  
\}  
  
\} else \{  
return;  
\}  
  
\}  
for (int i = 0; i < pctoolsName.size(); i++) \{  
  
if (!pctoolsName.isEmpty() && !pctoolsNumber.isEmpty()) \{  
ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();  
int rawContactInsertIndex = 0;  
int size = ops.size();  
ops.add(ContentProviderOperation  
.newInsert(RawContacts.CONTENT\_URI)  
.withValue(RawContacts.ACCOUNT\_TYPE,  
"neolink.com.android.account.phone")  
.withValue(  
RawContacts.ACCOUNT\_NAME,  
R.string.show\_privatecontacts)  
.withValue(RawContacts.RAW\_CONTACT\_MODE\_TYPE,  
mMode)  
.withValue(RawContacts.RAW\_CONTACT\_IMPORT\_TYPE,  
RawContacts.CONTACTS\_BY\_PCTOOLS).build());  
ops.add(ContentProviderOperation  
.newInsert(  
android.provider.ContactsContract.Data.CONTENT\_URI)  
.withValueBackReference(Data.RAW\_CONTACT\_ID,  
rawContactInsertIndex)  
.withValue(Data.MIMETYPE,  
StructuredName.CONTENT\_ITEM\_TYPE)  
.withValue(StructuredName.GIVEN\_NAME,  
pctoolsName.get(i)).build());  
ops.add(ContentProviderOperation  
.newInsert(  
android.provider.ContactsContract.Data.CONTENT\_URI)  
.withValueBackReference(Data.RAW\_CONTACT\_ID,  
rawContactInsertIndex)  
.withValue(Data.MIMETYPE, Phone.CONTENT\_ITEM\_TYPE)  
.withValue(Phone.NUMBER, pctoolsNumber.get(i))  
.withValue(Phone.TYPE, Phone.TYPE\_MOBILE)  
.withValue(Phone.LABEL, " ").build());  
  
ops.add(ContentProviderOperation  
.newInsert(  
android.provider.ContactsContract.Data.CONTENT\_URI)  
.withValueBackReference(Data.RAW\_CONTACT\_ID,  
rawContactInsertIndex)  
.withValue(  
ContactsContract.CommonDataKinds.Photo.PHOTO,  
null)  
.withValue(  
ContactsContract.Data.MIMETYPE,  
ContactsContract.CommonDataKinds.Photo.CONTENT\_ITEM\_TYPE)  
.build());  
try \{  
  
getApplicationContext().getContentResolver()  
.applyBatch(ContactsContract.AUTHORITY, ops);  
\} catch (RemoteException e) \{  
Log.e(TAG,  
String.format("%s: %s", e.toString(),  
e.getMessage()));  
\} catch (OperationApplicationException e) \{  
Log.e(TAG,  
String.format("%s: %s", e.toString(),  
e.getMessage()));  
\}  
\}  
\}  
/\*\*  
\* when the contacts import finished and start import group member .  
\*/  
mContactsHander  
.sendEmptyMessage(EVENT\_IMPORT\_GROUPMEMBER);  
Log.d(TAG, "....end .........importPrivateContacts..");  
  
\}  
  
private int importDigNormalContactsAndGroup() \{  
  
Log.e(TAG, "importDigNormalContactsAndGroup in ");  
ArrayList<String> DigNormalDatainfo = new ArrayList<String>();  
try \{  
ConfigurationManager manager = new ConfigurationManager();  
ConfigurationManager.Item DigNormalItem = null;  
  
try \{  
  
DigNormalItem = manager.getItemInfo(READ\_DIG\_NORMAL\_DATA\_KEY);  
if (DigNormalItem != null) \{  
List<ValueList> DigNormalItemList = DigNormalItem.valueList;  
if (DigNormalItemList != null  
&& DigNormalItemList.size() > 0) \{  
for (ValueList valueList : DigNormalItemList) \{  
  
Log.d(TAG, " valueList.value==" + valueList.value);  
  
String digNormalinfoString = valueList.value;  
if (!TextUtils.isEmpty(digNormalinfoString)) \{  
DigNormalDatainfo.add(digNormalinfoString);  
Log.d(TAG, " valueList.value==in..");  
\} else \{  
continue;  
\}  
\}  
  
\} else \{  
Log.d(TAG,  
"DigNormalItem is null or DigNormalItemList.size() is 0");  
return -1;  
\}  
\} else \{  
Log.d(TAG, "DigNormalItem is null");  
return -1;  
\}  
\} catch (ConfigurationException e) \{  
e.printStackTrace();  
\}  
\} catch (Exception e) \{  
e.printStackTrace();  
\}  
Log.d(TAG, "import pctool data done" + DigNormalDatainfo.isEmpty()  
\+ DigNormalDatainfo.size());  
if (!DigNormalDatainfo.isEmpty()) \{  
deleteOldNormalDataInfo(mMode);  
ArrayList<ContentProviderOperation> groupOperationList = new ArrayList<ContentProviderOperation>();  
ArrayList<ContentProviderOperation> contactsOperationList = new ArrayList<ContentProviderOperation>();  
for (int i = 0; i < DigNormalDatainfo.size(); i++) \{  
String contactsAndGroupinfoString = DigNormalDatainfo.get(i);  
Log.d(TAG, "contactsAndGroupinfoString=="  
\+ contactsAndGroupinfoString);  
String\[\] contactsAndGroupinfoStringSplit = contactsAndGroupinfoString  
.split(",");  
if (contactsAndGroupinfoStringSplit\[1\] != null) \{  
Log.d(TAG, "contactsAndGroupinfoStringSplit\[1\]=="  
\+ contactsAndGroupinfoStringSplit\[1\]);  
//if ("1".equals(contactsAndGroupinfoStringSplit\[1\])) \{// 1:  
// group  
// number  
  
ContentProviderOperation.Builder builder = ContentProviderOperation  
.newInsert(Groups.CONTENT\_URI);  
builder.withValue(Groups.ACCOUNT\_TYPE,  
"neolink.com.android.account.phone");  
if("0".equals(contactsAndGroupinfoStringSplit\[1\]))\{  
builder.withValue(  
Groups.ACCOUNT\_NAME,  
getApplicationContext().getString(  
R.string.normal\_mode\_contact));  
builder.withValue(Groups.ACCOUNT\_TYPE,  
"neolink.com.android.account.phone");  
\}else\{  
builder.withValue(  
Groups.ACCOUNT\_NAME,  
getApplicationContext().getString(  
R.string.normal\_mode\_group));  
builder.withValue(Groups.ACCOUNT\_TYPE,  
"neolink.com.android.account.phone");  
\}  
  
Log.d(TAG, "contactsAndGroupinfoStringSplit\[1\])=="  
\+ "=" + contactsAndGroupinfoStringSplit\[1\]);  
// builder.withValue(Groups.DATA\_SET, " ");  
  
if (contactsAndGroupinfoStringSplit\[2\] != null) \{  
builder.withValue(Groups.TITLE,  
contactsAndGroupinfoStringSplit\[2\].substring(  
contactsAndGroupinfoStringSplit\[2\]  
.indexOf("\\"") + 1,  
contactsAndGroupinfoStringSplit\[2\]  
.lastIndexOf("\\"")));  
\}  
if (contactsAndGroupinfoStringSplit\[3\] != null) \{  
builder.withValue(Groups.GROUP\_NUMBER,  
contactsAndGroupinfoStringSplit\[3\].substring(  
contactsAndGroupinfoStringSplit\[2\]  
.indexOf("\\"") + 1,  
contactsAndGroupinfoStringSplit\[3\]  
.lastIndexOf("\\"")));  
\}  
// if("1".equals(contactsAndGroupinfoStringSplit\[1\]))\{  
// builder.withValue(Groups.GROUP\_TYPE, 1);  
// \}else\{  
//  
// \}  
builder.withValue(Groups.GROUP\_TYPE, 0);  
// builder.withValue(Groups.GROUP\_DEFAULT,  
// Groups.GROUP\_DEFAULT\_FLAG);  
builder.withValue(Groups.GROUP\_DEFAULT, 0);  
builder.withValue(Groups.GROUP\_BY\_IMPORT\_TYPE,  
Groups.GROUP\_IMPORT\_TYPE);  
builder.withValue(Groups.GROUP\_CURRENT\_MODE,  
Settings.Secure.getInt(ContactsApplication  
.getApplication().getContentResolver(),  
Settings.Secure.PRIVATE\_PHONE\_MODE,  
PrivateMode.MODE\_UNKNOWN));  
/\*  
\* builder.withValue(Groups.GROUP\_LOCATION,  
\* getCurrentLocatin());  
\*/  
groupOperationList.add(builder.build());  
//\} /\*\*else if ("0".equals(contactsAndGroupinfoStringSplit\[1\])) \{// 0  
// :  
// private  
// numer  
/\* if (contactsAndGroupinfoStringSplit\[2\].isEmpty()) \{  
contactsAndGroupinfoStringSplit\[2\] = mContext  
.getString(R.string.name\_unknow);  
\}  
if (contactsAndGroupinfoStringSplit\[3\].isEmpty()) \{  
contactsAndGroupinfoStringSplit\[3\] = mContext  
.getString(R.string.number\_unknow);  
\}  
Log.d(TAG, "contactsAndGroupinfoStringSplit\[1\])=="  
\+ "=" + contactsAndGroupinfoStringSplit\[1\]);  
int rawContactInsertIndex = 0;  
int size = contactsOperationList.size();  
contactsOperationList  
.add(ContentProviderOperation  
.newInsert(RawContacts.CONTENT\_URI)  
.withValue(RawContacts.ACCOUNT\_TYPE,  
"neolink.com.android.account.phone")  
.withValue(RawContacts.ACCOUNT\_NAME,  
R.string.show\_privatecontacts)  
.withValue(  
RawContacts.RAW\_CONTACT\_MODE\_TYPE,  
ContactsApplication  
.getApplication().mMode)  
.withValue(  
RawContacts.RAW\_CONTACT\_IMPORT\_TYPE,  
RawContacts.CONTACTS\_BY\_PCTOOLS)  
.build());  
contactsOperationList  
.add(ContentProviderOperation  
.newInsert(  
android.provider.ContactsContract.Data.CONTENT\_URI)  
.withValueBackReference(  
Data.RAW\_CONTACT\_ID,  
rawContactInsertIndex)  
.withValue(  
Data.MIMETYPE,  
StructuredName.CONTENT\_ITEM\_TYPE)  
.withValue(  
StructuredName.GIVEN\_NAME,  
contactsAndGroupinfoStringSplit\[2\])  
.build());  
contactsOperationList  
.add(ContentProviderOperation  
.newInsert(  
android.provider.ContactsContract.Data.CONTENT\_URI)  
.withValueBackReference(  
Data.RAW\_CONTACT\_ID,  
rawContactInsertIndex)  
.withValue(Data.MIMETYPE,  
Phone.CONTENT\_ITEM\_TYPE)  
.withValue(  
Phone.NUMBER,  
contactsAndGroupinfoStringSplit\[3\])  
.withValue(Phone.TYPE,  
Phone.TYPE\_MOBILE)  
.withValue(Phone.LABEL, " ").build());  
  
contactsOperationList  
.add(ContentProviderOperation  
.newInsert(  
android.provider.ContactsContract.Data.CONTENT\_URI)  
.withValueBackReference(  
Data.RAW\_CONTACT\_ID,  
rawContactInsertIndex)  
.withValue(  
ContactsContract.CommonDataKinds.Photo.PHOTO,  
null)  
.withValue(  
ContactsContract.Data.MIMETYPE,  
ContactsContract.CommonDataKinds.Photo.CONTENT\_ITEM\_TYPE)  
.build());  
\} else \{  
Log.d(TAG, "make sure the type is correct");  
\}\*\*/  
\}else\{  
Log.d(TAG, "data type is error");  
continue;  
\}  
\}  
if (!groupOperationList.isEmpty()) \{  
  
try \{  
  
ContentProviderResult\[\] result = mContentResolver  
.applyBatch(ContactsContract.AUTHORITY,  
groupOperationList);  
Log.d(TAG, "addDigNormalGroup done....");  
  
\} catch (RemoteException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
Log.d(TAG, "addDigNormalGroup RemoteException");  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
\} catch (OperationApplicationException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
Log.d(TAG,  
"addDigNormalGroup OperationApplicationException");  
\}  
\}  
if (!contactsOperationList.isEmpty()) \{  
try \{  
getApplicationContext().getContentResolver().applyBatch(  
ContactsContract.AUTHORITY, contactsOperationList);  
\} catch (RemoteException e) \{  
Log.e(TAG,  
String.format("%s: %s", e.toString(),  
e.getMessage()));  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
\} catch (OperationApplicationException e) \{  
Log.e(TAG,  
String.format("%s: %s", e.toString(),  
e.getMessage()));  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
\}  
\}  
  
\} else \{  
Log.d(TAG, "DigNormalDatainfo is empty ");  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
return -1;  
\}  
mHandler.sendEmptyMessage(EVENT\_DO\_FINISH);  
Log.d(TAG, "DigNormalDatainfo............done...end");  
return 0;  
\}  
  
/\*\*import the dynamic group info  
\*  
\* @param group\_name  
\* @param group\_number  
\* @return  
\*/  
private int addDynamicGroup(String group\_name, String group\_number)\{  
  
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();  
ContentProviderOperation.Builder builder = ContentProviderOperation  
.newInsert(Groups.CONTENT\_URI);  
builder.withValue(Groups.ACCOUNT\_TYPE, "neolink.com.android.account.phone");  
builder.withValue(Groups.ACCOUNT\_NAME, getApplicationContext()  
.getString(R.string.label\_phone));  
// builder.withValue(Groups.DATA\_SET, " ");  
builder.withValue(Groups.TITLE, group\_name);  
builder.withValue(Groups.GROUP\_NUMBER, group\_number);  
builder.withValue(Groups.GROUP\_TYPE, 2);  
// builder.withValue(Groups.GROUP\_DEFAULT, Groups.GROUP\_DEFAULT\_FLAG);  
builder.withValue(Groups.GROUP\_DEFAULT, 0);  
builder.withValue(Groups.GROUP\_BY\_IMPORT\_TYPE, Groups.GROUP\_IMPORT\_TYPE);  
builder.withValue(Groups.GROUP\_CURRENT\_MODE, Settings.Secure.getInt(  
ContactsApplication.getApplication().getContentResolver(),  
Settings.Secure.PRIVATE\_PHONE\_MODE, PrivateMode.MODE\_UNKNOWN));  
/\*  
\* builder.withValue(Groups.GROUP\_LOCATION, getCurrentLocatin());  
\*/  
operationList.add(builder.build());  
  
try \{  
  
ContentProviderResult\[\] result = mContentResolver.applyBatch(  
ContactsContract.AUTHORITY, operationList);  
Log.d(TAG, "addDynamicGroup done....");  
  
return 0;  
\} catch (RemoteException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
Log.d(TAG, "addDynamicGroup RemoteException");  
\} catch (OperationApplicationException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
  
Log.d(TAG, "addDynamicGroup OperationApplicationException");  
\}  
return -1;  
\}  
  
/\*\*  
\* input the number and out put the contact id  
\* @param number  
\* @return  
\*/  
public int getContactId(String number) \{  
Cursor rawcontacatsCurcor = null;  
try \{  
rawcontacatsCurcor = getContentResolver().query(Phone.CONTENT\_URI,  
new String\[\] \{ Phone.CONTACT\_ID, Phone.NUMBER \}, null,  
null, null);  
if (rawcontacatsCurcor != null && rawcontacatsCurcor.moveToFirst()) \{  
while (!rawcontacatsCurcor.isAfterLast()) \{  
if (PhoneNumberUtils.compare(number,  
rawcontacatsCurcor.getString(1))) \{  
return rawcontacatsCurcor.getInt(0);  
\}  
rawcontacatsCurcor.moveToNext();  
\}  
\}  
\} catch (Exception e) \{  
Log.e(TAG, "getContactId error:", e);  
e.printStackTrace();  
\} finally \{  
if (rawcontacatsCurcor != null) \{  
rawcontacatsCurcor.close();  
\}  
\}  
return -1;  
\}  
  
/\*\*  
\* input the number and get the group number id in database  
\*  
\* @param number  
\* @return  
\*/  
public int getGroupId(String number) \{  
  
Uri GROUP\_LIST\_URI = Groups.CONTENT\_SUMMARY\_URI;  
final String\[\] COLUMNS = new String\[\] \{ Groups.\_ID,  
Groups.GROUP\_NUMBER, Groups.GROUP\_CURRENT\_MODE \};  
int group\_id = -1;  
Cursor groupcurcor = getContentResolver()  
.query(GROUP\_LIST\_URI,  
COLUMNS,  
Groups.GROUP\_NUMBER + " =? " + " AND "  
\+ Groups.GROUP\_CURRENT\_MODE + " =?",  
new String\[\] \{  
number,  
String.valueOf(ContactsApplication  
.getApplication().mMode) \}, null);  
try \{  
while (groupcurcor.moveToNext()) \{  
group\_id = groupcurcor.getInt(0);  
return group\_id;  
\}  
  
\} catch (Exception e) \{  
Log.e(TAG, "getGroupId error:", e);  
e.printStackTrace();  
\} finally \{  
if (groupcurcor != null) \{  
groupcurcor.close();  
\}  
\}  
return -1;  
\}  
  
  
/\*\*  
\* delete the dynamic group  
\*  
\* @param group\_number  
\*/  
private void deleteDynamicGroup(String group\_number) \{  
  
String selecion = "";  
selecion = Groups.GROUP\_TYPE + " = " + "2";  
  
getContentResolver().delete(  
Groups.CONTENT\_URI  
.buildUpon()  
.appendQueryParameter(  
ContactsContract.CALLER\_IS\_SYNCADAPTER, "true")  
.build(), selecion, null);  
  
\}  
  
/\*\*  
\* delete the current mode group info when import the new group before .  
\*  
\* @param group\_number  
\*/  
private void deleteOldGroupInfo(String group\_number) \{  
  
String selecion = Groups.GROUP\_BY\_IMPORT\_TYPE + " = "  
\+ Groups.GROUP\_IMPORT\_TYPE;  
  
getContentResolver().delete(  
Groups.CONTENT\_URI  
.buildUpon()  
.appendQueryParameter(  
ContactsContract.CALLER\_IS\_SYNCADAPTER, "true")  
.build(), selecion, null);  
\}  
  
  
/\*\*  
\* delete the old normal data 2015.4.8  
\* @param mode  
\*/  
private void deleteOldNormalDataInfo(int mode) \{  
  
String selecion = Groups.GROUP\_CURRENT\_MODE + " = "  
\+ String.valueOf(mode);  
  
getContentResolver().delete(  
Groups.CONTENT\_URI  
.buildUpon()  
.appendQueryParameter(  
ContactsContract.CALLER\_IS\_SYNCADAPTER, "true")  
.build(), selecion, null);  
  
Log.d(TAG, "deleteOldNormalDataInfo done");  
\}  
  
/\*\*  
\* delete the old contacts when import the new contacts before  
\*  
\* @param mMode  
\* @return  
\*/  
public int deleteOldImportContacts(int mMode) \{  
  
final String\[\] CONTACT\_PROJECTION\_ALTERNATIVE = new String\[\] \{  
Contacts.\_ID, // 0  
Contacts.NAME\_RAW\_CONTACT\_ID, // 0  
Contacts.CONTACT\_IMPORT\_TYPE, Contacts.CONTACAT\_MODE\_TYPE,  
  
\};  
ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>();  
Uri uri = Contacts.CONTENT\_URI;  
Cursor curcor = getApplicationContext().getContentResolver().query(uri,  
CONTACT\_PROJECTION\_ALTERNATIVE, null, null, null);  
while (curcor.moveToNext()) \{  
  
int import\_type = curcor.getInt(curcor  
.getColumnIndex(Contacts.CONTACT\_IMPORT\_TYPE));  
  
int mode\_type = curcor.getInt(curcor  
.getColumnIndex(Contacts.CONTACAT\_MODE\_TYPE));  
  
int mode\_id = curcor.getInt(curcor  
.getColumnIndex(Contacts.NAME\_RAW\_CONTACT\_ID));  
Log.d(TAG, "import\_type" + import\_type + "mMode==" + mMode  
\+ "mode\_id=" + mode\_id + "mode\_type=" + mode\_type);  
if (import\_type == RawContacts.CONTACTS\_BY\_PCTOOLS  
&& mode\_type == mMode) \{  
operations.add(ContentProviderOperation.newDelete(Uri.withAppendedPath(ContactsContract.RawContacts.CONTENT\_URI,String.valueOf(mode\_id)))  
.withYieldAllowed(false)  
.build());  
operations.add(ContentProviderOperation.newDelete(ContactsContract.RawContacts.CONTENT\_URI)  
.withSelection(Contacts.\_ID+"="+mode\_id, null)  
.build());  
  
\}  
\}  
curcor.close();  
try \{  
Log.d(TAG, "deleteCurcor=="+operations.size());  
getApplicationContext().getContentResolver().applyBatch(ContactsContract.AUTHORITY, operations);  
Log.d(TAG, "delete contact success");  
\} catch (Exception e) \{  
Log.d(TAG, "delete contact failed");  
Log.e(TAG, e.getMessage());  
\}  
  
return Log.w(TAG, "\*\*delete end\*\*");  
\}  
  
/\*\*  
\* when changed the group databse and update the default group flag  
\*  
\* @param defaultGroupNumber  
\* @return  
\*/  
public int updateDefaultGroup(String defaultGroupNumber) \{  
  
Log.d(TAG, "..........................updateDefaultGroup start.."  
\+ "defaultGroupNumber==" + defaultGroupNumber);  
ContentValues updateDefaultGroupValue = new ContentValues();  
updateDefaultGroupValue.put(Groups.GROUP\_DEFAULT,  
Groups.GROUP\_DEFAULT\_FLAG);  
updateDefaultGroupValue.put(Groups.GROUP\_CURRENT\_MODE, Settings.Secure  
.getInt(ContactsApplication.getApplication()  
.getContentResolver(),  
Settings.Secure.PRIVATE\_PHONE\_MODE,  
PrivateMode.MODE\_UNKNOWN));  
updateDefaultGroupValue.put(Groups.GROUP\_NUMBER, defaultGroupNumber);  
String\[\] args = \{ defaultGroupNumber \};  
  
mContext.getContentResolver().update(Groups.CONTENT\_URI,  
updateDefaultGroupValue, Groups.GROUP\_NUMBER + "=?", args);  
Log.d(TAG, "..........................updateDefaultGroup end..");  
return 0;  
\}  
  
/\*\*  
\* Remove the string ends semicolon by xuhong.tian  
\* @param htmlStr  
\* @return  
\*/  
public String rmsemicolon(String htmlStr) \{  
String result = "";  
boolean flag = true;  
if (htmlStr == null) \{  
return null;  
\}  
htmlStr = htmlStr.replace("\\"", "");  
char\[\] a = htmlStr.toCharArray();  
int length = a.length;  
for (int i = 0; i < length; i++) \{  
if (a\[i\] == '<') \{  
flag = false;  
continue;  
\}  
if (a\[i\] == '>') \{  
flag = true;  
continue;  
\}  
if (flag == true) \{  
result += a\[i\];  
\}  
\}  
return result.toString();  
\}  
  
private void resetProperties() \{  
SystemProperties.set("lte.pctool.contact.update", "0");  
SystemProperties.set("lte.pctool.contact.clear", "0");  
\}  
  
/\*  
\* String getCurrentLocatin() \{  
\*  
\* int radomNUmber = (int) (Math.random() \* 6 + 1);  
\*  
\* String\[\] location = new String\[\] \{  
\* mContext.getString(R.string.location\_1),  
\* mContext.getString(R.string.location\_2),  
\* mContext.getString(R.string.location\_3),  
\* mContext.getString(R.string.location\_4),  
\* mContext.getString(R.string.location\_5,  
\* mContext.getString(R.string.location\_6)) \};  
\*  
\* return location\[3\]; \}  
\*/  
  
boolean updateimportGroupMember() \{  
Log.d(TAG, "importGroupDone=="+importGroupDone+"importContactsDone=="+importContactsDone+"pctoolsFlag.charAt(6) == '0'="+pctoolsFlag.charAt(6));  
if (importGroupDone && importContactsDone) \{ // start  
return true;  
\} else if (importGroupDone && pctoolsFlag.charAt(6) == '0') \{ // mode changed  
return true;  
\} else \{  
return false;  
\}  
  
\}  
  
/\*\*  
\* save the default group info  
\*  
\* @param filter  
\* @return  
\*/  
private String getPreferredDefaultGroupNumber(String filter) \{  
  
SharedPreferences sp = null;  
try \{  
Context c = mContext.createPackageContext(  
"com.android.providers.contacts",  
Context.CONTEXT\_IGNORE\_SECURITY);  
sp = c.getSharedPreferences(filter, Context.MODE\_WORLD\_READABLE  
| Context.MODE\_MULTI\_PROCESS);  
  
\} catch (NameNotFoundException e) \{  
// TODO Auto-generated catch block  
e.printStackTrace();  
\}  
return sp.getString(PREF\_FILE\_NUMBER, "0");  
\}  
  
\}