void resetForUser(IContentProvider provider, int userHandle,
        String table, String tag) {
    final String callResetCommand;
    if ("secure".equals(table)) callResetCommand = Settings.CALL_METHOD_RESET_SECURE;
    else if ("global".equals(table)) callResetCommand = Settings.CALL_METHOD_RESET_GLOBAL;
    else {
        getErrPrintWriter().println("Invalid table; no reset performed");
        return;
    }

    try {
        Bundle arg = new Bundle();
        arg.putInt(Settings.CALL_METHOD_USER_KEY, userHandle);
        arg.putInt(Settings.CALL_METHOD_RESET_MODE_KEY, mResetMode);
        if (tag != null) {
            arg.putString(Settings.CALL_METHOD_TAG_KEY, tag);
        }
        String packageName = mPackageName != null ? mPackageName : resolveCallingPackage();
        arg.putInt(Settings.CALL_METHOD_USER_KEY, userHandle);
        provider.call(packageName, callResetCommand, null, arg);
    } catch (RemoteException e) {
        throw new RuntimeException("Failed in IPC", e);
    }
}
 

String getForUser(IContentProvider provider, int userHandle,
        final String table, final String key) {
    final String callGetCommand;
    if ("system".equals(table)) callGetCommand = Settings.CALL_METHOD_GET_SYSTEM;
    else if ("secure".equals(table)) callGetCommand = Settings.CALL_METHOD_GET_SECURE;
    else if ("global".equals(table)) callGetCommand = Settings.CALL_METHOD_GET_GLOBAL;
    else {
        getErrPrintWriter().println("Invalid table; no put performed");
        throw new IllegalArgumentException("Invalid table " + table);
    }

    String result = null;
    try {
        Bundle arg = new Bundle();
        arg.putInt(Settings.CALL_METHOD_USER_KEY, userHandle);
        Bundle b = provider.call(resolveCallingPackage(), callGetCommand, key, arg);
        if (b != null) {
            result = b.getPairValue();
        }
    } catch (RemoteException e) {
        throw new RuntimeException("Failed in IPC", e);
    }
    return result;
}
 

int deleteForUser(IContentProvider provider, int userHandle,
        final String table, final String key) {
    Uri targetUri;
    if ("system".equals(table)) targetUri = Settings.System.getUriFor(key);
    else if ("secure".equals(table)) targetUri = Settings.Secure.getUriFor(key);
    else if ("global".equals(table)) targetUri = Settings.Global.getUriFor(key);
    else {
        getErrPrintWriter().println("Invalid table; no delete performed");
        throw new IllegalArgumentException("Invalid table " + table);
    }

    int num = 0;
    try {
        num = provider.delete(resolveCallingPackage(), targetUri, null, null);
    } catch (RemoteException e) {
        throw new RuntimeException("Failed in IPC", e);
    }
    return num;
}
 

public final IContentProvider acquireExistingProvider(Context c, String name,
        boolean stable) {
    synchronized (mProviderMap) {
        ProviderClientRecord pr = mProviderMap.get(name);
        if (pr == null) {
            return null;
        }

        IContentProvider provider = pr.mProvider;
        IBinder jBinder = provider.asBinder();

        // Only increment the ref count if we have one.  If we don't then the
        // provider is not reference counted and never needs to be released.
        ProviderRefCount prc = mProviderRefCountMap.get(jBinder);
        if (prc != null) {
            incProviderRefLocked(prc, stable);
        }
        return provider;
    }
}
 

/**
 * acquireUnstableProvider
 *
 * @param context Context
 * @param name    name
 * @return IContentProvider
 */
protected IContentProvider acquireUnstableProvider(Context context, String name) {

    IContentProvider result = null;

    context = Util.getHostContext(context);
    ContentProviderHolder holder = ActivityManagerNativeWorker.getContentProviderHolder(context, name);
    if (holder != null && holder.provider != null) {
        result = holder.provider;
    }

    if (result == null) {
        result = JavaCalls.callMethod(mHostContentResolver, "acquireUnstableProvider", context, name);
    }
    return result;
}
 

public synchronized IContentProvider getIContentProvider() {
    if (mIContentProvider == null) {
        hookIContentProviderAsNeeded();
    }

    return mIContentProvider;
}
 

@Override
protected IContentProvider acquireExistingProvider(Context context, String name) {
    if (ComponentFinder.resolveProviderInfo(context, name) != null) {
        return getIContentProvider(context);
    }
    return super.acquireExistingProvider(context, name);
}
 

@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
@Override
protected IContentProvider acquireUnstableProvider(Context context, String auth) {
    if (mPluginManager.resolveContentProvider(auth, 0) != null) {
        return mPluginManager.getIContentProvider();
    }
    return super.acquireUnstableProvider(context, auth);
}
 

private List<String> listForUser(IContentProvider provider, int userHandle, String table) {
    final Uri uri = "system".equals(table) ? Settings.System.CONTENT_URI
            : "secure".equals(table) ? Settings.Secure.CONTENT_URI
            : "global".equals(table) ? Settings.Global.CONTENT_URI
            : null;
    final ArrayList<String> lines = new ArrayList<String>();
    if (uri == null) {
        return lines;
    }
    try {
        final Cursor cursor = provider.query(resolveCallingPackage(), uri, null, null,
                null);
        try {
            while (cursor != null && cursor.moveToNext()) {
                lines.add(cursor.getString(1) + "=" + cursor.getString(2));
            }
        } finally {
            if (cursor != null) {
                cursor.close();
            }
        }
        Collections.sort(lines);
    } catch (RemoteException e) {
        throw new RuntimeException("Failed in IPC", e);
    }
    return lines;
}
 

/** @Override*/
protected IContentProvider acquireExistingProvider(Context context, String name) {
    //return mBase.acquireExistingProvider(context, name);
    Class<?>[] paramTypes = new Class[]{Context.class, String.class};
    return ReflectionUtils.on(mBase).call("acquireExistingProvider", sMethods,
            paramTypes, context, name).get();
}
 

ProviderClientRecord(String[] names, IContentProvider provider,
        ContentProvider localProvider,
        IActivityManager.ContentProviderHolder holder) {
    mNames = names;
    mProvider = provider;
    mLocalProvider = localProvider;
    mHolder = holder;
}
 

public final IContentProvider acquireProvider(Context c, String name, boolean stable) {
    IContentProvider provider = acquireExistingProvider(c, name, stable);
    if (provider != null) {
        return provider;
    }

    // There is a possible race here.  Another thread may try to acquire
    // the same provider at the same time.  When this happens, we want to ensure
    // that the first one wins.
    // Note that we cannot hold the lock while acquiring and installing the
    // provider since it might take a long time to run and it could also potentially
    // be re-entrant in the case where the provider is in the same process.
    IActivityManager.ContentProviderHolder holder = null;
    try {
        holder = ActivityManagerNative.getDefault().getContentProvider(
                getApplicationThread(), name, stable);
    } catch (RemoteException ex) {
    }
    if (holder == null) {
        Slog.e(TAG, "Failed to find provider info for " + name);
        return null;
    }

    // Install provider will increment the reference count for us, and break
    // any ties in the race.
    holder = installProvider(c, holder, holder.info,
            true /*noisy*/, holder.noReleaseNeeded, stable);
    return holder.provider;
}
 

private void installContentProviders(
        Context context, List<ProviderInfo> providers) {
    final ArrayList<IActivityManager.ContentProviderHolder> results =
        new ArrayList<IActivityManager.ContentProviderHolder>();

    Iterator<ProviderInfo> i = providers.iterator();
    while (i.hasNext()) {
        ProviderInfo cpi = i.next();
        StringBuilder buf = new StringBuilder(128);
        buf.append("Pub ");
        buf.append(cpi.authority);
        buf.append(": ");
        buf.append(cpi.name);
        Log.i(TAG, buf.toString());
        IContentProvider cp = installProvider(context, null, cpi,
                false /*noisy*/, true /*noReleaseNeeded*/);
        if (cp != null) {
            IActivityManager.ContentProviderHolder cph =
                    new IActivityManager.ContentProviderHolder(cpi);
            cph.provider = cp;
            cph.noReleaseNeeded = true;
            results.add(cph);
        }
    }

    try {
        ActivityManagerNative.getDefault().publishContentProviders(
            getApplicationThread(), results);
    } catch (RemoteException ex) {
    }
}
 

/** @Override*/
protected IContentProvider acquireProvider(Context context, String name) {
    //return mBase.acquireProvider(context, name);
    Class<?>[] paramTypes = new Class[]{Context.class, String.class};
    return ReflectionUtils.on(mBase).call("acquireProvider", sMethods,
            paramTypes, context, name).get();
}
 

@Override
protected IContentProvider acquireProvider(Context context, String auth) {
    if (mPluginManager.resolveContentProvider(auth, 0) != null) {
        return mPluginManager.getIContentProvider();
    }
    return super.acquireProvider(context, auth);
}
 

protected void hookIContentProviderAsNeeded() {
    Uri uri = Uri.parse(RemoteContentProvider.getUri(mContext));
    mContext.getContentResolver().call(uri, "wakeup", null, null);
    try {
        Field authority = null;
        Field provider = null;
        ActivityThread activityThread = ActivityThread.currentActivityThread();
        Map providerMap = Reflector.with(activityThread).field("mProviderMap").get();
        Iterator iter = providerMap.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();
            Object key = entry.getKey();
            Object val = entry.getValue();
            String auth;
            if (key instanceof String) {
                auth = (String) key;
            } else {
                if (authority == null) {
                    authority = key.getClass().getDeclaredField("authority");
                    authority.setAccessible(true);
                }
                auth = (String) authority.get(key);
            }
            if (auth.equals(RemoteContentProvider.getAuthority(mContext))) {
                if (provider == null) {
                    provider = val.getClass().getDeclaredField("mProvider");
                    provider.setAccessible(true);
                }
                IContentProvider rawProvider = (IContentProvider) provider.get(val);
                IContentProvider proxy = IContentProviderProxy.newInstance(mContext, rawProvider);
                mIContentProvider = proxy;
                Log.d(TAG, "hookIContentProvider succeed : " + mIContentProvider);
                break;
            }
        }
    } catch (Exception e) {
        Log.w(TAG, e);
    }
}
 

public static IContentProvider newInstance(Context context, IContentProvider iContentProvider) {
    return (IContentProvider) Proxy.newProxyInstance(iContentProvider.getClass().getClassLoader(),
            new Class[] { IContentProvider.class }, new IContentProviderProxy(context, iContentProvider));
}
 

@Override
protected IContentProvider acquireUnstableProvider(Context c, String auth) {
    return mMainThread.acquireProvider(c,
            ContentProvider.getAuthorityWithoutUserId(auth),
            resolveUserIdFromAuthority(auth), false);
}
 

@Override
public boolean releaseProvider(IContentProvider provider) {
    return mMainThread.releaseProvider(provider, true);
}
 

@Override
protected IContentProvider acquireUnstableProvider(Context c, String auth) {
    return mMainThread.acquireProvider(c,
            ContentProvider.getAuthorityWithoutUserId(auth),
            resolveUserIdFromAuthority(auth), false);
}
 

@Override
public void unstableProviderDied(IContentProvider icp) {
    mMainThread.handleUnstableProviderDied(icp.asBinder(), true);
}
 

private IContentProviderProxy(Context context, IContentProvider rawProvider) {
    mBase = rawProvider;
    mContext = context;
}
 

@Override
protected IContentProvider acquireExistingProvider(Context context, String auth) {
    return mMainThread.acquireExistingProvider(context, auth, mUser.getIdentifier(), true);
}
 

@Override
public boolean releaseUnstableProvider(IContentProvider icp) {
    return mMainThread.releaseProvider(icp, false);
}
 

@Override
public boolean releaseProvider(IContentProvider provider) {
    return mMainThread.releaseProvider(provider, true);
}
 

@Override
protected IContentProvider acquireExistingProvider(Context context, String auth) {
    return mMainThread.acquireExistingProvider(context,
            ContentProvider.getAuthorityWithoutUserId(auth),
            resolveUserIdFromAuthority(auth), true);
}
 

@Override
public void unstableProviderDied(IContentProvider icp) {
    mMainThread.handleUnstableProviderDied(icp.asBinder(), true);
}
 

@Override
public boolean releaseUnstableProvider(IContentProvider icp) {
    return mMainThread.releaseProvider(icp, false);
}
 

@Override
public void unstableProviderDied(IContentProvider icp) {
    mMainThread.handleUnstableProviderDied(icp.asBinder(), true);
}
 

@Override
public boolean releaseProvider(IContentProvider provider) {
    return false;
}