android.content.pm.ProviderInfo Java Examples

@Override
protected void afterInvoke(Object receiver, Method method, Object[] args, Object invokeResult) throws Throwable {
    if (args != null) {
        if (invokeResult == null) {
            final int index0 = 0, index1 = 1;
            if (args.length >= 2 && args[index0] instanceof String && args[index1] instanceof Integer) {
                String name = (String) args[index0];
                Integer flags = (Integer) args[index1];
                ProviderInfo info = PluginManager.getInstance().resolveContentProvider(name, flags);
                if (info != null) {
                    setFakedResult(info);
                }
            }
        }
    }
    super.afterInvoke(receiver, method, args, invokeResult);
}
 

@Override
public ProviderInfo getProviderInfo(ComponentName className, int flags)
        throws NameNotFoundException {
    final int userId = getUserId();
    try {
        ProviderInfo pi = mPM.getProviderInfo(className,
                updateFlagsForComponent(flags, userId, null), userId);
        if (pi != null) {
            return pi;
        }
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }

    throw new NameNotFoundException(className.toString());
}
 

/**
 * Lists all defined providers with additional meta-data
 *
 * @param packageInfo from {@link PackageManager#getPackageInfo(String, int)} requiring {@link PackageManager#GET_PROVIDERS} flag
 * @return entries
 */
public static List<PageEntry<?>> createPmProviderInfo(@NonNull PackageInfo packageInfo) {
    List<PageEntry<?>> entries = new ArrayList<>();
    if (packageInfo.providers != null) {
        for (ProviderInfo provider : packageInfo.providers) {
            if (provider != null) {
                entries.add(Hood.get().createPropertyEntry(provider.name,
                        "exported: " + provider.exported + "\n" +
                                "enabled: " + provider.enabled + "\n" +
                                "authorities: " + provider.authority + "\n" +
                                "multi-process: " + provider.multiprocess + "\n" +
                                "read-perm: " + provider.readPermission + "\n" +
                                "write-perm: " + provider.writePermission + "\n", true));
            }
        }
    }
    return entries;
}
 

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

    for (ProviderInfo cpi : providers) {
        StringBuilder buf = new StringBuilder(128);
        buf.append("Pub ");
        buf.append(cpi.authority);
        buf.append(": ");
        buf.append(cpi.name);
        Log.i(TAG, buf.toString());
        IActivityManager.ContentProviderHolder cph = installProvider(context, null, cpi,
                false /*noisy*/, true /*noReleaseNeeded*/, true /*stable*/);
        if (cph != null) {
            cph.noReleaseNeeded = true;
            results.add(cph);
        }
    }

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

/**
 * 安装阶段调用，把package对应的provider存入sp中。
 *
 * @param hostContext Context
 * @param providers   ProviderInfo[]
 */
public static void addProviders(Context hostContext, ProviderInfo[] providers) {
    if (hostContext == null || providers == null || providers.length == 0) {
        return;
    }

    SharedPreferences sp = hostContext.getSharedPreferences(SP_FILENAME, Context.MODE_PRIVATE);
    Editor editor = sp.edit();

    for (ProviderInfo provider : providers) {
        String packageName = provider.packageName;
        String authority = provider.authority;

        if (sp.contains(authority)) {
            if (Constants.DEBUG) {
                Log.e("ContentProviderProxy", packageName + "的provider: " + authority
                        + " 已经存在 , replace it.");
            }
        }

        editor.putString(authority, packageName);
    }

    editor.commit();
}
 

/**
 * After the FileProvider is instantiated, this method is called to provide the system with
 * information about the provider.
 *
 * @param context A {@link Context} for the current component.
 * @param info A {@link ProviderInfo} for the new provider.
 */
@Override
public void attachInfo(Context context, ProviderInfo info) {
    super.attachInfo(context, info);

    // Sanity check our security
    if (info.exported) {
        throw new SecurityException("Provider must not be exported");
    }
    if (!info.grantUriPermissions) {
        throw new SecurityException("Provider must grant uri permissions");
    }

    mStrategy = getPathStrategy(context, info.authority);
}
 

private PackageParser.Package getDefaultProviderAuthorityPackage(
        String authority, int userId) {
    ProviderInfo provider =
            mServiceInternal.resolveContentProvider(authority, DEFAULT_FLAGS, userId);
    if (provider != null) {
        return getSystemPackage(provider.packageName);
    }
    return null;
}
 

private List<ProviderInfo> generateProviderInfos(List<DynamicApkParser.Provider> providers) {
    List<ProviderInfo> providerInfos = new ArrayList<>();
    for (DynamicApkParser.Provider p : providers) {
        p.info.packageName = getHostPackageName();
        p.info.applicationInfo.packageName = getHostPackageName();
        providerInfos.add(p.info);
    }
    return providerInfos;
}
 

@Override
public void attachInfo(Context context, ProviderInfo info) {
    super.attachInfo(context, info);
    if (info.exported) {
        throw new SecurityException("Provider must not be exported");
    }
    if (!info.grantUriPermissions) {
        throw new SecurityException("Provider must grant uri permissions");
    }

    mStrategy = getPathStrategy(context, info.authority);
}
 

@Override
public Object call(Object who, Method method, Object... args) throws Throwable {
	String processName = (String) args[0];
	int flags = (int) args[2];
	List<ProviderInfo> infos = VPackageManager.get().queryContentProviders(processName, flags, 0);
	if (ParceledListSliceCompat.isReturnParceledListSlice(method)) {
		return ParceledListSliceCompat.create(infos);
	}
	return infos;
}
 

@Override
public ProviderInfo getProviderInfo(ComponentName className, int flags)
        throws NameNotFoundException {
    try {
        ProviderInfo pi = mPM.getProviderInfo(className, flags, mContext.getUserId());
        if (pi != null) {
            return pi;
        }
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }

    throw new NameNotFoundException(className.toString());
}
 

private ContentProviderHolder(Parcel source) {
    info = ProviderInfo.CREATOR.createFromParcel(source);
    provider = ContentProviderNative.asInterface(
            source.readStrongBinder());
    connection = source.readStrongBinder();
    noReleaseNeeded = source.readInt() != 0;
}
 

/**
 * コンストラクタ.
 * 
 * @param context コンテキスト
 * @param fileProvider FileProviderクラス名
 */
public FileManager(final Context context, final String fileProvider) {
    mContext = context;
    mFileProviderClassName = fileProvider;
    File dir = getBasePath();
    if (!dir.exists()) {
        if (!dir.mkdirs()) {
            mLogger.warning("Cannot create a folder.");
        }
    }

    PackageManager pkgMgr = context.getPackageManager();
    try {
        PackageInfo packageInfo = pkgMgr.getPackageInfo(context.getPackageName(), PackageManager.GET_PROVIDERS);
        ProviderInfo[] providers = packageInfo.providers;
        if (providers != null) {
            for (ProviderInfo provider : providers) {
                if (mFileProviderClassName.equals(provider.name)) {
                    mAuthority = provider.authority;
                }
            }
        }
        if (mAuthority == null) {
            throw new RuntimeException("Cannot found provider.");
        }
    } catch (NameNotFoundException e) {
        throw new RuntimeException("Cannot found provider.");
    }

    mWorkerThread = new HandlerThread(getClass().getSimpleName());
    mWorkerThread.start();
    mHandler = new Handler(mWorkerThread.getLooper());
}
 

@Override
public void attachInfo(Context context, ProviderInfo info) {
  // applicationId is expected to be prepended. See AndroidManifest.xml
  if (SentryInitProvider.class.getName().equals(info.authority)) {
    throw new IllegalStateException(
        "An applicationId is required to fulfill the manifest placeholder.");
  }
  super.attachInfo(context, info);
}
 

@TargetApi(VERSION_CODES.KITKAT)
    private static ResolveInfo newResolveInfo(ProviderInfo providerInfo, IntentFilter intentFilter) {
        ResolveInfo resolveInfo = new ResolveInfo();
        resolveInfo.providerInfo = providerInfo;
        resolveInfo.filter = intentFilter;
        resolveInfo.resolvePackageName = providerInfo.packageName;
        resolveInfo.labelRes = providerInfo.labelRes;
        resolveInfo.icon = providerInfo.icon;
        resolveInfo.specificIndex = 1;
//      默认就是false，不用再设置了。
//        resolveInfo.system = false;
        resolveInfo.priority = intentFilter.getPriority();
        resolveInfo.preferredOrder = 0;
        return resolveInfo;
    }
 

private String getMyAuthority() throws NameNotFoundException, IllegalAccessException {
    if (VERSION.SDK_INT >= 21) {
        return (String) FieldUtils.readField((Object) this, "mAuthority");
    }
    Context context = getContext();
    PackageInfo pkgInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 8);
    if (!(pkgInfo == null || pkgInfo.providers == null || pkgInfo.providers.length <= 0)) {
        for (ProviderInfo info : pkgInfo.providers) {
            if (TextUtils.equals(info.name, getClass().getName())) {
                return info.authority;
            }
        }
    }
    return null;
}
 

@Override
public void attachInfo(Context context, ProviderInfo providerInfo) {
    if (providerInfo == null) {
        throw new NullPointerException("CrashReporterInitProvider ProviderInfo cannot be null.");
    }
    // So if the authorities equal the library internal ones, the developer forgot to set his applicationId
    if ("com.balsikandar.crashreporter.CrashReporterInitProvider".equals(providerInfo.authority)) {
        throw new IllegalStateException("Incorrect provider authority in manifest. Most likely due to a "
                + "missing applicationId variable in application\'s build.gradle.");
    }
    super.attachInfo(context, providerInfo);
}
 

public static Drawable loadPackageIcon(Context context, String authority, int icon) {
    if (icon != 0) {
        if (authority != null) {
            final PackageManager pm = context.getPackageManager();
            final ProviderInfo info = pm.resolveContentProvider(authority, 0);
            if (info != null) {
                return pm.getDrawable(info.packageName, icon, info.applicationInfo);
            }
        } else {
            return ContextCompat.getDrawable(context, icon);
        }
    }
    return null;
}
 

@Override
public void attachInfo(Context context, ProviderInfo info) {
    super.attachInfo(context, info);
    TRANSACTION_URI = Uri.parse("content://" + info.authority + "/transaction");
    matcher.addURI(info.authority, "transaction/#", TRANSACTION);
    matcher.addURI(info.authority, "transaction", TRANSACTIONS);
}
 

@Override
@SuppressWarnings("unchecked")
public List<ProviderInfo> queryContentProviders(String processName,
        int uid, int flags, String metaDataKey) {
    try {
        ParceledListSlice<ProviderInfo> slice =
                mPM.queryContentProviders(processName, uid, flags, metaDataKey);
        return slice != null ? slice.getList() : Collections.<ProviderInfo>emptyList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/** @hide **/
@Override
public ProviderInfo resolveContentProviderAsUser(String name, int flags, int userId) {
    try {
        return mPM.resolveContentProvider(name, flags, userId);
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

private Set<String> findDisallowedContentProviderAuthorities() {
    ProviderInfo[] providers = getProviderInfo(context);

    Set<String> disallowedAuthorities = new HashSet<>(providers.length);
    for (ProviderInfo providerInfo : providers) {
        if (!isContentProviderAllowed(providerInfo)) {
            String[] authorities = providerInfo.authority.split(";");
            Collections.addAll(disallowedAuthorities, authorities);
        }
    }

    return disallowedAuthorities;
}
 

@Override
public void attachInfo(Context context, ProviderInfo info) {
    super.attachInfo(context, info);

    // Sanity check our security
    if (info.exported) {
        throw new SecurityException("Provider must not be exported");
    }
    if (!info.grantUriPermissions) {
        throw new SecurityException("Provider must grant uri permissions");
    }

    mStrategy = getPathStrategy(context, info.authority);
}
 

@Override
public ProviderInfo getProviderInfo(ComponentName component, int flags) throws NameNotFoundException {
    LoadedPlugin plugin = mPluginManager.getLoadedPlugin(component);
    if (null != plugin) {
        return plugin.mProviderInfos.get(component);
    }

    return this.mHostPackageManager.getProviderInfo(component, flags);
}
 

private void initializeContentProviderInfo() {
	PackageInfo packageInfo = mPluginClient.mClientPackageInfo;
	if ((packageInfo.providers != null)
			&& (packageInfo.providers.length > 0)) {
		if (TextUtils.isEmpty(mPluginClientContentProviderClass)) {
			mPluginClientContentProviderClass = packageInfo.providers[0].name;
		}
		for (ProviderInfo a : packageInfo.providers) {
			if (a.name.equals(mPluginClientContentProviderClass)) {
				mProviderInfo = a;
			}
		}
	}
}
 

@Override
public void attachInfo(Context context, ProviderInfo info) {
    super.attachInfo(context, info);

    // Sanity check our security
    if (info.exported) {
        throw new SecurityException("Provider must not be exported");
    }
    if (!info.grantUriPermissions) {
        throw new SecurityException("Provider must grant uri permissions");
    }

    mStrategy = getPathStrategy(context, info.authority);
}
 

private static void doValidateProcessNames(final Application app, final String[] process_names) {
	try {
		final PackageInfo info = app.getPackageManager().getPackageInfo(app.getPackageName(),
				GET_ACTIVITIES | GET_SERVICES | GET_RECEIVERS | GET_PROVIDERS);
		final Set<String> defined_process_names = new HashSet<>();
		if (info.activities != null) for (final ActivityInfo activity : info.activities) defined_process_names.add(activity.processName);
		if (info.services != null) for (final ServiceInfo service : info.services) defined_process_names.add(service.processName);
		if (info.receivers != null) for (final ActivityInfo receiver : info.receivers) defined_process_names.add(receiver.processName);
		if (info.providers != null) for (final ProviderInfo provider : info.providers) defined_process_names.add(provider.processName);
		for (final String process_name : process_names)
			if (! defined_process_names.contains(getFullProcessName(app, process_name)))
				throw new IllegalArgumentException("Process name \"" + process_name + "\" is not used by any component in AndroidManifest.xml");
	} catch (final PackageManager.NameNotFoundException ignored) {}		// Should never happen
}
 

public String getExportedContentProvider() {
    StringBuilder sb = new StringBuilder();
    if (mPInfo.providers != null) {
        for (ProviderInfo pi : mPInfo.providers) {
            String piName = pi.name;
            if (pi.exported) {

                //Grant Uri Permissions
                piName = piName + " GRANT: " + String.valueOf(pi.grantUriPermissions) + "|";

                if (pi.authority != null) {
                    piName = piName + " AUTHORITY: " + pi.authority + "|";
                }

                if (pi.readPermission != null) {
                    piName = piName + " READ: " + pi.readPermission + "|";
                }
                if (pi.writePermission != null) {
                    piName = piName + " WRITE: " + pi.writePermission + "|";
                }
                PathPermission[] pp = pi.pathPermissions;
                if (pp != null) {
                    for (PathPermission pathPermission : pp) {
                        piName = piName + " PATH: " + pathPermission.getPath() + "|";
                        piName = piName + "  - READ: " + pathPermission.getReadPermission() + "|";
                        piName = piName + "  - WRITE: " + pathPermission.getWritePermission() + "|";
                    }
                }
                sb.append(piName + "\n");
            }
        }
    } else {
        sb.append(" -- null");
    }
    return sb.toString();
}
 

@Override
public ProviderInfo getProviderInfo(ComponentName className, int flags)
        throws NameNotFoundException {
    try {
        ProviderInfo pi = mPM.getProviderInfo(className, flags);
        if (pi != null) {
            return pi;
        }
    } catch (RemoteException e) {
        throw new RuntimeException("Package manager has died", e);
    }

    throw new NameNotFoundException(className.toString());
}
 

/** {@hide} */
@Override
public void attachInfoForTesting(Context context, ProviderInfo info) {
    registerAuthority(info.authority);

    super.attachInfoForTesting(context, info);
}