android.content.ContentProvider Java Examples

private ProviderClientRecord installProviderAuthoritiesLocked(IContentProvider provider,
        ContentProvider localProvider,IActivityManager.ContentProviderHolder holder) {
    String names[] = PATTERN_SEMICOLON.split(holder.info.authority);
    ProviderClientRecord pcr = new ProviderClientRecord(names, provider,
            localProvider, holder);
    for (int i = 0; i < names.length; i++) {
        ProviderClientRecord existing = mProviderMap.get(names[i]);
        if (existing != null) {
            Slog.w(TAG, "Content provider " + pcr.mHolder.info.name
                    + " already published as " + names[i]);
        } else {
            mProviderMap.put(names[i], pcr);
        }
    }
    return pcr;
}
 

@Override
@Nullable
public Context resolveContext(Object object) throws Exception {
	if (object instanceof View) {
		return ((View) object).getContext();
	} else if (object instanceof Fragment) {
		return ((Fragment) object).getActivity();
	} else if (object instanceof Context) {
		return (Context) object;
	} else if (object instanceof ContentProvider) {
		return ((ContentProvider) object).getContext();
	} else if (object instanceof ContextProvider) {
		return ((ContextProvider) object).getContext();
	} else if (object instanceof ViewProvider) {
		return ((ViewProvider) object).getView().getContext();
	} else {
		return null;
	}
}
 

private final void checkUriOwnerLocked(Uri uri, int sourceUid) {
    if (uri == null || !ContentResolver.SCHEME_CONTENT.equals(uri.getScheme())) return;

    final long ident = Binder.clearCallingIdentity();
    try {
        // This will throw SecurityException if caller can't grant
        mAm.checkGrantUriPermission(sourceUid, null,
                ContentProvider.getUriWithoutUserId(uri),
                Intent.FLAG_GRANT_READ_URI_PERMISSION,
                ContentProvider.getUserIdFromUri(uri, UserHandle.getUserId(sourceUid)));
    } catch (RemoteException ignored) {
        // Ignored because we're in same process
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
}
 

private static GrantedUriPermissions grantUri(IActivityManager am, Uri uri,
        int sourceUid, String targetPackage, int targetUserId, int grantFlags, String tag,
        GrantedUriPermissions curPerms) {
    try {
        int sourceUserId = ContentProvider.getUserIdFromUri(uri,
                UserHandle.getUserId(sourceUid));
        uri = ContentProvider.getUriWithoutUserId(uri);
        if (curPerms == null) {
            curPerms = new GrantedUriPermissions(am, grantFlags, sourceUid, tag);
        }
        am.grantUriPermissionFromOwner(curPerms.mPermissionOwner, sourceUid, targetPackage,
                uri, grantFlags, sourceUserId, targetUserId);
        curPerms.mUris.add(uri);
    } catch (RemoteException e) {
        Slog.e("JobScheduler", "AM dead");
    }
    return curPerms;
}
 

@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
    PluginProviderHelper.PluginUri pu = mHelper.toPluginUri(uri);
    if (pu == null) {
        return null;
    }
    ContentProvider cp = mHelper.getProvider(pu);
    if (cp == null) {
        return null;
    }
    return cp.query(pu.transferredUri, projection, selection, selectionArgs, sortOrder);
}
 

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

public ContentProvider getProvider() {
    Object o = RefInvoker.getField(instance, ClassName, Field_mProvider);
    if (o instanceof ContentProvider) {//maybe ContentProviderProxy
        return (ContentProvider) o;
    }
    return null;
}
 

@Override
public void revokeUriPermission(Uri uri, int modeFlags) {
     try {
        ActivityManager.getService().revokeUriPermission(
                mMainThread.getApplicationThread(), null,
                ContentProvider.getUriWithoutUserId(uri), modeFlags, resolveUserId(uri));
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

protected static @NonNull <T extends AppListProvider> T getInstance(final Context context) {
	final String authority = context.getPackageName() + AUTHORITY_SUFFIX;		// Do not use BuildConfig.APPLICATION_ID
	final ContentProviderClient client = context.getContentResolver().acquireContentProviderClient(authority);
	if (client == null) throw new IllegalStateException("AppListProvider not associated with authority: " + authority);
	try {
		final ContentProvider provider = client.getLocalContentProvider();
		if (provider == null)
			throw new IllegalStateException("android:multiprocess=\"true\" is required for this provider.");
		if (! (provider instanceof AppListProvider)) throw new IllegalArgumentException("");
		@SuppressWarnings("unchecked") final T casted = (T) provider;
		return casted;
	} finally { //noinspection deprecation
		client.release();
	}
}
 

/** @hide */
@Override
public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) {
    try {
        return ActivityManager.getService().checkUriPermission(
                ContentProvider.getUriWithoutUserId(uri), pid, uid, modeFlags,
                resolveUserId(uri), callerToken);
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) {
    try {
        return ActivityManager.getService().checkUriPermission(
                ContentProvider.getUriWithoutUserId(uri), pid, uid, modeFlags,
                resolveUserId(uri), null);
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
    PluginProviderHelper.PluginUri pu = mHelper.toPluginUri(uri);
    if (pu == null) {
        return -1;
    }
    ContentProvider cp = mHelper.getProvider(pu);
    if (cp == null) {
        return -1;
    }
    return cp.delete(pu.transferredUri, selection, selectionArgs);
}
 

private String getAuthority(Context context, Class<? extends ContentProvider> providerClass) {
    PackageManager manager = context.getApplicationContext().getPackageManager();
    try {
        ProviderInfo providerInfo = manager.getProviderInfo(
                new ComponentName(context, providerClass), PackageManager.GET_META_DATA);
        return providerInfo.authority;
    } catch (PackageManager.NameNotFoundException e) {
        throw new IllegalStateException(e);
    }
}
 

@Override
public int delete(@NonNull Uri uri, String selection, String[] selectionArgs) {
    ContentProvider provider = getContentProvider(uri);
    if (provider != null) {
        Uri pluginUri = Uri.parse(uri.getQueryParameter(IntentConstant.EXTRA_TARGET_URI_KEY));
        return provider.delete(pluginUri, selection, selectionArgs);
    }
    return 0;
}
 

@Override
public Cursor query(Uri uri, String[] projection,
                    String selection, String[] selectionArgs, String sortOrder) {
    ContentProvider mContentProvider = getContentProvider();
    if (mContentProvider != null) {
        return mContentProvider.query(uri, projection, selection, selectionArgs, sortOrder);
    }
    return null;
}
 

@Override
public Uri insert(@NonNull Uri uri, ContentValues values) {
    ContentProvider provider = getContentProvider(uri);
    if (provider != null) {
        Uri pluginUri = Uri.parse(uri.getQueryParameter(IntentConstant.EXTRA_TARGET_URI_KEY));
        return provider.insert(pluginUri, values);
    }
    return null;
}
 

@Override
public void revokeUriPermission(Uri uri, int modeFlags) {
     try {
        ActivityManager.getService().revokeUriPermission(
                mMainThread.getApplicationThread(), null,
                ContentProvider.getUriWithoutUserId(uri), modeFlags, resolveUserId(uri));
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@VisibleForTesting
ProviderTestRule(
    Set<WeakReference<ContentProvider>> providersRef,
    Set<DatabaseArgs> databaseArgsSet,
    ContentResolver resolver,
    DelegatingContext context) {
  this.providersRef = providersRef;
  this.databaseArgsSet = databaseArgsSet;
  this.resolver = resolver;
  this.context = context;
}
 

@Override
public void grantUriPermission(String toPackage, Uri uri, int modeFlags) {
     try {
        ActivityManagerNative.getDefault().grantUriPermission(
                mMainThread.getApplicationThread(), toPackage,
                ContentProvider.getUriWithoutUserId(uri), modeFlags, resolveUserId(uri));
    } catch (RemoteException e) {
    }
}
 

/** @hide */
@Override
public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) {
    try {
        return ActivityManager.getService().checkUriPermission(
                ContentProvider.getUriWithoutUserId(uri), pid, uid, modeFlags,
                resolveUserId(uri), callerToken);
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) {
    try {
        return ActivityManager.getService().checkUriPermission(
                ContentProvider.getUriWithoutUserId(uri), pid, uid, modeFlags,
                resolveUserId(uri), null);
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
public void revokeUriPermission(String targetPackage, Uri uri, int modeFlags) {
    try {
        ActivityManager.getService().revokeUriPermission(
                mMainThread.getApplicationThread(), targetPackage,
                ContentProvider.getUriWithoutUserId(uri), modeFlags, resolveUserId(uri));
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
public void revokeUriPermission(Uri uri, int modeFlags) {
     try {
        ActivityManager.getService().revokeUriPermission(
                mMainThread.getApplicationThread(), null,
                ContentProvider.getUriWithoutUserId(uri), modeFlags, resolveUserId(uri));
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
public void grantUriPermission(String toPackage, Uri uri, int modeFlags) {
     try {
        ActivityManager.getService().grantUriPermission(
                mMainThread.getApplicationThread(), toPackage,
                ContentProvider.getUriWithoutUserId(uri), modeFlags, resolveUserId(uri));
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/*****验证ContentProvider实现类是否加载*****/
protected ContentProvider getContentProvider() {
    if (this.mContentProvider != null) {
        return this.mContentProvider;
    }
    try {
        Class<?> loadClass = Globals.getClassLoader().loadClass(mTargetProvider);
        if (loadClass != null) {
            Constructor<?> constructor = loadClass.getConstructor();
            constructor.setAccessible(true);
            this.mContentProvider = (ContentProvider) constructor.newInstance();
            Field declaredField = ContentProvider.class.getDeclaredField("mContext");
            declaredField.setAccessible(true);
            declaredField.set(this.mContentProvider, getContext());
            declaredField = ContentProvider.class.getDeclaredField("mReadPermission");
            declaredField.setAccessible(true);
            declaredField.set(this.mContentProvider, getReadPermission());
            declaredField = ContentProvider.class.getDeclaredField("mWritePermission");
            declaredField.setAccessible(true);
            declaredField.set(this.mContentProvider, getWritePermission());
            declaredField = ContentProvider.class.getDeclaredField("mPathPermissions");
            declaredField.setAccessible(true);
            declaredField.set(this.mContentProvider, getPathPermissions());
            this.mContentProvider.onCreate();
            return this.mContentProvider;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
 

@Override
public void grantUriPermission(String toPackage, Uri uri, int modeFlags) {
     try {
        ActivityManager.getService().grantUriPermission(
                mMainThread.getApplicationThread(), toPackage,
                ContentProvider.getUriWithoutUserId(uri), modeFlags, resolveUserId(uri));
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/**
 * Note the presence of a {@link Uri} that should have permission granted to
 * whoever will be rendering it.
 * <p>
 * If the enqueuing app has the ability to grant access, it will be added to
 * {@link #mGrantableUris}. Otherwise, this will either log or throw
 * {@link SecurityException} depending on target SDK of enqueuing app.
 */
private void visitGrantableUri(Uri uri, boolean userOverriddenUri) {
    if (uri == null || !ContentResolver.SCHEME_CONTENT.equals(uri.getScheme())) return;

    // We can't grant Uri permissions from system
    final int sourceUid = sbn.getUid();
    if (sourceUid == android.os.Process.SYSTEM_UID) return;

    final long ident = Binder.clearCallingIdentity();
    try {
        // This will throw SecurityException if caller can't grant
        mAm.checkGrantUriPermission(sourceUid, null,
                ContentProvider.getUriWithoutUserId(uri),
                Intent.FLAG_GRANT_READ_URI_PERMISSION,
                ContentProvider.getUserIdFromUri(uri, UserHandle.getUserId(sourceUid)));

        if (mGrantableUris == null) {
            mGrantableUris = new ArraySet<>();
        }
        mGrantableUris.add(uri);
    } catch (RemoteException ignored) {
        // Ignored because we're in same process
    } catch (SecurityException e) {
        if (!userOverriddenUri) {
            if (mTargetSdkVersion >= Build.VERSION_CODES.P) {
                throw e;
            } else {
                Log.w(TAG, "Ignoring " + uri + " from " + sourceUid + ": " + e.getMessage());
            }
        }
    } finally {
        Binder.restoreCallingIdentity(ident);
    }
}
 

@Override
public String getType(Uri uri) {
    PluginProviderHelper.PluginUri pu = mHelper.toPluginUri(uri);
    if (pu == null) {
        return null;
    }
    ContentProvider cp = mHelper.getProvider(pu);
    if (cp == null) {
        return null;
    }
    return cp.getType(pu.transferredUri);
}
 

/** @hide */
@Override
public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags, IBinder callerToken) {
    try {
        return ActivityManager.getService().checkUriPermission(
                ContentProvider.getUriWithoutUserId(uri), pid, uid, modeFlags,
                resolveUserId(uri), callerToken);
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) {
    try {
        return ActivityManager.getService().checkUriPermission(
                ContentProvider.getUriWithoutUserId(uri), pid, uid, modeFlags,
                resolveUserId(uri), null);
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}