| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.appenumeration.cts.query; |
| |
| import static android.appenumeration.cts.Constants.ACTION_CHECK_SIGNATURES; |
| import static android.appenumeration.cts.Constants.ACTION_GET_INSTALLED_PACKAGES; |
| import static android.appenumeration.cts.Constants.ACTION_GET_NAMES_FOR_UIDS; |
| import static android.appenumeration.cts.Constants.ACTION_GET_NAME_FOR_UID; |
| import static android.appenumeration.cts.Constants.ACTION_GET_PACKAGES_FOR_UID; |
| import static android.appenumeration.cts.Constants.ACTION_GET_PACKAGE_INFO; |
| import static android.appenumeration.cts.Constants.ACTION_HAS_SIGNING_CERTIFICATE; |
| import static android.appenumeration.cts.Constants.ACTION_JUST_FINISH; |
| import static android.appenumeration.cts.Constants.ACTION_QUERY_ACTIVITIES; |
| import static android.appenumeration.cts.Constants.ACTION_QUERY_PROVIDERS; |
| import static android.appenumeration.cts.Constants.ACTION_QUERY_SERVICES; |
| import static android.appenumeration.cts.Constants.ACTION_SEND_RESULT; |
| import static android.appenumeration.cts.Constants.ACTION_START_DIRECTLY; |
| import static android.appenumeration.cts.Constants.ACTION_START_FOR_RESULT; |
| import static android.appenumeration.cts.Constants.ACTION_START_SENDER_FOR_RESULT; |
| import static android.appenumeration.cts.Constants.CALLBACK_EVENT_INVALID; |
| import static android.appenumeration.cts.Constants.CALLBACK_EVENT_PACKAGES_AVAILABLE; |
| import static android.appenumeration.cts.Constants.CALLBACK_EVENT_PACKAGES_SUSPENDED; |
| import static android.appenumeration.cts.Constants.CALLBACK_EVENT_PACKAGES_UNAVAILABLE; |
| import static android.appenumeration.cts.Constants.CALLBACK_EVENT_PACKAGES_UNSUSPENDED; |
| import static android.appenumeration.cts.Constants.CALLBACK_EVENT_PACKAGE_ADDED; |
| import static android.appenumeration.cts.Constants.CALLBACK_EVENT_PACKAGE_CHANGED; |
| import static android.appenumeration.cts.Constants.CALLBACK_EVENT_PACKAGE_REMOVED; |
| import static android.appenumeration.cts.Constants.EXTRA_AUTHORITY; |
| import static android.appenumeration.cts.Constants.EXTRA_CERT; |
| import static android.appenumeration.cts.Constants.EXTRA_DATA; |
| import static android.appenumeration.cts.Constants.EXTRA_ERROR; |
| import static android.appenumeration.cts.Constants.EXTRA_FLAGS; |
| import static android.appenumeration.cts.Constants.EXTRA_REMOTE_CALLBACK; |
| import static android.appenumeration.cts.Constants.EXTRA_REMOTE_READY_CALLBACK; |
| import static android.content.Intent.EXTRA_COMPONENT_NAME; |
| import static android.content.Intent.EXTRA_PACKAGES; |
| import static android.content.Intent.EXTRA_RETURN_RESULT; |
| import static android.content.pm.PackageManager.CERT_INPUT_RAW_X509; |
| import static android.os.Process.INVALID_UID; |
| |
| import android.app.Activity; |
| import android.app.PendingIntent; |
| import android.appenumeration.cts.Constants; |
| import android.appenumeration.cts.MissingBroadcastException; |
| import android.appwidget.AppWidgetManager; |
| import android.appwidget.AppWidgetProviderInfo; |
| import android.content.ActivityNotFoundException; |
| import android.content.BroadcastReceiver; |
| import android.content.ComponentName; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.IntentSender; |
| import android.content.ServiceConnection; |
| import android.content.SyncAdapterType; |
| import android.content.pm.LauncherApps; |
| import android.content.pm.PackageInfo; |
| import android.content.pm.PackageManager; |
| import android.content.pm.SharedLibraryInfo; |
| import android.database.Cursor; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.IBinder; |
| import android.os.Parcelable; |
| import android.os.PatternMatcher; |
| import android.os.Process; |
| import android.os.RemoteCallback; |
| import android.os.UserHandle; |
| import android.util.SparseArray; |
| import android.view.accessibility.AccessibilityManager; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.stream.Collectors; |
| |
| public class TestActivity extends Activity { |
| |
| private final static long TIMEOUT_MS = 3000; |
| |
| /** |
| * Extending the timeout time of non broadcast receivers, avoid not |
| * receiving callbacks in time on some common low-end platforms and |
| * do not affect the situation that callback can be received in advance. |
| */ |
| private final static long EXTENDED_TIMEOUT_MS = 5000; |
| |
| SparseArray<RemoteCallback> callbacks = new SparseArray<>(); |
| |
| private Handler mainHandler; |
| private Handler backgroundHandler; |
| private HandlerThread backgroundThread; |
| |
| @Override |
| protected void onCreate(Bundle savedInstanceState) { |
| mainHandler = new Handler(getMainLooper()); |
| backgroundThread = new HandlerThread("testBackground"); |
| backgroundThread.start(); |
| backgroundHandler = new Handler(backgroundThread.getLooper()); |
| super.onCreate(savedInstanceState); |
| handleIntent(getIntent()); |
| onCommandReady(getIntent()); |
| } |
| |
| @Override |
| protected void onDestroy() { |
| backgroundThread.quitSafely(); |
| super.onDestroy(); |
| } |
| |
| private void handleIntent(Intent intent) { |
| RemoteCallback remoteCallback = intent.getParcelableExtra(EXTRA_REMOTE_CALLBACK); |
| try { |
| final String action = intent.getAction(); |
| final Intent queryIntent = intent.getParcelableExtra(Intent.EXTRA_INTENT); |
| if (ACTION_GET_PACKAGE_INFO.equals(action)) { |
| final String packageName = intent.getStringExtra(Intent.EXTRA_PACKAGE_NAME); |
| sendPackageInfo(remoteCallback, packageName); |
| } else if (ACTION_GET_PACKAGES_FOR_UID.equals(action)) { |
| final int uid = intent.getIntExtra(Intent.EXTRA_UID, INVALID_UID); |
| sendPackagesForUid(remoteCallback, uid); |
| } else if (ACTION_GET_NAME_FOR_UID.equals(action)) { |
| final int uid = intent.getIntExtra(Intent.EXTRA_UID, INVALID_UID); |
| sendNameForUid(remoteCallback, uid); |
| } else if (ACTION_GET_NAMES_FOR_UIDS.equals(action)) { |
| final int uid = intent.getIntExtra(Intent.EXTRA_UID, INVALID_UID); |
| sendNamesForUids(remoteCallback, uid); |
| } else if (ACTION_CHECK_SIGNATURES.equals(action)) { |
| final int uid1 = getPackageManager().getApplicationInfo( |
| getPackageName(), /* flags */ 0).uid; |
| final int uid2 = intent.getIntExtra(Intent.EXTRA_UID, INVALID_UID); |
| sendCheckSignatures(remoteCallback, uid1, uid2); |
| } else if (ACTION_HAS_SIGNING_CERTIFICATE.equals(action)) { |
| final int uid = intent.getIntExtra(Intent.EXTRA_UID, INVALID_UID); |
| final byte[] cert = intent.getBundleExtra(EXTRA_DATA).getByteArray(EXTRA_CERT); |
| sendHasSigningCertificate(remoteCallback, uid, cert, CERT_INPUT_RAW_X509); |
| } else if (ACTION_START_FOR_RESULT.equals(action)) { |
| final String packageName = intent.getStringExtra(Intent.EXTRA_PACKAGE_NAME); |
| int requestCode = RESULT_FIRST_USER + callbacks.size(); |
| callbacks.put(requestCode, remoteCallback); |
| startActivityForResult( |
| new Intent(ACTION_SEND_RESULT).setComponent( |
| new ComponentName(packageName, getClass().getCanonicalName())), |
| requestCode); |
| // don't send anything... await result callback |
| } else if (ACTION_SEND_RESULT.equals(action)) { |
| try { |
| setResult(RESULT_OK, |
| getIntent().putExtra( |
| Intent.EXTRA_RETURN_RESULT, |
| getPackageManager().getPackageInfo(getCallingPackage(), 0))); |
| } catch (PackageManager.NameNotFoundException e) { |
| setResult(RESULT_FIRST_USER, new Intent().putExtra("error", e)); |
| } |
| finish(); |
| } else if (ACTION_QUERY_ACTIVITIES.equals(action)) { |
| sendQueryIntentActivities(remoteCallback, queryIntent); |
| } else if (ACTION_QUERY_SERVICES.equals(action)) { |
| sendQueryIntentServices(remoteCallback, queryIntent); |
| } else if (ACTION_QUERY_PROVIDERS.equals(action)) { |
| sendQueryIntentProviders(remoteCallback, queryIntent); |
| } else if (ACTION_START_DIRECTLY.equals(action)) { |
| try { |
| startActivity(queryIntent); |
| remoteCallback.sendResult(new Bundle()); |
| } catch (ActivityNotFoundException e) { |
| sendError(remoteCallback, e); |
| } |
| finish(); |
| } else if (ACTION_JUST_FINISH.equals(action)) { |
| finish(); |
| } else if (ACTION_GET_INSTALLED_PACKAGES.equals(action)) { |
| sendGetInstalledPackages(remoteCallback, queryIntent.getIntExtra(EXTRA_FLAGS, 0)); |
| } else if (ACTION_START_SENDER_FOR_RESULT.equals(action)) { |
| PendingIntent pendingIntent = intent.getParcelableExtra("pendingIntent"); |
| int requestCode = RESULT_FIRST_USER + callbacks.size(); |
| callbacks.put(requestCode, remoteCallback); |
| try { |
| startIntentSenderForResult(pendingIntent.getIntentSender(), requestCode, null, |
| 0, 0, 0); |
| } catch (IntentSender.SendIntentException e) { |
| sendError(remoteCallback, e); |
| } |
| } else if (Constants.ACTION_AWAIT_PACKAGE_REMOVED.equals(action)) { |
| final String packageName = intent.getStringExtra(Intent.EXTRA_PACKAGE_NAME); |
| awaitPackageBroadcast( |
| remoteCallback, packageName, Intent.ACTION_PACKAGE_REMOVED, TIMEOUT_MS); |
| } else if (Constants.ACTION_AWAIT_PACKAGE_ADDED.equals(action)) { |
| final String packageName = intent.getStringExtra(Intent.EXTRA_PACKAGE_NAME); |
| awaitPackageBroadcast( |
| remoteCallback, packageName, Intent.ACTION_PACKAGE_ADDED, TIMEOUT_MS); |
| } else if (Constants.ACTION_QUERY_RESOLVER.equals(action)) { |
| final String authority = intent.getStringExtra(Intent.EXTRA_PACKAGE_NAME); |
| queryResolverForVisiblePackages(remoteCallback, authority); |
| } else if (Constants.ACTION_BIND_SERVICE.equals(action)) { |
| final String packageName = intent.getStringExtra(Intent.EXTRA_PACKAGE_NAME); |
| bindService(remoteCallback, packageName); |
| } else if (Constants.ACTION_GET_SYNCADAPTER_TYPES.equals(action)) { |
| sendSyncAdapterTypes(remoteCallback); |
| } else if (Constants.ACTION_GET_INSTALLED_APPWIDGET_PROVIDERS.equals(action)) { |
| sendInstalledAppWidgetProviders(remoteCallback); |
| } else if (Constants.ACTION_AWAIT_PACKAGES_SUSPENDED.equals(action)) { |
| final String[] awaitPackages = intent.getBundleExtra(EXTRA_DATA) |
| .getStringArray(EXTRA_PACKAGES); |
| awaitSuspendedPackagesBroadcast(remoteCallback, Arrays.asList(awaitPackages), |
| Intent.ACTION_PACKAGES_SUSPENDED, TIMEOUT_MS); |
| } else if (Constants.ACTION_LAUNCHER_APPS_IS_ACTIVITY_ENABLED.equals(action)) { |
| final String componentName = intent.getBundleExtra(EXTRA_DATA) |
| .getString(EXTRA_COMPONENT_NAME); |
| sendIsActivityEnabled(remoteCallback, ComponentName.unflattenFromString( |
| componentName)); |
| } else if (Constants.ACTION_GET_SYNCADAPTER_PACKAGES_FOR_AUTHORITY.equals(action)) { |
| final String authority = intent.getBundleExtra(EXTRA_DATA) |
| .getString(EXTRA_AUTHORITY); |
| final int userId = intent.getBundleExtra(EXTRA_DATA) |
| .getInt(Intent.EXTRA_USER); |
| sendSyncAdapterPackagesForAuthorityAsUser(remoteCallback, authority, userId); |
| } else if (Constants.ACTION_AWAIT_LAUNCHER_APPS_CALLBACK.equals(action)) { |
| final int expectedEventCode = intent.getBundleExtra(EXTRA_DATA) |
| .getInt(EXTRA_FLAGS, CALLBACK_EVENT_INVALID); |
| awaitLauncherAppsCallback(remoteCallback, expectedEventCode, EXTENDED_TIMEOUT_MS); |
| } else if (Constants.ACTION_GET_SHAREDLIBRARY_DEPENDENT_PACKAGES.equals(action)) { |
| final String sharedLibName = intent.getStringExtra(Intent.EXTRA_PACKAGE_NAME); |
| sendGetSharedLibraryDependentPackages(remoteCallback, sharedLibName); |
| } else if (Constants.ACTION_GET_PREFERRED_ACTIVITIES.equals(action)) { |
| sendGetPreferredActivities(remoteCallback); |
| } else if (Constants.ACTION_SET_INSTALLER_PACKAGE_NAME.equals(action)) { |
| final String targetPackageName = intent.getStringExtra(Intent.EXTRA_PACKAGE_NAME); |
| final String installerPackageName = intent.getBundleExtra(EXTRA_DATA) |
| .getString(Intent.EXTRA_INSTALLER_PACKAGE_NAME); |
| sendSetInstallerPackageName(remoteCallback, targetPackageName, |
| installerPackageName); |
| } else if (Constants.ACTION_GET_INSTALLED_ACCESSIBILITYSERVICES_PACKAGES.equals( |
| action)) { |
| sendGetInstalledAccessibilityServicePackages(remoteCallback); |
| } else { |
| sendError(remoteCallback, new Exception("unknown action " + action)); |
| } |
| } catch (Exception e) { |
| sendError(remoteCallback, e); |
| } |
| } |
| |
| private void sendGetInstalledAccessibilityServicePackages(RemoteCallback remoteCallback) { |
| final String[] packages = getSystemService( |
| AccessibilityManager.class).getInstalledAccessibilityServiceList().stream().map( |
| p -> p.getComponentName().getPackageName()).distinct().toArray(String[]::new); |
| final Bundle result = new Bundle(); |
| result.putStringArray(EXTRA_RETURN_RESULT, packages); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void onCommandReady(Intent intent) { |
| final RemoteCallback callback = intent.getParcelableExtra(EXTRA_REMOTE_READY_CALLBACK); |
| if (callback != null) { |
| callback.sendResult(null); |
| } |
| } |
| |
| private void awaitPackageBroadcast(RemoteCallback remoteCallback, String packageName, |
| String action, long timeoutMs) { |
| final IntentFilter filter = new IntentFilter(action); |
| filter.addDataScheme("package"); |
| filter.addDataSchemeSpecificPart(packageName, PatternMatcher.PATTERN_LITERAL); |
| final Object token = new Object(); |
| registerReceiver(new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| final Bundle result = new Bundle(); |
| result.putString(EXTRA_DATA, intent.getDataString()); |
| remoteCallback.sendResult(result); |
| mainHandler.removeCallbacksAndMessages(token); |
| finish(); |
| } |
| }, filter); |
| mainHandler.postDelayed( |
| () -> sendError(remoteCallback, |
| new MissingBroadcastException(action, timeoutMs)), |
| token, timeoutMs); |
| } |
| |
| private void awaitSuspendedPackagesBroadcast(RemoteCallback remoteCallback, |
| List<String> awaitList, String action, long timeoutMs) { |
| final IntentFilter filter = new IntentFilter(action); |
| final ArrayList<String> suspendedList = new ArrayList<>(); |
| final Object token = new Object(); |
| final Runnable sendResult = () -> { |
| final Bundle result = new Bundle(); |
| result.putStringArray(EXTRA_PACKAGES, suspendedList.toArray(new String[] {})); |
| remoteCallback.sendResult(result); |
| finish(); |
| }; |
| registerReceiver(new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| final Bundle extras = intent.getExtras(); |
| final String[] changedList = extras.getStringArray( |
| Intent.EXTRA_CHANGED_PACKAGE_LIST); |
| suspendedList.addAll(Arrays.stream(changedList).filter( |
| p -> awaitList.contains(p)).collect(Collectors.toList())); |
| if (suspendedList.size() == awaitList.size()) { |
| mainHandler.removeCallbacksAndMessages(token); |
| sendResult.run(); |
| } |
| } |
| }, filter); |
| mainHandler.postDelayed(() -> sendResult.run(), token, timeoutMs); |
| } |
| |
| private void awaitLauncherAppsCallback(RemoteCallback remoteCallback, int expectedEventCode, |
| long timeoutMs) { |
| final Object token = new Object(); |
| final Bundle result = new Bundle(); |
| final LauncherApps launcherApps = getSystemService(LauncherApps.class); |
| final LauncherApps.Callback launcherAppsCallback = new LauncherApps.Callback() { |
| |
| private void onPackageStateUpdated(String[] packageNames, int resultCode) { |
| if (resultCode != expectedEventCode) { |
| return; |
| } |
| |
| mainHandler.removeCallbacksAndMessages(token); |
| result.putStringArray(EXTRA_PACKAGES, packageNames); |
| result.putInt(EXTRA_FLAGS, resultCode); |
| remoteCallback.sendResult(result); |
| |
| launcherApps.unregisterCallback(this); |
| finish(); |
| } |
| |
| @Override |
| public void onPackageRemoved(String packageName, UserHandle user) { |
| onPackageStateUpdated(new String[]{packageName}, CALLBACK_EVENT_PACKAGE_REMOVED); |
| } |
| |
| @Override |
| public void onPackageAdded(String packageName, UserHandle user) { |
| onPackageStateUpdated(new String[]{packageName}, CALLBACK_EVENT_PACKAGE_ADDED); |
| } |
| |
| @Override |
| public void onPackageChanged(String packageName, UserHandle user) { |
| onPackageStateUpdated(new String[]{packageName}, CALLBACK_EVENT_PACKAGE_CHANGED); |
| } |
| |
| @Override |
| public void onPackagesAvailable(String[] packageNames, UserHandle user, |
| boolean replacing) { |
| onPackageStateUpdated(packageNames, CALLBACK_EVENT_PACKAGES_AVAILABLE); |
| } |
| |
| @Override |
| public void onPackagesUnavailable(String[] packageNames, UserHandle user, |
| boolean replacing) { |
| onPackageStateUpdated(packageNames, CALLBACK_EVENT_PACKAGES_UNAVAILABLE); |
| } |
| |
| @Override |
| public void onPackagesSuspended(String[] packageNames, UserHandle user) { |
| onPackageStateUpdated(packageNames, CALLBACK_EVENT_PACKAGES_SUSPENDED); |
| super.onPackagesSuspended(packageNames, user); |
| } |
| |
| @Override |
| public void onPackagesUnsuspended(String[] packageNames, UserHandle user) { |
| onPackageStateUpdated(packageNames, CALLBACK_EVENT_PACKAGES_UNSUSPENDED); |
| super.onPackagesUnsuspended(packageNames, user); |
| } |
| }; |
| |
| launcherApps.registerCallback(launcherAppsCallback); |
| |
| mainHandler.postDelayed(() -> { |
| result.putStringArray(EXTRA_PACKAGES, new String[]{}); |
| result.putInt(EXTRA_FLAGS, CALLBACK_EVENT_INVALID); |
| remoteCallback.sendResult(result); |
| |
| launcherApps.unregisterCallback(launcherAppsCallback); |
| finish(); |
| }, token, timeoutMs); |
| } |
| |
| private void sendGetInstalledPackages(RemoteCallback remoteCallback, int flags) { |
| String[] packages = |
| getPackageManager().getInstalledPackages(flags) |
| .stream().map(p -> p.packageName).distinct().toArray(String[]::new); |
| Bundle result = new Bundle(); |
| result.putStringArray(EXTRA_RETURN_RESULT, packages); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendQueryIntentActivities(RemoteCallback remoteCallback, Intent queryIntent) { |
| final String[] resolveInfos = getPackageManager().queryIntentActivities( |
| queryIntent, 0 /* flags */).stream() |
| .map(ri -> ri.activityInfo.applicationInfo.packageName) |
| .distinct() |
| .toArray(String[]::new); |
| Bundle result = new Bundle(); |
| result.putStringArray(EXTRA_RETURN_RESULT, resolveInfos); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendQueryIntentServices(RemoteCallback remoteCallback, Intent queryIntent) { |
| final String[] resolveInfos = getPackageManager().queryIntentServices( |
| queryIntent, 0 /* flags */).stream() |
| .map(ri -> ri.serviceInfo.applicationInfo.packageName) |
| .distinct() |
| .toArray(String[]::new); |
| Bundle result = new Bundle(); |
| result.putStringArray(EXTRA_RETURN_RESULT, resolveInfos); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendQueryIntentProviders(RemoteCallback remoteCallback, Intent queryIntent) { |
| final String[] resolveInfos = getPackageManager().queryIntentContentProviders( |
| queryIntent, 0 /* flags */).stream() |
| .map(ri -> ri.providerInfo.applicationInfo.packageName) |
| .distinct() |
| .toArray(String[]::new); |
| Bundle result = new Bundle(); |
| result.putStringArray(EXTRA_RETURN_RESULT, resolveInfos); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void queryResolverForVisiblePackages(RemoteCallback remoteCallback, String authority) { |
| backgroundHandler.post(() -> { |
| Uri queryUri = Uri.parse("content://" + authority + "/test"); |
| Cursor query = getContentResolver().query(queryUri, null, null, null, null); |
| if (query == null || !query.moveToFirst()) { |
| sendError(remoteCallback, |
| new IllegalStateException( |
| "Query of " + queryUri + " could not be completed")); |
| return; |
| } |
| ArrayList<String> visiblePackages = new ArrayList<>(); |
| while (!query.isAfterLast()) { |
| visiblePackages.add(query.getString(0)); |
| query.moveToNext(); |
| } |
| query.close(); |
| |
| mainHandler.post(() -> { |
| Bundle result = new Bundle(); |
| result.putStringArray(EXTRA_RETURN_RESULT, visiblePackages.toArray(new String[]{})); |
| remoteCallback.sendResult(result); |
| finish(); |
| }); |
| |
| }); |
| } |
| |
| private void sendError(RemoteCallback remoteCallback, Exception failure) { |
| Bundle result = new Bundle(); |
| result.putSerializable(EXTRA_ERROR, failure); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendPackageInfo(RemoteCallback remoteCallback, String packageName) { |
| final PackageInfo pi; |
| try { |
| pi = getPackageManager().getPackageInfo(packageName, 0); |
| } catch (PackageManager.NameNotFoundException e) { |
| sendError(remoteCallback, e); |
| return; |
| } |
| Bundle result = new Bundle(); |
| result.putParcelable(EXTRA_RETURN_RESULT, pi); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendPackagesForUid(RemoteCallback remoteCallback, int uid) { |
| final String[] packages = getPackageManager().getPackagesForUid(uid); |
| final Bundle result = new Bundle(); |
| result.putStringArray(EXTRA_RETURN_RESULT, packages); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendNameForUid(RemoteCallback remoteCallback, int uid) { |
| final String name = getPackageManager().getNameForUid(uid); |
| final Bundle result = new Bundle(); |
| result.putString(EXTRA_RETURN_RESULT, name); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendNamesForUids(RemoteCallback remoteCallback, int uid) { |
| final String[] names = getPackageManager().getNamesForUids(new int[]{uid}); |
| final Bundle result = new Bundle(); |
| result.putStringArray(EXTRA_RETURN_RESULT, names); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendCheckSignatures(RemoteCallback remoteCallback, int uid1, int uid2) { |
| final int signatureResult = getPackageManager().checkSignatures(uid1, uid2); |
| final Bundle result = new Bundle(); |
| result.putInt(EXTRA_RETURN_RESULT, signatureResult); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendHasSigningCertificate(RemoteCallback remoteCallback, int uid, byte[] cert, |
| int type) { |
| final boolean signatureResult = getPackageManager().hasSigningCertificate(uid, cert, type); |
| final Bundle result = new Bundle(); |
| result.putBoolean(EXTRA_RETURN_RESULT, signatureResult); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| /** |
| * Instead of sending a list of package names, this function sends a List of |
| * {@link SyncAdapterType}, since the {@link SyncAdapterType#getPackageName()} is a test api |
| * which can only be invoked in the instrumentation. |
| */ |
| private void sendSyncAdapterTypes(RemoteCallback remoteCallback) { |
| final SyncAdapterType[] types = ContentResolver.getSyncAdapterTypes(); |
| final ArrayList<Parcelable> parcelables = new ArrayList<>(); |
| for (SyncAdapterType type : types) { |
| parcelables.add(type); |
| } |
| final Bundle result = new Bundle(); |
| result.putParcelableArrayList(EXTRA_RETURN_RESULT, parcelables); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendIsActivityEnabled(RemoteCallback remoteCallback, ComponentName componentName) { |
| final LauncherApps launcherApps = getSystemService(LauncherApps.class); |
| final Bundle result = new Bundle(); |
| try { |
| result.putBoolean(EXTRA_RETURN_RESULT, launcherApps.isActivityEnabled(componentName, |
| Process.myUserHandle())); |
| } catch (IllegalArgumentException e) { |
| } |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendInstalledAppWidgetProviders(RemoteCallback remoteCallback) { |
| final AppWidgetManager appWidgetManager = getSystemService(AppWidgetManager.class); |
| final List<AppWidgetProviderInfo> providers = appWidgetManager.getInstalledProviders(); |
| final ArrayList<Parcelable> parcelables = new ArrayList<>(); |
| for (AppWidgetProviderInfo info : providers) { |
| parcelables.add(info); |
| } |
| final Bundle result = new Bundle(); |
| result.putParcelableArrayList(EXTRA_RETURN_RESULT, parcelables); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendSyncAdapterPackagesForAuthorityAsUser(RemoteCallback remoteCallback, |
| String authority, int userId) { |
| final String[] syncAdapterPackages = ContentResolver |
| .getSyncAdapterPackagesForAuthorityAsUser(authority, userId); |
| final Bundle result = new Bundle(); |
| result.putStringArray(Intent.EXTRA_PACKAGES, syncAdapterPackages); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendGetSharedLibraryDependentPackages(RemoteCallback remoteCallback, |
| String sharedLibName) { |
| final List<SharedLibraryInfo> sharedLibraryInfos = getPackageManager() |
| .getSharedLibraries(0 /* flags */); |
| SharedLibraryInfo sharedLibraryInfo = sharedLibraryInfos.stream().filter( |
| info -> sharedLibName.equals(info.getName())).findAny().orElse(null); |
| final String[] dependentPackages = sharedLibraryInfo == null ? null |
| : sharedLibraryInfo.getDependentPackages().stream() |
| .map(versionedPackage -> versionedPackage.getPackageName()) |
| .distinct().collect(Collectors.toList()).toArray(new String[]{}); |
| final Bundle result = new Bundle(); |
| result.putStringArray(Intent.EXTRA_PACKAGES, dependentPackages); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendGetPreferredActivities(RemoteCallback remoteCallback) { |
| final List<IntentFilter> filters = new ArrayList<>(); |
| final List<ComponentName> activities = new ArrayList<>(); |
| getPackageManager().getPreferredActivities(filters, activities, null /* packageName*/); |
| final String[] packages = activities.stream() |
| .map(componentName -> componentName.getPackageName()).distinct() |
| .collect(Collectors.toList()).toArray(new String[]{}); |
| final Bundle result = new Bundle(); |
| result.putStringArray(Intent.EXTRA_PACKAGES, packages); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void sendSetInstallerPackageName(RemoteCallback remoteCallback, |
| String targetPackageName, String installerPackageName) { |
| try { |
| getPackageManager().setInstallerPackageName(targetPackageName, installerPackageName); |
| remoteCallback.sendResult(null); |
| finish(); |
| } catch (Exception e) { |
| sendError(remoteCallback, e); |
| } |
| } |
| |
| @Override |
| protected void onActivityResult(int requestCode, int resultCode, Intent data) { |
| super.onActivityResult(requestCode, resultCode, data); |
| final RemoteCallback remoteCallback = callbacks.get(requestCode); |
| if (resultCode != RESULT_OK) { |
| Exception e = (Exception) data.getSerializableExtra(EXTRA_ERROR); |
| sendError(remoteCallback, e == null ? new Exception("Result was " + resultCode) : e); |
| return; |
| } |
| final Bundle result = new Bundle(); |
| result.putParcelable(EXTRA_RETURN_RESULT, data.getParcelableExtra(EXTRA_RETURN_RESULT)); |
| remoteCallback.sendResult(result); |
| finish(); |
| } |
| |
| private void bindService(RemoteCallback remoteCallback, String packageName) { |
| final String SERVICE_NAME = "android.appenumeration.testapp.DummyService"; |
| final Intent intent = new Intent(); |
| intent.setClassName(packageName, SERVICE_NAME); |
| final ServiceConnection serviceConnection = new ServiceConnection() { |
| @Override |
| public void onServiceConnected(ComponentName className, IBinder service) { |
| // No-op |
| } |
| |
| @Override |
| public void onServiceDisconnected(ComponentName className) { |
| // No-op |
| } |
| |
| @Override |
| public void onBindingDied(ComponentName name) { |
| // Remote service die |
| finish(); |
| } |
| |
| @Override |
| public void onNullBinding(ComponentName name) { |
| // Since the DummyService doesn't implement onBind, it returns null and |
| // onNullBinding would be called. Use postDelayed to keep this service |
| // connection alive for 3 seconds. |
| mainHandler.postDelayed(() -> { |
| unbindService(this); |
| finish(); |
| }, TIMEOUT_MS); |
| } |
| }; |
| |
| final boolean bound = bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE); |
| final Bundle result = new Bundle(); |
| result.putBoolean(EXTRA_RETURN_RESULT, bound); |
| remoteCallback.sendResult(result); |
| // Don't invoke finish() right here if service is bound successfully to keep the service |
| // connection alive since the ServiceRecord would be remove from the ServiceMap once no |
| // client is binding the service. |
| if (!bound) finish(); |
| } |
| } |
