自己动手写 android 数据库（2）

小灰灰 2022-08-05 07:29 283阅读 0赞

package com.neolink.providers.contacts;  
  
import java.text.Collator;  
import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Locale;  
import java.util.concurrent.CountDownLatch;  
import java.util.regex.Pattern;  
  
import com.android.common.content.ProjectionMap;  
import com.google.android.collect.Maps;  
import com.neolink.providers.contacts.PrivateContactsDataHelper.Tables;  
import com.neolink.providers.contacts.PrivateContactsDataHelper.Views;  
import com.neolink.providers.util.HanziToPinyin;  
import com.neolink.providers.util.HanziToPinyin.Token;  
import com.neolink.providers.util.Utils;  
  
import android.accounts.Account;  
import android.accounts.AccountManager;  
import android.content.ContentProvider;  
import android.content.ContentProviderOperation;  
import android.content.ContentProviderResult;  
import android.content.ContentUris;  
import android.content.ContentValues;  
import android.content.Context;  
import android.content.OperationApplicationException;  
import android.content.UriMatcher;  
import android.content.pm.ProviderInfo;  
import android.content.res.Resources;  
import android.database.AbstractCursor;  
import android.database.Cursor;  
import android.database.DatabaseUtils;  
import android.database.sqlite.SQLiteCantOpenDatabaseException;  
import android.database.sqlite.SQLiteDatabase;  
import android.database.sqlite.SQLiteDoneException;  
import android.database.sqlite.SQLiteFullException;  
import android.database.sqlite.SQLiteQueryBuilder;  
import android.database.sqlite.SQLiteStatement;  
import android.database.sqlite.SQLiteTransactionListener;  
import android.net.Uri;  
import android.os.Bundle;  
import android.os.Handler;  
import android.os.HandlerThread;  
import android.os.Message;  
import android.os.Process;  
import android.os.StrictMode;  
import android.provider.BaseColumns;  
import android.provider.OpenableColumns;  
import android.provider.Settings;  
import android.provider.CallLog.Calls;  
import android.provider.ContactsContract.ContactCounts;  
import android.text.TextUtils;  
import android.util.Log;  
import android.webkit.MHTUtil;  
import neolink.telephony.PrivateContactConst;  
import neolink.telephony.PrivateContactContracts;  
import neolink.telephony.PrivateManager;  
import neolink.telephony.PrivateMode;  
import neolink.telephony.PrivateContactConst.DataKindMimeType;  
import neolink.telephony.PrivateContactContracts.CallLogColumns;  
import neolink.telephony.PrivateContactContracts.Contacts;  
import neolink.telephony.PrivateContactContracts.ContactsColumns;  
import neolink.telephony.PrivateContactContracts.Data;  
import neolink.telephony.PrivateContactContracts.DataColumns;  
import neolink.telephony.PrivateContactContracts.GroupContact;  
import neolink.telephony.PrivateContactContracts.GroupContactColumns;  
import neolink.telephony.PrivateContactContracts.MimetypesColumns;  
import neolink.telephony.PrivateContactContracts.ZoneColumns;  
import android.app.Application;  
import android.app.SearchManager;  
  
public class PrivateContactsProvider extends ContentProvider implements  
SQLiteTransactionListener \{  
public static final String LOG\_TAG = "PrivateContactsProvider";  
private HandlerThread mBackgroundThread;  
private Handler mBackgroundHandler;  
private static final UriMatcher URI\_MATCHER = new UriMatcher(  
UriMatcher.NO\_MATCH);  
  
private PrivateContactsDataHelper mPrivateContactsDatabaseHelper;  
private SQLiteStatement mContactDisplayNameUpdate;  
private SQLiteStatement mContactToDataUpdate;  
private SQLiteStatement mContactToCallLogUpdate;  
private SQLiteStatement mGroupToDataUpdate;  
  
private PrivateContactTransactionContext mContactTransactionContext = new PrivateContactTransactionContext();  
private final ThreadLocal<PrivateContactTransactionContext> mTransactionContext = new ThreadLocal<PrivateContactTransactionContext>();  
  
private static final int PRIVATE\_CONTACTS = 100;  
private static final int PRIVATE\_CONTACTS\_ID = 101;  
private static final int PRIVATE\_CONTACTS\_ID\_DATAS = 102;  
private static final int DATABASE\_VERSION = 2;  
private static HashMap<String, String> sNotesProjectionMap;  
private static final int PRIVATE\_DATA = 200;  
private static final int PRIVATE\_DATA\_GROUP = 201;  
private static final int PRIVATE\_DATA\_CONTACTS = 202;  
private static final int PRIVATE\_DATA\_ID = 203;  
  
private static final int PRIVATE\_GROUP\_CONTACT = 300;  
private static final int PRIVATE\_GROUP\_CONTACT\_ID = 301;  
  
private static final int PRIVATE\_GROUP\_TYPE = 111;  
  
private static final int PRIVATE\_CALLLOG = 115;  
private static final int PRIVATE\_CALLLOG\_ID = 116;  
  
private static final int PRIVATE\_INDEXSEARCH\_ID = 800;  
private static final int PRIVATE\_GROUP\_ZONE = 801;  
private static final int PRIVATE\_MIMETYPE = 802;  
  
private final ThreadLocal<SQLiteDatabase> mDb = new ThreadLocal<SQLiteDatabase>();  
private final ThreadLocal<PrivateContactsDataHelper> mDbHelper = new ThreadLocal<PrivateContactsDataHelper>();  
  
private HashMap<String, Long> mMimeTypeCache;  
private final HashMap<String, Long> mZoneIdCache = new HashMap<String, Long>();  
  
public static final String UPDATE\_CONTACTS = "SELECT "  
\+ DataColumns.MIMETYPE\_ID + "," + Data.DATA1 + "," + Data.DATA2  
\+ "," + Data.DATA3 + " FROM " + Tables.PRIVATE\_DATA + " WHERE "  
\+ Data.CONTACT\_ID + " = ?";  
  
public static final String UPDATE\_CALL\_LOG\_FROM\_CONTACTS = "SELECT "  
\+ ContactsColumns.\_ID + "," + ContactsColumns.DISPLAY\_NAME  
\+ " FROM " + Tables.PRIVATE\_CONTACT + " WHERE "  
\+ ContactsColumns.NUMBER + " =? ";  
  
public static final String UPDATE\_CALL\_LOG\_FROM\_GROUP = "SELECT "  
\+ GroupContactColumns.\_ID + ","  
\+ GroupContactColumns.GROUP\_MODE\_TYPE + ","  
\+ GroupContactColumns.GROUP\_CONTACT\_NUMBER + " FROM "  
\+ Tables.PRIVATE\_CONTACT + " WHERE ("  
\+ GroupContactColumns.GROUP\_MODE\_TYPE + " = ?" + " AND "  
\+ GroupContactColumns.GROUP\_CONTACT\_NUMBER + " = ?" + " )";  
  
static \{  
  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "contacts",  
PRIVATE\_CONTACTS);  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "contacts/\#",  
PRIVATE\_CONTACTS\_ID);  
  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY,  
"contacts\_filter/\#", PRIVATE\_INDEXSEARCH\_ID);  
  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY,  
"contacts/\#/datas", PRIVATE\_CONTACTS\_ID\_DATAS);  
  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "p\_data",  
PRIVATE\_DATA);  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "p\_data/\#",  
PRIVATE\_DATA\_ID);  
  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "p\_data\_group",  
PRIVATE\_DATA\_GROUP);  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "p\_data\_contact",  
PRIVATE\_DATA\_CONTACTS);  
  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "p\_groups",  
PRIVATE\_GROUP\_CONTACT);  
  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY,  
"PrivateGroupContact/\#", PRIVATE\_GROUP\_CONTACT\_ID);  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY,  
"PrivateGroupContact/\#", PRIVATE\_GROUP\_TYPE);  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "p\_calls/\#",  
PRIVATE\_CALLLOG\_ID);  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "p\_calls",  
PRIVATE\_CALLLOG);  
  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "p\_zone",  
PRIVATE\_GROUP\_ZONE);  
URI\_MATCHER.addURI(PrivateContactContracts.AUTHORITY, "p\_type",  
PRIVATE\_MIMETYPE);  
\}  
  
/\*\* Contains just the contacts columns \*/  
private static final ProjectionMap sContactsColumns = ProjectionMap  
.builder().add(PrivateContactContracts.ContactsColumns.\_ID)  
.add(ContactsColumns.NUMBER).add(ContactsColumns.DISPLAY\_NAME)  
.add(ContactsColumns.CONTACTS\_PCTOOLS)  
.add(ContactsColumns.CONTACTS\_TYPE)  
.add(ContactsColumns.CURRENT\_MODE).add(ContactsColumns.SORT\_KEY)  
.build();  
  
/\*\* Contains just the zone columns \*/  
private static final ProjectionMap sZoneColumns = ProjectionMap.builder()  
.add(PrivateContactContracts.ZoneColumns.\_ID)  
.add(ZoneColumns.ZONE\_NAME).build();  
  
/\*\* Contains just the group columns \*/  
private static final ProjectionMap sGroupsColumns = ProjectionMap.builder()  
.add(PrivateContactContracts.ContactsColumns.\_ID)  
.add(GroupContactColumns.GROUP\_ID)  
.add(GroupContactColumns.GROUP\_CONTACT\_NAME)  
.add(GroupContactColumns.GROUP\_CONTACT\_NUMBER)  
.add(GroupContactColumns.GROUP\_CONTACT\_TYPE)  
.add(GroupContactColumns.GROUP\_ZONE\_NAME)  
.add(GroupContactColumns.GROUP\_ZONE\_ID)  
.add(GroupContactColumns.GROUP\_DEFAULT)  
.add(GroupContactColumns.GROUP\_MODE\_TYPE).build();  
  
/\*\* Contains just the data columns \*/  
private static final ProjectionMap sDataColumns = ProjectionMap.builder()  
.add(DataColumns.\_ID).add(DataColumns.GROUP\_ID)  
.add(DataColumns.MIMETYPE\_ID).add(DataColumns.CONTACT\_ID)  
.add(DataColumns.DATA1).add(DataColumns.DATA2)  
.add(DataColumns.DATA3).build();  
  
/\*\* Contains just the call log columns \*/  
private static final ProjectionMap sCallLogColumns = ProjectionMap  
.builder().add(CallLogColumns.\_ID).add(CallLogColumns.NUMBER)  
.add(CallLogColumns.DISPLAY\_NAME).add(CallLogColumns.DATE)  
.add(CallLogColumns.DURATION).add(CallLogColumns.CALL\_LOG\_MODE)  
.add(CallLogColumns.IS\_READ).add(CallLogColumns.IS\_HANDUP)  
.add(CallLogColumns.IS\_NEW).build();  
  
/\*\* Contains just the call the mimetype columns \*/  
private static final ProjectionMap sMimetypeColumns = ProjectionMap  
.builder().add(MimetypesColumns.\_ID).add(MimetypesColumns.MIMETYPE)  
.build();  
  
private volatile PrivateContactsCountDownLatch mReadAccessLatch;  
private volatile PrivateContactsCountDownLatch mWriteAccessLatch;  
private int mMode;  
  
@Override  
public boolean onCreate() \{  
Utils.logProvider("on create");  
mPrivateContactsDatabaseHelper = PrivateContactsDataHelper  
.getInstance(getContext());  
mTransactionContext.set(mContactTransactionContext);  
mMimeTypeCache = mPrivateContactsDatabaseHelper.mMimetypeCache;  
mDbHelper.set(mPrivateContactsDatabaseHelper);  
initialize();  
return true;  
\}  
  
private boolean initialize() \{  
  
mReadAccessLatch = new PrivateContactsCountDownLatch(1);  
mWriteAccessLatch = new PrivateContactsCountDownLatch(1);  
mBackgroundThread = new HandlerThread("ContactsProviderWorker",  
Process.THREAD\_PRIORITY\_BACKGROUND);  
mBackgroundThread.start();  
mBackgroundHandler = new Handler(mBackgroundThread.getLooper()) \{  
@Override  
public void handleMessage(Message msg) \{  
performBackgroundTask(msg.what, msg.obj);  
\}  
\};  
  
return true;  
\}  
  
protected void performBackgroundTask(int task, Object arg) \{  
switch (task) \{  
\}  
\}  
  
private void waitForAccess(PrivateContactsCountDownLatch latch) \{  
if (latch == null) \{  
return;  
\}  
  
while (true) \{  
try \{  
latch.await();  
return;  
\} catch (InterruptedException e) \{  
Thread.currentThread().interrupt();  
\}  
\}  
\}  
  
protected void scheduleBackgroundTask(int task) \{  
mBackgroundHandler.sendEmptyMessage(task);  
\}  
  
protected void scheduleBackgroundTask(int task, Object arg) \{  
mBackgroundHandler.sendMessage(mBackgroundHandler.obtainMessage(task,  
arg));  
\}  
  
public Cursor query(Uri uri, String\[\] projection, String selection,  
String\[\] selectionArgs, String sortOrder) \{  
  
int match = URI\_MATCHER.match(uri);  
Utils.logProvider("PrivateContactsProvider query uri is:" + uri  
\+ " selection is:" + selection + " sortOrder is:" + sortOrder  
\+ "match=" + match);  
  
if (selectionArgs != null) \{  
for (int i = 0; i < selectionArgs.length; i++) \{  
Utils.logProvider("selectionArgs==" + selectionArgs\[i\]);  
\}  
\}  
checkReadableDB();  
// waitForAccess(mWriteAccessLatch);  
SQLiteQueryBuilder qb = new SQLiteQueryBuilder();  
switch (match) \{  
case PRIVATE\_INDEXSEARCH\_ID:  
  
setTablesAndProjectionMapFroPrivateIndexSearch(qb, uri);  
final String\[\] PROJECTION = new String\[\] \{  
PrivateContactContracts.ContactsColumns.\_ID,  
Contacts.DISPLAY\_NAME, Contacts.SEARCH\_INDEX\_NAME,  
Contacts.SEARCH\_INDEX\_NUMBER \};  
String\[\] selectionArgsIndex = null;  
if (!TextUtils.isEmpty(selection)) \{  
  
String pingyingName = getFullPinYin(selection);// get the  
// pingyin name;  
String firstName = getFirstPinYin(selection); // get the first  
// name;  
selectionArgsIndex = new String\[pingyingName.length()\];  
  
if (!isNumeric(pingyingName)) \{  
  
selection = "search\_index like ?";  
for (int i = 0; i < pingyingName.length() - 1; i++) \{  
selection = selection + "or search\_index like ?"  
\+ "or number like ?";  
\}  
for (int i = 0; i < pingyingName.length(); i++) \{  
selectionArgsIndex\[i\] = "%" + pingyingName + "%";  
\}  
  
\} else \{  
selection = "number like ?";  
for (int i = 0; i < pingyingName.length() - 1; i++) \{  
selection = selection + "or number like ?"  
\+ "or number like ?";  
\}  
for (int i = 0; i < pingyingName.length(); i++) \{  
selectionArgsIndex\[i\] = "%" + pingyingName + "%";  
\}  
  
\}  
\} else \{  
selection = null;  
selectionArgs = null;  
  
\}  
Cursor cursorIndex = qb.query(mDb.get(), PROJECTION, selection,  
selectionArgsIndex, null, null, sortOrder);  
if (cursorIndex != null) \{  
cursorIndex.setNotificationUri(getContext()  
.getContentResolver(),  
PrivateContactContracts.AUTHORITY\_URI);  
\}  
return cursorIndex;  
  
case PRIVATE\_CONTACTS:  
setTablesAndProjectionMapForPrivateContact(qb, uri);  
Cursor contactscursor = qb.query(mDb.get(), projection, selection,  
selectionArgs, null, null, sortOrder);  
Utils.logProvider("PrivateContatProvider after nomal query cursor :"  
\+ contactscursor);  
if (contactscursor != null) \{  
contactscursor.setNotificationUri(getContext()  
.getContentResolver(),  
PrivateContactContracts.AUTHORITY\_URI);  
\}  
return contactscursor;  
case PRIVATE\_CONTACTS\_ID\_DATAS:  
List<String> pathSegments = uri.getPathSegments();  
  
for (String s : pathSegments) \{  
Utils.logProvider("PrivateContactsProvider query pathSegments s:"  
\+ s);  
\}  
long contactId = Long.parseLong(pathSegments.get(1));  
setTablesAndProjectionMapForData(qb, uri);  
selectionArgs = insertSelectionArg(selectionArgs,  
String.valueOf(contactId));  
qb.appendWhere(Data.CONTACT\_ID + " = ? ");  
StringBuffer sbTemp = new StringBuffer();  
for (String s : projection) \{  
sbTemp.append(s + ",");  
\}  
Utils.logProvider("PrivateContactsProvider projection :"  
\+ sbTemp.toString() + " selection :" + selection  
\+ " selectionArgs :" + sbTemp.toString());  
sbTemp = new StringBuffer();  
for (String s : selectionArgs) \{  
sbTemp.append(s + ",");  
\}  
break;  
case PRIVATE\_CONTACTS\_ID:  
long contact\_Id = ContentUris.parseId(uri);  
setTablesAndProjectionMapForData(qb, uri);  
selectionArgs = insertSelectionArg(selectionArgs,  
String.valueOf(contact\_Id));  
qb.appendWhere(Data.CONTACT\_ID + " = ? ");  
break;  
case PRIVATE\_GROUP\_ZONE:  
setTablesAndProjectionMapFroPrivateZone(qb, uri);  
Cursor groupCursor = qb.query(mDb.get(), projection, selection,  
selectionArgs, null, null, sortOrder);  
return groupCursor;  
  
case PRIVATE\_GROUP\_CONTACT:  
setTablesAndProjectionMapFroPrivateGroupContact(qb, uri);  
Cursor zoneCursor = qb.query(mDb.get(), projection, selection,  
selectionArgs, null, null, sortOrder);  
return zoneCursor;  
case PRIVATE\_CALLLOG:  
setTablesAndProjectionMapFroPrivateCall(qb, uri);  
Cursor CallLogCursor = qb.query(mDb.get(), projection, selection,  
selectionArgs, null, null, sortOrder);  
return CallLogCursor;  
case PRIVATE\_DATA:  
  
setTablesAndProjectionMapForData(qb, uri);  
Cursor cursor = qb.query(mDb.get(), projection, selection,  
selectionArgs, null, null, sortOrder);  
  
return cursor;  
case PRIVATE\_DATA\_CONTACTS:  
  
setTablesAndProjectionMapForData(qb, uri);  
Cursor datacursor = qb.query(mDb.get(), projection, selection,  
selectionArgs, null, null, sortOrder);  
  
return datacursor;  
  
case PRIVATE\_DATA\_GROUP:  
  
setTablesAndProjectionMapForData(qb, uri);  
Cursor groupcursor = qb.query(mDb.get(), projection, selection,  
selectionArgs, null, null, sortOrder);  
  
return groupcursor;  
default:  
Utils.logProvider(" the url is error");  
\}  
return null;  
\}  
  
private String\[\] insertSelectionArg(String\[\] selectionArgs, String arg) \{  
if (selectionArgs == null) \{  
return new String\[\] \{ arg \};  
\} else \{  
int newLength = selectionArgs.length + 1;  
String\[\] newSelectionArgs = new String\[newLength\];  
newSelectionArgs\[0\] = arg;  
System.arraycopy(selectionArgs, 0, newSelectionArgs, 1,  
selectionArgs.length);  
return newSelectionArgs;  
\}  
\}  
  
private static final class AddressBookIndexQuery \{  
public static final String LETTER = "letter";  
public static final String TITLE = "title";  
public static final String COUNT = "count";  
  
public static final String\[\] COLUMNS = new String\[\] \{ LETTER, TITLE,  
COUNT \};  
  
public static final int COLUMN\_LETTER = 0;  
public static final int COLUMN\_TITLE = 1;  
public static final int COLUMN\_COUNT = 2;  
  
// The first letter of the sort key column is what is used for the index  
// headings.  
public static final String SECTION\_HEADING = "SUBSTR(%1$s,1,1)";  
  
public static final String ORDER\_BY = LETTER + " COLLATE "  
\+ "PHONEBOOK";  
\}  
  
private Cursor bundleLetterCountExtras(Cursor cursor,  
final SQLiteDatabase DB, SQLiteQueryBuilder qb, String selection,  
String\[\] selectionArgs, String sortOrder, String countExpression) \{  
if (!(cursor instanceof AbstractCursor)) \{  
Log.w(LOG\_TAG,  
"Unable to bundle extras. Cursor is not AbstractCursor.");  
return cursor;  
\}  
checkReadableDB();  
String sortKey;  
String sortOrderSuffix = "";  
if (sortOrder != null) \{  
int spaceIndex = sortOrder.indexOf(' ');  
if (spaceIndex != -1) \{  
sortKey = sortOrder.substring(0, spaceIndex);  
sortOrderSuffix = sortOrder.substring(spaceIndex);  
\} else \{  
sortKey = sortOrder;  
\}  
\} else \{  
sortKey = Contacts.SORT\_KEY;  
\}  
  
String locale = Locale.getDefault().toString();  
  
HashMap<String, String> projectionMap = Maps.newHashMap();  
String sectionHeading = String.format(Locale.US,  
AddressBookIndexQuery.SECTION\_HEADING, sortKey);  
projectionMap.put(AddressBookIndexQuery.LETTER, sectionHeading + " AS "  
\+ AddressBookIndexQuery.LETTER);  
  
// If "what to count" is not specified, we just count all records.  
if (TextUtils.isEmpty(countExpression)) \{  
countExpression = "\*";  
\}  
projectionMap.put(AddressBookIndexQuery.TITLE, "GET\_PHONEBOOK\_INDEX("  
\+ sectionHeading + ",'" + locale + "')" + " AS "  
\+ AddressBookIndexQuery.TITLE);  
projectionMap.put(AddressBookIndexQuery.COUNT, "COUNT("  
\+ countExpression + ") AS " + AddressBookIndexQuery.COUNT);  
qb.setProjectionMap(projectionMap);  
  
Cursor indexCursor = qb.query(mDb.get(), AddressBookIndexQuery.COLUMNS,  
selection, selectionArgs, AddressBookIndexQuery.ORDER\_BY,  
null /\* having \*/, AddressBookIndexQuery.ORDER\_BY  
\+ sortOrderSuffix);  
  
try \{  
int groupCount = indexCursor.getCount();  
Utils.logProvider("ContactsProvider2 bundleLetterCountExtra groupCount is:"  
\+ groupCount);  
String titles\[\] = new String\[groupCount\];  
int counts\[\] = new int\[groupCount\];  
int indexCount = 0;  
String currentTitle = null;  
  
// Since GET\_PHONEBOOK\_INDEX is a many-to-1 function, we may end up  
// with multiple entries for the same title. The following code  
// collapses those duplicates.  
for (int i = 0; i < groupCount; i++) \{  
indexCursor.moveToNext();  
String title = indexCursor  
.getString(AddressBookIndexQuery.COLUMN\_TITLE);  
int count = indexCursor  
.getInt(AddressBookIndexQuery.COLUMN\_COUNT);  
Utils.logProvider("ContactsProvider2 bundleLetterCountExtra currentTitle is:"  
\+ currentTitle  
\+ " title is:"  
\+ title  
\+ " count is:"  
\+ count);  
if (indexCount == 0 || !TextUtils.equals(title, currentTitle)) \{  
titles\[indexCount\] = currentTitle = title;  
counts\[indexCount\] = count;  
indexCount++;  
\} else \{  
counts\[indexCount - 1\] += count;  
\}  
\}  
Utils.logProvider("ContactsProvider2 bundleLetterCountExtra indexCount is:"  
\+ indexCount);  
if (indexCount < groupCount) \{  
String\[\] newTitles = new String\[indexCount\];  
System.arraycopy(titles, 0, newTitles, 0, indexCount);  
titles = newTitles;  
  
int\[\] newCounts = new int\[indexCount\];  
System.arraycopy(counts, 0, newCounts, 0, indexCount);  
counts = newCounts;  
\}  
  
final Bundle bundle = new Bundle();  
bundle.putStringArray(  
ContactCounts.EXTRA\_ADDRESS\_BOOK\_INDEX\_TITLES, titles);  
bundle.putIntArray(ContactCounts.EXTRA\_ADDRESS\_BOOK\_INDEX\_COUNTS,  
counts);  
((AbstractCursor) cursor).setExtras(bundle);  
return cursor;  
\} finally \{  
indexCursor.close();  
\}  
\}  
  
private boolean readBooleanQueryParameter(Uri uri, String parameter,  
boolean defaultValue) \{  
String query = uri.getEncodedQuery();  
if (query == null) \{  
return defaultValue;  
\}  
int index = query.indexOf(parameter);  
if (index == -1) \{  
return defaultValue;  
\}  
index += parameter.length();  
return !matchQueryParameter(query, index, "=0", false)  
&& !matchQueryParameter(query, index, "=false", true);  
\}  
  
private static boolean matchQueryParameter(String query, int index,  
String value, boolean ignoreCase) \{  
Utils.logProvider("COntactsProvider2 matchQueryParameter query is:"  
\+ query + " index is:" + index + "value is:" + value  
\+ "ingnore is:" + ignoreCase);  
int length = value.length();  
return query.regionMatches(ignoreCase, index, value, 0, length)  
&& (query.length() == index + length || query.charAt(index  
\+ length) == '&');  
\}  
  
private void setTablesAndProjectionMapForPrivateContact(  
SQLiteQueryBuilder qb, Uri uri) \{  
StringBuilder sb = new StringBuilder();  
sb.append(Views.PRIVATE\_CONTACT);  
qb.setProjectionMap(sContactsColumns);  
qb.setTables(sb.toString());  
\}  
  
private void setTablesAndProjectionMapFroPrivateGroupContact(  
SQLiteQueryBuilder qb, Uri uri) \{  
qb.setTables(Tables.PRIVATE\_GROUP\_CONTACT);  
qb.setProjectionMap(sGroupsColumns);  
\}  
  
private void setTablesAndProjectionMapFroPrivateZone(SQLiteQueryBuilder qb,  
Uri uri) \{  
qb.setTables(Tables.PRIVATE\_ZONE);  
qb.setProjectionMap(sZoneColumns);  
\}  
  
private void setTablesAndProjectionMapFroPrivateIndexSearch(  
SQLiteQueryBuilder qb, Uri uri) \{  
qb.setTables(Tables.PRIVATE\_CONTACT);  
\}  
  
private void setTablesAndProjectionMapForData(SQLiteQueryBuilder qb, Uri uri) \{  
StringBuilder sb = new StringBuilder();  
sb.append(Tables.PRIVATE\_DATA);  
qb.setTables(sb.toString());  
qb.setProjectionMap(sDataColumns);  
\}  
  
private void setTablesAndProjectionMapFroPrivateCall(SQLiteQueryBuilder qb,  
Uri uri) \{  
qb.setTables(Tables.PRIVATE\_CALL);  
qb.setProjectionMap(sCallLogColumns);  
\}  
  
@Override  
public int update(Uri uri, ContentValues values, String selection,  
String\[\] selectionArgs) \{  
Utils.logProvider("PrivateContactsProvider update uri is:" + uri  
\+ " contentValues is:" + values + "selection=" + selection  
\+ "URI\_MATCHER.match(uri)" + URI\_MATCHER.match(uri));  
  
if (selectionArgs != null) \{  
for (int i = 0; i < selectionArgs.length; i++) \{  
Utils.logProvider("selectionArgs==" + selectionArgs\[i\]);  
\}  
\}  
checkWritableDb();  
// waitForAccess(mWriteAccessLatch);  
return doUpdateActionInTransaction(uri, values, selection,  
selectionArgs);  
\}  
  
private Uri doInsertActionInTransaction(Uri uri, ContentValues values) \{  
Uri result = null;  
SQLiteDatabase db = mPrivateContactsDatabaseHelper  
.getWritableDatabase();  
db.beginTransactionWithListener(this);  
try \{  
  
result = insertInTransaction(uri, values);  
  
db.setTransactionSuccessful();  
\} finally \{  
db.endTransaction();  
contactyChanged(uri);  
  
\}  
  
return result;  
\}  
  
private void contactyChanged(Uri uri) \{  
// Log.d(LOG\_TAG, "do\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*noticefy>>r" + uri);  
if (uri.equals(PrivateContactContracts.Contacts.CONTENT\_URI)) \{  
getContext().getContentResolver().notifyChange(  
Contacts.CONTENT\_URI, null, false);  
\} else if (uri.equals(PrivateContactContracts.Data.CONTENT\_URI)) \{  
getContext().getContentResolver().notifyChange(Data.CONTENT\_URI,  
null, false);  
// \} else if  
// (uri.equals(PrivateContactContract.Contacts.CONTENT\_LOG\_URI)) \{  
// // getContext().getContentResolver().notifyChange(  
// // Contacts.CONTENT\_LOG\_URI, null, false);  
// \} else if  
// (uri.getEncodedAuthority().equals("com.neolink.contacts")) \{  
getContext().getContentResolver().notifyChange(  
Contacts.CONTENT\_URI, null, false);  
\} else \{  
Log.d(LOG\_TAG, "do\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*noticefy error" + uri);  
\}  
\}  
  
private int doUpdateActionInTransaction(Uri uri, ContentValues values,  
String selection, String\[\] selectionArgs) \{  
int result = 0;  
SQLiteDatabase db = mPrivateContactsDatabaseHelper  
.getWritableDatabase();  
db.beginTransaction();  
try \{  
result = updateInTransaction(uri, values, selection, selectionArgs);  
db.setTransactionSuccessful();  
\} finally \{  
db.endTransaction();  
contactyChanged(uri);  
\}  
return result;  
\}  
  
private int doDeleteActionInTransaction(Uri uri, String selection,  
String\[\] selectionArgs) \{  
int result = 0;  
SQLiteDatabase db = mPrivateContactsDatabaseHelper  
.getWritableDatabase();  
Utils.logProvider("PrivateContactsProvider doDeleteActionInTransaction uri is:"  
\+ uri);  
db.beginTransaction();  
try \{  
result = deleteInTransaction(uri, selection, selectionArgs);  
db.setTransactionSuccessful();  
\} finally \{  
db.endTransaction();  
if (uri.equals(PrivateContactContracts.GroupContact.CONTENT\_URI)) \{  
getContext().getContentResolver().notifyChange(  
GroupContact.CONTENT\_URI, null, false);  
\} else \{  
contactyChanged(uri);  
\}  
\}  
return result;  
\}  
  
private Uri insertInTransaction(Uri uri, ContentValues values) \{  
int match = URI\_MATCHER.match(uri);  
Utils.logProvider("PrivateContactsProvider insertInTransaction uri is:"  
\+ uri + " match is:" + match);  
switch (match) \{  
case PRIVATE\_CONTACTS:  
return insertContact(uri, values);  
case PRIVATE\_DATA:  
return insertData(uri, values);  
case PRIVATE\_GROUP\_CONTACT:  
return insertGroupContact(uri, values);  
case PRIVATE\_CALLLOG:  
return insertCallLogData(uri, values);  
default:  
return null;  
\}  
  
\}  
  
private int updateInTransaction(Uri uri, ContentValues values,  
String selection, String\[\] selectionArgs) \{  
int count = 0;  
int match = URI\_MATCHER.match(uri);  
Log.d(LOG\_TAG, "updateInTransaction update uri is:" + uri  
\+ " contentValues is:" + values + "match==" + match);  
switch (match) \{  
case PRIVATE\_CONTACTS:  
count = updateContact(values, selection, selectionArgs);  
return count;  
case PRIVATE\_CONTACTS\_ID:  
count = updateContact(ContentUris.parseId(uri), values);  
return count;  
case PRIVATE\_DATA:  
count = updateData(values, selection, selectionArgs);  
return count;  
case PRIVATE\_DATA\_ID:  
long dataId = ContentUris.parseId(uri);  
count = updateData(dataId, values, selection, selectionArgs);  
return count;  
case PRIVATE\_CALLLOG:  
count = updateDataCallLog(values, selection, selectionArgs);  
return count;  
case PRIVATE\_CALLLOG\_ID:  
count = updateDataCallLogId(uri, values, selection, selectionArgs);  
return count;  
case PRIVATE\_GROUP\_CONTACT:  
count = updateDataGroup(values, selection, selectionArgs);  
return count;  
default:  
break;  
\}  
return -1;  
\}  
  
private int updateData(long dataId, ContentValues values, String selection,  
String\[\] selectionArgs) \{  
int count = 0;  
count = mDb.get().update(Tables.PRIVATE\_DATA, values, selection,  
selectionArgs);  
return count;  
\}  
  
private int updateDataCallLog(ContentValues values, String selection,  
String\[\] selectionArgs) \{  
int count = 0;  
count = mDb.get().update(Tables.PRIVATE\_CALL, values, selection,  
selectionArgs);  
return count;  
\}  
  
private int updateDataCallLogId(Uri url, ContentValues values,  
String selection, String\[\] selectionArgs) \{  
int count = 0;  
String selectionWithId = (PrivateContactContracts.CallLogColumns.\_ID  
\+ "=" + ContentUris.parseId(url) + " ")  
\+ (selection == null ? "" : " AND (" + selection + ")");  
count = mDb.get().update(Tables.PRIVATE\_CALL, values, selectionWithId,  
selectionArgs);  
return count;  
\}  
  
private int updateDataGroup(ContentValues values, String selection,  
String\[\] selectionArgs) \{  
int count = 0;  
count = mDb.get().update(Tables.PRIVATE\_GROUP\_CONTACT, values,  
selection, selectionArgs);  
return count;  
\}  
  
private int updateData(ContentValues values, String selection,  
String\[\] selectionArgs) \{  
Utils.logProvider("PrivateContactsProvider updateData22 selection "  
\+ selection + "values==" + values);  
int count = 0;  
int contacts\_id = 0;  
String contacts\_type = "";  
Cursor cursor = mDb.get().query(  
Tables.PRIVATE\_DATA,  
new String\[\] \{ DataColumns.\_ID, Data.CONTACT\_ID,  
Data.MIMETYPE\_ID \}, selection, selectionArgs, null,  
null, null);  
  
try \{  
while (cursor.moveToNext()) \{  
long dataId = cursor.getLong(0);  
contacts\_id = cursor.getInt(1);  
contacts\_type = cursor.getString(2);  
count += updateData(dataId, values, selection, selectionArgs);  
Utils.logProvider("PrivateContactsProvider updateData22 dataContact\_id"  
\+ " "  
\+ "values=="  
\+ values  
\+ "contacts\_id"  
\+ contacts\_id  
\+ "count=="  
\+ count  
\+ "dataId=="  
\+ dataId  
\+ "contacts\_type==" + contacts\_type);  
\}  
\} finally \{  
cursor.close();  
\}  
// Utils.logProvider("PrivateContactsProvider updateData22 selection "+selection+"values=="+values+"dataId"+"count=="+count);  
  
// if ("1".equals(contacts\_type) || "2".equals(contacts\_type)) \{  
// updateContactDisplayName(values, contacts\_id);  
// \}  
  
return count;  
\}  
  
private int updateContact(ContentValues values, String selection,  
String\[\] selectionArgs) \{  
Utils.logProvider("PrivateContactsProvider updateContact22 selection:"  
\+ selection + ",values:" + values);  
int count = 0;  
  
Cursor cursor = mDb.get().query(Views.PRIVATE\_CONTACT,  
new String\[\] \{ ContactsColumns.\_ID \}, selection, selectionArgs,  
null, null, null);  
try \{  
while (cursor.moveToNext()) \{  
long contactId = cursor.getLong(0);  
updateContact(contactId, values);  
count++;  
\}  
\} finally \{  
cursor.close();  
\}  
return count;  
\}  
  
private int updateContact(long contactId, ContentValues values) \{  
Utils.logProvider("PrivateContactProvider updateContact11 contactId :"  
\+ contactId + ",contentValues:" + values);  
String\[\] whereArgs = new String\[\] \{ String.valueOf(contactId) \};  
int rslt = mDb.get().update(Tables.PRIVATE\_CONTACT, values,  
ContactsColumns.\_ID + " = ?", whereArgs);  
return rslt;  
\}  
  
private int deleteInTransaction(Uri uri, String selection,  
String\[\] selectionArgs) \{  
int match = URI\_MATCHER.match(uri);  
SQLiteQueryBuilder qb = new SQLiteQueryBuilder();  
switch (match) \{  
case PRIVATE\_CONTACTS:  
return mDb.get().delete(Tables.PRIVATE\_CONTACT, selection,  
selectionArgs);  
case PRIVATE\_CONTACTS\_ID:  
long contactId = ContentUris.parseId(uri);  
Utils.logProvider("PrivateContactsPRovider deleteInTransaction contactId :"  
\+ contactId);  
setTablesAndProjectionMapForPrivateContact(qb, null);  
qb.appendWhere(ContactsColumns.\_ID + " =? ");  
String\[\] args = new String\[\] \{ String.valueOf(contactId) \};  
Cursor c = qb.query(mDb.get(), null, null, args, null, null, null);  
try \{  
if (c.getCount() == 1) \{  
return deleteContact(contactId);  
\} else \{  
return 0;  
\}  
\} finally \{  
c.close();  
\}  
case PRIVATE\_GROUP\_CONTACT:  
return deleteGroupData(uri, selection, selectionArgs);  
case PRIVATE\_DATA:  
return deleteData(selection, selectionArgs);  
  
case PRIVATE\_CALLLOG:  
return deleteCalllog(uri, selection, selectionArgs);  
case PRIVATE\_CALLLOG\_ID:  
long callLogId = ContentUris.parseId(uri);  
Utils.logProvider("PrivateContactsPRovider deleteInTransaction Id :"  
\+ callLogId);  
setTablesAndProjectionMapFroPrivateCall(qb, null);  
qb.appendWhere(CallLogColumns.\_ID + " =? ");  
String\[\] args1 = new String\[\] \{ String.valueOf(callLogId) \};  
Cursor c1 = qb  
.query(mDb.get(), null, null, args1, null, null, null);  
try \{  
if (c1.getCount() == 1) \{  
return deleteCalllogId(callLogId);  
\} else \{  
return 0;  
\}  
\} finally \{  
c1.close();  
\}  
case PRIVATE\_DATA\_ID:  
long dataId = ContentUris.parseId(uri);  
selectionArgs = new String\[\] \{ String.valueOf(dataId) \};  
return deleteData(DataColumns.\_ID + " ?", selectionArgs);  
  
default:  
break;  
\}  
return -1;  
\}  
  
private int deleteGroupData(Uri uri, String where, String\[\] whereArgs) \{  
SQLiteDatabase db = mPrivateContactsDatabaseHelper  
.getWritableDatabase();  
int count = db.delete(  
PrivateContactsDataHelper.Tables.PRIVATE\_GROUP\_CONTACT, where,  
whereArgs);  
return count;  
\}  
  
private int deleteData(String selection, String\[\] selectionArgs) \{  
// Utils.logProvider("PrivateContactsProvider deleteData selection:"+selection+" selection size:"+(selectionArgs==null?0:selectionArgs.length));  
int count = 0;  
count = mDb.get().delete(Tables.PRIVATE\_DATA, selection, selectionArgs);  
  
return count;  
\}  
  
private int deleteCalllogId(long id) \{  
String whereContact = ContactsColumns.\_ID + " = " + id;  
int count = mDb.get().delete(Tables.PRIVATE\_CALL, whereContact, null);  
return count;  
\}  
  
private int deleteCalllog(Uri uri, String selection, String\[\] selectionArgs) \{  
int count = 0;  
count = mDb.get().delete(Tables.PRIVATE\_CALL, selection, selectionArgs);  
return count;  
\}  
  
private int deleteContact(long contactId) \{  
String whereContact = ContactsColumns.\_ID + " = " + contactId;  
String whereData = Data.CONTACT\_ID + " = " + contactId;  
int count1 = mDb.get().delete(Tables.PRIVATE\_CONTACT, whereContact,  
null);  
int count2 = mDb.get().delete(Tables.PRIVATE\_DATA, whereData, null);  
Utils.logProvider("PrivateContactsProvider deleteContact count1 and count2 :"  
\+ count1 + "," + count2);  
return count2;  
\}  
  
private Uri insertContact(Uri uri, ContentValues values) \{  
checkTransactionContext();  
  
ContentValues mValues = new ContentValues(values);  
  
if (mValues.containsKey(ContactsColumns.DISPLAY\_NAME)) \{  
mValues.put(ContactsColumns.SEARCH\_INDEX\_NAME,  
getFirstPinYin(mValues  
.getAsString(ContactsColumns.DISPLAY\_NAME)));  
\}  
if (mValues.containsKey(ContactsColumns.NUMBER))  
mValues.put(ContactsColumns.SEARCH\_INDEX\_NUMBER,  
mValues.getAsInteger(ContactsColumns.NUMBER));  
checkTransactionContext();  
checkWritableDb();  
long contactReturnId = mDb.get().insert(Tables.PRIVATE\_CONTACT, null,  
mValues);  
  
Utils.logProvider("contactReturnId=="  
\+ contactReturnId  
\+ "<<<<<<<<<<<<>>>>>>>>>>>>>>>>insertmContactToDataUpdate"  
\+ getMimeTypeId(PrivateContactConst.DataKindMimeType.CONTACTS\_NUMBER\_CONTENT\_ITEM\_TYPE)  
\+ mPrivateContactsDatabaseHelper  
.getMimeTypeId(PrivateContactConst.DataKindMimeType.CONTACTS\_NUMBER\_CONTENT\_ITEM\_TYPE));  
if (contactReturnId < 0) \{  
return null;  
\}  
if (values.containsKey(Contacts.DISPLAY\_NAME)) \{  
insertmContactToDataUpdate(  
contactReturnId,  
values.getAsString(Contacts.DISPLAY\_NAME),  
(int) getMimeTypeId(PrivateContactConst.DataKindMimeType.CONTACTS\_NAME\_CONTENT\_ITEM\_TYPE));  
\}  
if (values.containsKey(Contacts.NUMBER)) \{  
insertmContactToDataUpdate(  
contactReturnId,  
values.getAsString(Contacts.NUMBER),  
(int) getMimeTypeId(PrivateContactConst.DataKindMimeType.CONTACTS\_NUMBER\_CONTENT\_ITEM\_TYPE));  
\}  
mTransactionContext.get().contactInsert(contactReturnId);  
uri = ContentUris.withAppendedId(uri, contactReturnId);  
return uri;  
\}  
  
private Uri insertGroupContact(Uri uri, ContentValues values) \{  
Utils.logProvider("PrivateContactsProvider insertGroupContact uri:"  
\+ uri + ",values:" + values);  
checkTransactionContext();  
checkWritableDb();  
int zone\_id;  
ContentValues mValues = new ContentValues(values);  
long groupReturnId = mDb.get().insert(Tables.PRIVATE\_GROUP\_CONTACT,  
null, mValues);  
uri = ContentUris.withAppendedId(uri, groupReturnId);  
Log.d(LOG\_TAG, "insertGroupContact\_groupReturnId=" + groupReturnId);  
if (groupReturnId < 0) \{  
Log.d(LOG\_TAG, "insertGroupContact\_groupReturnId=" + groupReturnId);  
\} else \{  
// if (values.containsKey(GroupContact.GROUP\_ZONE\_NAME)) \{  
// getZoneInfo(values.getAsString(GroupContact.GROUP\_ZONE\_NAME),values.getAsInteger(GroupContact.GROUP\_ZONE\_ID));  
// \}else\{  
// getZoneInfo("test1111",15);  
// \}  
  
if (values.containsKey(GroupContact.GROUP\_CONTACT\_NAME)) \{  
  
Log.d(LOG\_TAG,  
"insertGroupContact\_"  
\+ mPrivateContactsDatabaseHelper  
.getMimeTypeId(PrivateContactConst.DataKindMimeType.GROUP\_NAME\_CONTENT\_ITEM\_TYPE));  
\}  
if (values.containsKey(GroupContact.GROUP\_CONTACT\_NUMBER)) \{  
insertDataFromGroupUpdate(  
groupReturnId,  
values.getAsString(GroupContact.GROUP\_CONTACT\_NUMBER),  
(int) getMimeTypeId(PrivateContactConst.DataKindMimeType.GROUP\_NUMBER\_CONTENT\_ITEM\_TYPE));  
\}  
\}  
  
return uri;  
\}  
  
private Uri insertCallLogData(Uri uri, ContentValues values) \{  
Utils.logProvider("PrivateNormalProvider call log uri:" + uri  
\+ ",values:" + values);  
checkTransactionContext();  
ContentValues mValues = new ContentValues(values);  
checkWritableDb();  
  
int normalid = 0;  
long normalid1 = mDb.get().insert(Tables.PRIVATE\_CALL, null, mValues);  
if (normalid1 < 0) \{  
Log.d(LOG\_TAG, "normalid==" + normalid1);  
\} else \{  
if (values.containsKey(CallLogColumns.NUMBER)) \{  
insertmCallLogToUpdateSelf(values  
.getAsString(CallLogColumns.NUMBER));  
\}  
\}  
return uri;  
\}  
  
/\*\*  
\* Inserts a record in the \{@link Tables\#NAME\_LOOKUP\} table.  
\*/  
public void insertmCallLogToUpdateSelf(String number) \{  
  
mMode = Settings.Secure.getInt(getContext().getContentResolver(),  
Settings.Secure.PRIVATE\_PHONE\_MODE, PrivateMode.MODE\_UNKNOWN);  
  
long modeType = 0;  
if (mMode == PrivateMode.MODE\_MPT1327\_ANALOG\_TRUNKING) \{  
modeType = (long) PrivateContactContracts.Contacts.CONTACTS\_IMPORT\_BY\_PCTOOL\_PDT;  
\} else if (mMode == PrivateMode.MODE\_PDT\_DIGITAL\_TRUNKING) \{  
modeType = (long) PrivateContactContracts.Contacts.CONTACTS\_IMPORT\_BY\_PCTOOL\_MPT;  
\}  
  
String\[\] selectionArgs = new String\[1\];  
mMode = 11;  
// selectionArgs\[0\] = String.valueOf(11);  
selectionArgs\[0\] = String.valueOf(number);  
checkReadableDB();  
Cursor c = mDb.get().rawQuery(UPDATE\_CALL\_LOG\_FROM\_CONTACTS,  
selectionArgs);  
String name = "";  
long ContactId = 0;  
Utils.logProvider("insertmCallLogToUpdateSelf getCOunt is:"  
\+ c.getCount());  
try \{  
if (c.getCount() == 0) \{  
c.close();  
return;  
\}  
while (c.moveToNext()) \{  
Utils.logProvider("insertmCallLogToUpdateSelf getCOunt is:"  
\+ c.getCount() + " aa:" + c.getLong(0) + "bb:"  
\+ c.getString(1));  
name = c.getString(1);  
\}  
\} catch (Exception e) \{  
e.printStackTrace();  
\} finally \{  
c.close();  
\}  
checkWritableDb();  
if (mContactToCallLogUpdate == null) \{  
mContactToCallLogUpdate = mDb.get().compileStatement(  
"UPDATE " + Tables.PRIVATE\_CALL + " SET "  
\+ CallLogColumns.CONTACTS\_ID + " =? " + " , "  
\+ CallLogColumns.DISPLAY\_NAME + " =? " + " WHERE "  
\+ CallLogColumns.NUMBER + " = ?");  
\}  
mContactToCallLogUpdate.bindLong(1, ContactId);  
bindString(mContactToCallLogUpdate, 2, name);  
bindString(mContactToCallLogUpdate, 3, number);  
mContactToCallLogUpdate.execute();  
  
\}  
  
private Uri insertData(Uri uri, ContentValues values) \{  
ContentValues mValues = new ContentValues();  
mValues.clear();  
mValues.putAll(values);  
  
mMode = Settings.Secure.getInt(getContext().getContentResolver(),  
Settings.Secure.PRIVATE\_PHONE\_MODE, PrivateMode.MODE\_UNKNOWN);  
  
int modeType = 0;  
if (mMode == PrivateMode.MODE\_MPT1327\_ANALOG\_TRUNKING) \{  
modeType = PrivateContactContracts.Contacts.CONTACTS\_IMPORT\_BY\_PCTOOL\_PDT;  
\} else if (mMode == PrivateMode.MODE\_PDT\_DIGITAL\_TRUNKING) \{  
modeType = PrivateContactContracts.Contacts.CONTACTS\_IMPORT\_BY\_PCTOOL\_MPT;  
\}  
  
long contactDataId = mValues.getAsLong(Data.CONTACT\_ID);  
  
String mimeType = mValues.getAsString(MimetypesColumns.MIMETYPE);  
mValues.put(Data.MIMETYPE\_ID, getMimeTypeId(mimeType));  
// mValues.put(Data.IMPORT\_TYPE, modeType);  
mValues.remove(MimetypesColumns.MIMETYPE);  
  
long id = mDb.get().insert(Tables.PRIVATE\_DATA, null, mValues);  
Utils.logProvider("PrivateContactsProvider insertData id is:" + id  
\+ mValues + " mimeType is:" + mimeType + " contactDataId is:"  
\+ contactDataId);  
if (id < 0) \{  
return null;  
\}  
// if (DataKindMimeType.NAME\_CONTENT\_ITEM\_TYPE.equals(mimeType)  
// || DataKindMimeType.PHONE\_CONTENT\_ITEM\_TYPE.equals(mimeType)) \{  
// updateContactDisplayName(mValues, contactDataId);  
// \}  
return ContentUris.withAppendedId(uri, id);  
\}  
  
public long getMimeTypeId(String mimeType) \{  
if (mMimeTypeCache.containsKey(mimeType))  
return mMimeTypeCache.get(mimeType);  
  
return lookupMimeTypeId(mimeType);  
\}  
  
private long lookupMimeTypeId(String mimeType) \{  
checkWritableDb();  
final SQLiteStatement mimeTypeQuery = mDb.get().compileStatement(  
"SELECT " + MimetypesColumns.\_ID + " FROM "  
\+ Tables.PRIVATE\_MIMETYPE + " WHERE "  
\+ MimetypesColumns.MIMETYPE + " = ?");  
final SQLiteStatement mimetypeInsert = mDb.get().compileStatement(  
"INSERT INTO " + Tables.PRIVATE\_MIMETYPE + "("  
\+ MimetypesColumns.MIMETYPE + " ) VALUES (?)");  
try \{  
return lookupAndCacheId(mimeTypeQuery, mimetypeInsert, mimeType,  
mMimeTypeCache);  
\} finally \{  
mimetypeInsert.close();  
mimeTypeQuery.close();  
\}  
\}  
  
private long lookupAndCacheId(SQLiteStatement query,  
SQLiteStatement insert, String value, HashMap<String, Long> cache) \{  
Utils.logProvider("PrivateContactsProvider lookupAndCacheId");  
long id = -1;  
try \{  
DatabaseUtils.bindObjectToProgram(query, 1, value);  
id = query.simpleQueryForLong();  
if (id != -1) \{  
return id;  
\}  
\} catch (SQLiteDoneException e) \{  
e.printStackTrace();  
DatabaseUtils.bindObjectToProgram(insert, 1, value);  
id = insert.executeInsert();  
Utils.logProvider("PrivateContactsProvider lookupAndCacheId CatchException id is:"  
\+ id);  
\}  
if (id != -1) \{  
cache.put(value, id);  
return id;  
\} else \{  
throw new IllegalStateException(  
"Couldn't find or create internal value is:" + value);  
\}  
\}  
  
public long getZoneInfo(String zoneName, int id) \{  
if (mZoneIdCache.containsKey(zoneName))  
return mZoneIdCache.get(zoneName);  
  
return lookupZoneId(zoneName, id);  
\}  
  
private long lookupZoneId(String zoneName, int zoneid) \{  
checkWritableDb();  
final SQLiteStatement mimeTypeQuery = mDb.get().compileStatement(  
"SELECT " + ZoneColumns.\_ID + " FROM " + Tables.PRIVATE\_ZONE  
\+ " WHERE " + ZoneColumns.ZONE\_NAME + " = ?");  
final SQLiteStatement mimetypeInsert = mDb.get().compileStatement(  
"INSERT INTO " + Tables.PRIVATE\_ZONE + "(" + ZoneColumns.\_ID  
\+ " , " + ZoneColumns.ZONE\_NAME + " ) VALUES (?,?)");  
try \{  
return lookupZoneAndCacheId(mimeTypeQuery, mimetypeInsert,  
zoneName, zoneid, mZoneIdCache);  
\} finally \{  
mimetypeInsert.close();  
mimeTypeQuery.close();  
\}  
\}  
  
private long lookupZoneAndCacheId(SQLiteStatement query,  
SQLiteStatement insert, String value, int zoneid,  
HashMap<String, Long> cache) \{  
Utils.logProvider("PrivateContactsProvider lookupAndCacheId");  
long id = -1;  
try \{  
DatabaseUtils.bindObjectToProgram(query, 1, value);  
id = query.simpleQueryForLong();  
\} catch (SQLiteDoneException e) \{  
e.printStackTrace();  
DatabaseUtils.bindObjectToProgram(insert, 1, zoneid);  
DatabaseUtils.bindObjectToProgram(insert, 2, value);  
id = insert.executeInsert();  
Utils.logProvider("PrivateContactsProvider lookupAndCacheId CatchException id is:"  
\+ id);  
\}  
if (id != -1) \{  
cache.put(value, id);  
return id;  
\} else \{  
throw new IllegalStateException(  
"Couldn't find or create internal value is:" + value);  
\}  
\}  
  
private void checkWritableDb() \{  
if (mDb.get() == null) \{  
mDb.set(mPrivateContactsDatabaseHelper.getWritableDatabase());  
\}  
\}  
  
private void checkReadableDB() \{  
if (mDb.get() == null) \{  
mDb.set(mPrivateContactsDatabaseHelper.getReadableDatabase());  
\}  
\}  
  
private void checkTransactionContext() \{  
if (mTransactionContext.get() == null) \{  
mTransactionContext.set(mContactTransactionContext);  
\}  
\}  
  
@Override  
public String getType(Uri uri) \{  
final int match = URI\_MATCHER.match(uri);  
switch (match) \{  
case PRIVATE\_CONTACTS:  
return Contacts.CONTENT\_TYPE;  
case PRIVATE\_CONTACTS\_ID:  
return Contacts.CONTENT\_ITEM\_TYPE;  
case PRIVATE\_GROUP\_CONTACT:  
return GroupContact.CONTENT\_TYPE;  
case PRIVATE\_GROUP\_CONTACT\_ID:  
return GroupContact.CONTENT\_ITEM\_TYPE;  
\}  
  
return null;  
\}  
  
@Override  
public Uri insert(Uri uri, ContentValues values) \{  
  
checkWritableDb();  
int match = URI\_MATCHER.match(uri);  
Log.d(LOG\_TAG, "insert...match==" + match + "values=");  
// waitForAccess(mWriteAccessLatch);  
Uri returnUri = doInsertActionInTransaction(uri, values);  
return returnUri;  
\}  
  
@Override  
public int delete(Uri uri, String selection, String\[\] selectionArgs) \{  
Utils.logProvider("PrivateContactsProvider delete uri is:" + uri  
\+ "selection=" + selection + "URI\_MATCHER.match(uri)"  
\+ URI\_MATCHER.match(uri));  
  
if (selectionArgs != null) \{  
for (int i = 0; i < selectionArgs.length; i++) \{  
Utils.logProvider("selectionArgs==" + selectionArgs\[i\]);  
\}  
\}  
checkWritableDb();  
// waitForAccess(mWriteAccessLatch);  
return doDeleteActionInTransaction(uri, selection, selectionArgs);  
\}  
  
@Override  
public void onCommit() \{  
checkReadableDB();  
checkTransactionContext();  
Utils.logProvider(" onCommit ----------done");  
try \{  
for (long contactId : mTransactionContext.get()  
.getInsertContactIdList()) \{  
Utils.logProvider("PrivateContactSaveService onCommit ----------contactId=="  
\+ contactId);  
// updateContactDisplayName(null, contactId);  
\}  
\} finally \{  
mTransactionContext.get().clear();  
\}  
\}  
  
public void onRollback() \{  
Utils.logProvider(" onRollback ----------done");  
\}  
  
@Override  
public void onBegin() \{  
checkTransactionContext();  
  
Log.d(LOG\_TAG, "PrivateContactsProvider onBegin");  
mTransactionContext.get().clear();  
\}  
  
public void updateContactDisplayName(ContentValues NumbermValues,  
long contact\_id) \{  
  
Long modeType = (long) -1;  
mMode = Settings.Secure.getInt(getContext().getContentResolver(),  
Settings.Secure.PRIVATE\_PHONE\_MODE, PrivateMode.MODE\_UNKNOWN);  
  
if (mMode == PrivateMode.MODE\_MPT1327\_ANALOG\_TRUNKING) \{  
modeType = (long) PrivateContactContracts.Contacts.CONTACTS\_IMPORT\_BY\_PCTOOL\_PDT;  
\} else if (mMode == PrivateMode.MODE\_PDT\_DIGITAL\_TRUNKING) \{  
modeType = (long) PrivateContactContracts.Contacts.CONTACTS\_IMPORT\_BY\_PCTOOL\_MPT;  
\}  
  
String\[\] selectionArgs = new String\[1\];  
selectionArgs\[0\] = String.valueOf(contact\_id);  
checkReadableDB();  
Cursor c = mDb.get().rawQuery(UPDATE\_CONTACTS, selectionArgs);  
String name = "";  
String phone = "";  
Utils.logProvider("updateContactDisplayName getCOunt is:"  
\+ c.getCount() + " contact\_id is:" + contact\_id + "new "  
\+ NumbermValues);  
try \{  
if (c.getCount() == 0) \{  
c.close();  
return;  
\}  
while (c.moveToNext()) \{  
int mimeType = c.getInt(c  
.getColumnIndexOrThrow(DataColumns.MIMETYPE\_ID));  
Utils.logProvider("PrivateContactsProvider updateContactDisplayName mimeType is:"  
\+ mimeType  
\+ "=="  
\+ lookupMimeTypeId(DataKindMimeType.CONTACTS\_NAME\_CONTENT\_ITEM\_TYPE));  
/\*  
\* if (mimeType ==  
\* lookupMimeTypeId(DataKindMimeType.CONTACTS\_NAME\_CONTENT\_ITEM\_TYPE  
\* )) \{ name = c.getString(c  
\* .getColumnIndexOrThrow(PrivateContactConst  
\* .NameEditorDataKind)); \} if (mimeType ==  
\* lookupMimeTypeId(DataKindMimeType  
\* .CONTACTS\_NUMBER\_CONTENT\_ITEM\_TYPE)) \{ phone = c .getString(c  
\* .  
\* getColumnIndexOrThrow(PrivateContactConst.NameEditorDataKind)  
\* ); \}  
\*/  
\}  
\} catch (Exception e) \{  
e.printStackTrace();  
\} finally \{  
c.close();  
\}  
checkWritableDb();  
if (mContactDisplayNameUpdate == null) \{  
mContactDisplayNameUpdate = mDb.get().compileStatement(  
"UPDATE " + Tables.PRIVATE\_CONTACT + " SET "  
\+ Contacts.DISPLAY\_NAME + " =? " + " , "  
\+ Contacts.SORT\_KEY + " =? " + " , "  
\+ Contacts.SEARCH\_INDEX\_NAME + " =? " + " , "  
\+ Contacts.SEARCH\_INDEX\_NUMBER + " =? " + " , "  
\+ Contacts.NUMBER + " =? " + " WHERE "  
\+ ContactsColumns.\_ID + " = ?");  
\}  
Utils.logProvider("PrivateContactsProvider updateContactDisplayName1111 is:"  
\+ name + "--contact.id" + contact\_id + phone);  
  
if (TextUtils.isEmpty(name)) \{  
Utils.logProvider("PrivateContactsProvider updateContactDisplayName1111 is:"  
\+ name + "--contact.id" + contact\_id + phone);  
  
bindString(mContactDisplayNameUpdate, 1, phone);  
bindString(mContactDisplayNameUpdate, 2, phone);  
bindString(mContactDisplayNameUpdate, 3, phone);  
bindString(mContactDisplayNameUpdate, 4, phone);  
bindInt(mContactDisplayNameUpdate, 5, modeType);  
  
\} else \{  
  
bindString(mContactDisplayNameUpdate, 1, name);// display\_name  
bindString(mContactDisplayNameUpdate, 2, getFullPinYin(name));// sort\_ley  
bindString(mContactDisplayNameUpdate, 3, getFirstPinYin(name) + "\*"  
\+ getFullPinYin(name));// search\_full and first\_name  
bindString(mContactDisplayNameUpdate, 4, phone);// seach\_number  
bindInt(mContactDisplayNameUpdate, 5, modeType);  
  
\}  
mContactDisplayNameUpdate.bindLong(6, contact\_id);  
mContactDisplayNameUpdate.execute();  
\}  
  
/\*\*  
\* Inserts a record in the \{@link Tables\#NAME\_LOOKUP\} table.  
\*/  
public void insertmContactToDataUpdate(long ContactId, String values,  
int mimetype) \{  
if (mContactToDataUpdate == null) \{  
mDbHelper.set(mPrivateContactsDatabaseHelper);  
mContactToDataUpdate = mDbHelper  
.get()  
.getWritableDatabase()  
.compileStatement(  
"INSERT OR IGNORE INTO " + Tables.PRIVATE\_DATA  
\+ "(" + DataColumns.CONTACT\_ID + ","  
\+ DataColumns.MIMETYPE\_ID + ","  
\+ DataColumns.DATA1 + ") VALUES (?,?,?)");  
\}  
mContactToDataUpdate.bindLong(1, ContactId);  
mContactToDataUpdate.bindLong(2, mimetype);  
bindString(mContactToDataUpdate, 3, values);  
mContactToDataUpdate.executeInsert();  
  
// if (getMimeTypeId(DataKindMimeType.CONTACTS\_NAME\_CONTENT\_ITEM\_TYPE)==  
// mimetype  
// ||  
// getMimeTypeId(DataKindMimeType.CONTACTS\_NUMBER\_CONTENT\_ITEM\_TYPE)==  
// mimetype) \{  
// updateContactDisplayName(values, ContactId);  
// \}  
\}  
  
/\*\*  
\* Inserts a record in the \{@link Tables\#NAME\_LOOKUP\} table.  
\*/  
public void insertDataFromGroupUpdate(long GroupId, String values,  
int mimetype) \{  
if (mGroupToDataUpdate == null) \{  
mDbHelper.set(mPrivateContactsDatabaseHelper);  
mGroupToDataUpdate = mDbHelper  
.get()  
.getWritableDatabase()  
.compileStatement(  
"INSERT OR IGNORE INTO " + Tables.PRIVATE\_DATA  
\+ "(" + DataColumns.GROUP\_ID + ","  
\+ DataColumns.MIMETYPE\_ID + ","  
\+ DataColumns.DATA1 + ") VALUES (?,?,?)");  
\}  
mGroupToDataUpdate.bindLong(1, GroupId);  
mGroupToDataUpdate.bindLong(2, mimetype);  
bindString(mGroupToDataUpdate, 3, values);  
mGroupToDataUpdate.executeInsert();  
\}  
  
@Override  
public ContentProviderResult\[\] applyBatch(  
ArrayList<ContentProviderOperation> operations)  
throws OperationApplicationException \{  
  
Utils.logProvider("applyBatch has changed!"  
\+ operations.size());  
SQLiteDatabase db = mPrivateContactsDatabaseHelper  
.getWritableDatabase();  
// waitForAccess(mWriteAccessLatch);  
db.beginTransaction();// start transaction  
// db.beginTransactionWithListener(this);  
try \{  
ContentProviderResult\[\] results = super.applyBatch(operations);  
db.setTransactionSuccessful();// set successful  
return results;  
\} finally \{  
db.endTransaction();// end transaction  
Utils.logProvider("PrivateContactsProvidernotifyChange>GroupContact has changed");  
getContext().getContentResolver().notifyChange(  
GroupContact.CONTENT\_URI, null, false);  
\}  
  
\}  
  
private void bindString(SQLiteStatement stmt, int index, String value) \{  
if (value == null) \{  
stmt.bindNull(index);  
\} else \{  
stmt.bindString(index, value);  
\}  
\}  
  
private void bindInt(SQLiteStatement stmt, int index, Long value) \{  
if (value == 0) \{  
stmt.bindNull(index);  
\} else \{  
stmt.bindLong(index, value);  
\}  
\}  
  
public String getFirstPinYin(String source) \{  
  
if (!Arrays.asList(Collator.getAvailableLocales()).contains(  
Locale.CHINA)) \{  
  
return source;  
  
\}  
  
ArrayList<Token> tokens = HanziToPinyin.getInstance().get(source);  
  
if (tokens == null || tokens.size() == 0) \{  
  
return source;  
  
\}  
  
StringBuffer result = new StringBuffer();  
  
for (Token token : tokens) \{  
  
if (token.type == Token.PINYIN) \{  
  
result.append(token.target.charAt(0));  
  
\} else \{  
  
result.append("");  
  
\}  
  
\}  
return result.toString().toLowerCase();  
\}  
  
public String getFullPinYin(String source) \{  
if (!Arrays.asList(Collator.getAvailableLocales()).contains(  
Locale.CHINA)) \{  
return source;  
\}  
ArrayList<Token> tokens = HanziToPinyin.getInstance().get(source);  
if (tokens == null || tokens.size() == 0) \{  
return source;  
\}  
StringBuffer result = new StringBuffer();  
for (Token token : tokens) \{  
if (token.type == Token.PINYIN) \{  
result.append(token.target);  
\} else \{  
result.append(token.source);  
\}  
\}  
return result.toString().toLowerCase();  
\}  
  
public static boolean isNumeric(String str) \{  
Pattern pattern = Pattern.compile("\[0-9\]\*");  
return pattern.matcher(str).matches();  
\}  
  
private String\[\] splitNameByWord(String name) \{  
int length = name.length();  
String\[\] subname = new String\[length\];  
for (int i = 0; i < name.length(); i++) \{  
  
subname\[i\] = name.charAt(i) + "";  
\}  
return subname;  
\}  
  
\}