增删该查联系人的 service-蒲公英云

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 groupNumberAndNumberinfo = new ArrayList();
if (contactsMemberItem != null) {
List 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;
}

if (!groupNumberAndNumberinfo.isEmpty()) {
for (int i = 0; i < groupNumberAndNumberinfo.size(); i++) {
String groupNumberAndNumberinfoString = groupNumberAndNumberinfo
.get(i);
String[] groupNumberAndNumberinfoSplit = groupNumberAndNumberinfoString
.split(“,”);
ArrayList rawContactOperations = new ArrayList();
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 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 operationList = new ArrayList();
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 pctoolsName = new ArrayList();
ArrayList pctoolsNumber = new ArrayList();
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 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 ops = new ArrayList();
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 DigNormalDatainfo = new ArrayList();
try {
ConfigurationManager manager = new ConfigurationManager();
ConfigurationManager.Item DigNormalItem = null;

try {

DigNormalItem = manager.getItemInfo(READ_DIG_NORMAL_DATA_KEY);
if (DigNormalItem != null) {
List 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 groupOperationList = new ArrayList();
ArrayList contactsOperationList = new ArrayList();
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 operationList = new ArrayList();
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 operations = new ArrayList();
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”);
}

}