diff --git a/core/java/android/app/backup/BackupAgent.java b/core/java/android/app/backup/BackupAgent.java index c983d4f687106..24580b40aa298 100644 --- a/core/java/android/app/backup/BackupAgent.java +++ b/core/java/android/app/backup/BackupAgent.java @@ -16,6 +16,7 @@ package android.app.backup; +import android.annotation.Nullable; import android.app.IBackupAgent; import android.app.QueuedWork; import android.app.backup.FullBackup.BackupScheme.PathWithRequiredFlags; @@ -181,6 +182,8 @@ public abstract class BackupAgent extends ContextWrapper { Handler mHandler = null; + @Nullable private UserHandle mUser; + Handler getHandler() { if (mHandler == null) { mHandler = new Handler(Looper.getMainLooper()); @@ -232,6 +235,8 @@ public abstract class BackupAgent extends ContextWrapper { */ public void onCreate(UserHandle user) { onCreate(); + + mUser = user; } /** @@ -528,6 +533,10 @@ public abstract class BackupAgent extends ContextWrapper { public void onQuotaExceeded(long backupDataBytes, long quotaBytes) { } + private int getBackupUserId() { + return mUser == null ? super.getUserId() : mUser.getIdentifier(); + } + /** * Check whether the xml yielded any tag for the provided domainToken. * If so, perform a {@link #fullBackupFileTree} which backs up the file or recurses if the path @@ -1033,7 +1042,7 @@ public abstract class BackupAgent extends ContextWrapper { Binder.restoreCallingIdentity(ident); try { - callbackBinder.opComplete(token, 0); + callbackBinder.opCompleteForUser(getBackupUserId(), token, 0); } catch (RemoteException e) { // we'll time out anyway, so we're safe } @@ -1082,7 +1091,7 @@ public abstract class BackupAgent extends ContextWrapper { Binder.restoreCallingIdentity(ident); try { - callbackBinder.opComplete(token, 0); + callbackBinder.opCompleteForUser(getBackupUserId(), token, 0); } catch (RemoteException e) { // we'll time out anyway, so we're safe } @@ -1112,7 +1121,8 @@ public abstract class BackupAgent extends ContextWrapper { } finally { Binder.restoreCallingIdentity(ident); try { - callbackBinder.opComplete(token, measureOutput.getSize()); + callbackBinder.opCompleteForUser(getBackupUserId(), token, + measureOutput.getSize()); } catch (RemoteException e) { // timeout, so we're safe } @@ -1137,7 +1147,7 @@ public abstract class BackupAgent extends ContextWrapper { Binder.restoreCallingIdentity(ident); try { - callbackBinder.opComplete(token, 0); + callbackBinder.opCompleteForUser(getBackupUserId(), token, 0); } catch (RemoteException e) { // we'll time out anyway, so we're safe } @@ -1162,7 +1172,7 @@ public abstract class BackupAgent extends ContextWrapper { Binder.restoreCallingIdentity(ident); try { - callbackBinder.opComplete(token, 0); + callbackBinder.opCompleteForUser(getBackupUserId(), token, 0); } catch (RemoteException e) { // we'll time out anyway, so we're safe } diff --git a/core/java/android/app/backup/IBackupManager.aidl b/core/java/android/app/backup/IBackupManager.aidl index f8c5a815a32e6..eda8981d7e0e5 100644 --- a/core/java/android/app/backup/IBackupManager.aidl +++ b/core/java/android/app/backup/IBackupManager.aidl @@ -547,6 +547,19 @@ interface IBackupManager { */ IRestoreSession beginRestoreSessionForUser(int userId, String packageName, String transportID); + /** + * Notify the backup manager that a BackupAgent has completed the operation + * corresponding to the given token and user id. + * + * @param userId User id for which the operation has been completed. + * @param token The transaction token passed to the BackupAgent method being + * invoked. + * @param result In the case of a full backup measure operation, the estimated + * total file size that would result from the operation. Unused in all other + * cases. + */ + void opCompleteForUser(int userId, int token, long result); + /** * Notify the backup manager that a BackupAgent has completed the operation * corresponding to the given token. diff --git a/services/backup/java/com/android/server/backup/PackageManagerBackupAgent.java b/services/backup/java/com/android/server/backup/PackageManagerBackupAgent.java index 4a1e5b9910bf5..2241569afe180 100644 --- a/services/backup/java/com/android/server/backup/PackageManagerBackupAgent.java +++ b/services/backup/java/com/android/server/backup/PackageManagerBackupAgent.java @@ -164,7 +164,7 @@ public class PackageManagerBackupAgent extends BackupAgent { int N = pkgs.size(); for (int a = N-1; a >= 0; a--) { PackageInfo pkg = pkgs.get(a); - if (!AppBackupUtils.appIsEligibleForBackup(pkg.applicationInfo, pm)) { + if (!AppBackupUtils.appIsEligibleForBackup(pkg.applicationInfo, userId)) { pkgs.remove(a); } } diff --git a/services/backup/java/com/android/server/backup/Trampoline.java b/services/backup/java/com/android/server/backup/Trampoline.java index b9a6f3c08cc49..4f58d7920d740 100644 --- a/services/backup/java/com/android/server/backup/Trampoline.java +++ b/services/backup/java/com/android/server/backup/Trampoline.java @@ -636,13 +636,17 @@ public class Trampoline extends IBackupManager.Stub { } @Override - public void opComplete(int token, long result) throws RemoteException { - int userId = binderGetCallingUserId(); + public void opCompleteForUser(int userId, int token, long result) throws RemoteException { if (isUserReadyForBackup(userId)) { - mService.opComplete(binderGetCallingUserId(), token, result); + mService.opComplete(userId, token, result); } } + @Override + public void opComplete(int token, long result) throws RemoteException { + opCompleteForUser(binderGetCallingUserId(), token, result); + } + @Override public long getAvailableRestoreTokenForUser(int userId, String packageName) { return isUserReadyForBackup(userId) ? mService.getAvailableRestoreToken(userId, diff --git a/services/backup/java/com/android/server/backup/UserBackupManagerService.java b/services/backup/java/com/android/server/backup/UserBackupManagerService.java index 79f8a7e4e9ae3..115e9240c6fe2 100644 --- a/services/backup/java/com/android/server/backup/UserBackupManagerService.java +++ b/services/backup/java/com/android/server/backup/UserBackupManagerService.java @@ -804,7 +804,7 @@ public class UserBackupManagerService { public BackupAgent makeMetadataAgent() { PackageManagerBackupAgent pmAgent = new PackageManagerBackupAgent(mPackageManager, mUserId); pmAgent.attach(mContext); - pmAgent.onCreate(); + pmAgent.onCreate(UserHandle.of(mUserId)); return pmAgent; } @@ -815,7 +815,7 @@ public class UserBackupManagerService { PackageManagerBackupAgent pmAgent = new PackageManagerBackupAgent(mPackageManager, packages, mUserId); pmAgent.attach(mContext); - pmAgent.onCreate(); + pmAgent.onCreate(UserHandle.of(mUserId)); return pmAgent; } @@ -910,10 +910,10 @@ public class UserBackupManagerService { long lastBackup = in.readLong(); foundApps.add(pkgName); // all apps that we've addressed already try { - PackageInfo pkg = mPackageManager.getPackageInfo(pkgName, 0); + PackageInfo pkg = mPackageManager.getPackageInfoAsUser(pkgName, 0, mUserId); if (AppBackupUtils.appGetsFullBackup(pkg) - && AppBackupUtils.appIsEligibleForBackup( - pkg.applicationInfo, mPackageManager)) { + && AppBackupUtils.appIsEligibleForBackup(pkg.applicationInfo, + mUserId)) { schedule.add(new FullBackupEntry(pkgName, lastBackup)); } else { if (DEBUG) { @@ -933,8 +933,8 @@ public class UserBackupManagerService { // scan to make sure that we're tracking all full-backup candidates properly for (PackageInfo app : apps) { if (AppBackupUtils.appGetsFullBackup(app) - && AppBackupUtils.appIsEligibleForBackup( - app.applicationInfo, mPackageManager)) { + && AppBackupUtils.appIsEligibleForBackup(app.applicationInfo, + mUserId)) { if (!foundApps.contains(app.packageName)) { if (MORE_DEBUG) { Slog.i(TAG, "New full backup app " + app.packageName + " found"); @@ -960,7 +960,7 @@ public class UserBackupManagerService { schedule = new ArrayList<>(apps.size()); for (PackageInfo info : apps) { if (AppBackupUtils.appGetsFullBackup(info) && AppBackupUtils.appIsEligibleForBackup( - info.applicationInfo, mPackageManager)) { + info.applicationInfo, mUserId)) { schedule.add(new FullBackupEntry(info.packageName, 0)); } } @@ -1222,8 +1222,8 @@ public class UserBackupManagerService { mPackageManager.getPackageInfoAsUser( packageName, /* flags */ 0, mUserId); if (AppBackupUtils.appGetsFullBackup(app) - && AppBackupUtils.appIsEligibleForBackup( - app.applicationInfo, mPackageManager)) { + && AppBackupUtils.appIsEligibleForBackup(app.applicationInfo, + mUserId)) { enqueueFullBackup(packageName, now); scheduleNextFullBackupJob(0); } else { @@ -1618,8 +1618,7 @@ public class UserBackupManagerService { try { PackageInfo packageInfo = mPackageManager.getPackageInfoAsUser(packageName, PackageManager.GET_SIGNING_CERTIFICATES, mUserId); - if (!AppBackupUtils.appIsEligibleForBackup(packageInfo.applicationInfo, - mPackageManager)) { + if (!AppBackupUtils.appIsEligibleForBackup(packageInfo.applicationInfo, mUserId)) { BackupObserverUtils.sendBackupOnPackageResult(observer, packageName, BackupManager.ERROR_BACKUP_NOT_ALLOWED); continue; @@ -2095,7 +2094,8 @@ public class UserBackupManagerService { } try { - PackageInfo appInfo = mPackageManager.getPackageInfo(entry.packageName, 0); + PackageInfo appInfo = mPackageManager.getPackageInfoAsUser( + entry.packageName, 0, mUserId); if (!AppBackupUtils.appGetsFullBackup(appInfo)) { // The head app isn't supposed to get full-data backups [any more]; // so we cull it and force a loop around to consider the new head diff --git a/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java b/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java index 31786d749f0ad..0a7159bfe1b78 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java +++ b/services/backup/java/com/android/server/backup/fullbackup/PerformAdbBackupTask.java @@ -286,7 +286,8 @@ public class PerformAdbBackupTask extends FullBackupTask implements BackupRestor Iterator> iter = packagesToBackup.entrySet().iterator(); while (iter.hasNext()) { PackageInfo pkg = iter.next().getValue(); - if (!AppBackupUtils.appIsEligibleForBackup(pkg.applicationInfo, pm) + if (!AppBackupUtils.appIsEligibleForBackup(pkg.applicationInfo, + mUserBackupManagerService.getUserId()) || AppBackupUtils.appIsStopped(pkg.applicationInfo)) { iter.remove(); if (DEBUG) { diff --git a/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java b/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java index 0fb4f93e542b7..86e679f16f662 100644 --- a/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java +++ b/services/backup/java/com/android/server/backup/fullbackup/PerformFullTransportBackupTask.java @@ -143,6 +143,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba private final int mBackupRunnerOpToken; private final OnTaskFinishedListener mListener; private final TransportClient mTransportClient; + private final int mUserId; // This is true when a backup operation for some package is in progress. private volatile boolean mIsDoingBackup; @@ -173,6 +174,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba mAgentTimeoutParameters = Preconditions.checkNotNull( backupManagerService.getAgentTimeoutParameters(), "Timeout parameters cannot be null"); + mUserId = backupManagerService.getUserId(); if (backupManagerService.isBackupOperationInProgress()) { if (DEBUG) { @@ -187,9 +189,10 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba for (String pkg : whichPackages) { try { PackageManager pm = backupManagerService.getPackageManager(); - PackageInfo info = pm.getPackageInfo(pkg, PackageManager.GET_SIGNING_CERTIFICATES); + PackageInfo info = pm.getPackageInfoAsUser(pkg, + PackageManager.GET_SIGNING_CERTIFICATES, mUserId); mCurrentPackage = info; - if (!AppBackupUtils.appIsEligibleForBackup(info.applicationInfo, pm)) { + if (!AppBackupUtils.appIsEligibleForBackup(info.applicationInfo, mUserId)) { // Cull any packages that have indicated that backups are not permitted, // that run as system-domain uids but do not define their own backup agents, // as well as any explicit mention of the 'special' shared-storage agent @@ -633,7 +636,7 @@ public class PerformFullTransportBackupTask extends FullBackupTask implements Ba unregisterTask(); if (mJob != null) { - mJob.finishBackupPass(backupManagerService.getUserId()); + mJob.finishBackupPass(mUserId); } synchronized (backupManagerService.getQueueLock()) { diff --git a/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java b/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java index cfc129e11c6ea..294eb0128b2cf 100644 --- a/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java +++ b/services/backup/java/com/android/server/backup/keyvalue/KeyValueBackupTask.java @@ -489,7 +489,7 @@ public class KeyValueBackupTask implements BackupRestoreTask, Runnable { throw AgentException.permanent(e); } ApplicationInfo applicationInfo = packageInfo.applicationInfo; - if (!AppBackupUtils.appIsEligibleForBackup(applicationInfo, mPackageManager)) { + if (!AppBackupUtils.appIsEligibleForBackup(applicationInfo, mUserId)) { mReporter.onPackageNotEligibleForBackup(packageName); throw AgentException.permanent(); } diff --git a/services/backup/java/com/android/server/backup/restore/FullRestoreEngine.java b/services/backup/java/com/android/server/backup/restore/FullRestoreEngine.java index b3d9fbcb88d33..c5389fa5f8784 100644 --- a/services/backup/java/com/android/server/backup/restore/FullRestoreEngine.java +++ b/services/backup/java/com/android/server/backup/restore/FullRestoreEngine.java @@ -230,7 +230,7 @@ public class FullRestoreEngine extends RestoreEngine { PackageManagerInternal.class); RestorePolicy restorePolicy = tarBackupReader.chooseRestorePolicy( mBackupManagerService.getPackageManager(), allowApks, info, signatures, - pmi); + pmi, mUserId); mManifestSignatures.put(info.packageName, signatures); mPackagePolicies.put(pkg, restorePolicy); mPackageInstallers.put(pkg, info.installerPackageName); @@ -332,8 +332,9 @@ public class FullRestoreEngine extends RestoreEngine { } try { - mTargetApp = mBackupManagerService.getPackageManager() - .getApplicationInfoAsUser(pkg, 0, mUserId); + mTargetApp = + mBackupManagerService.getPackageManager() + .getApplicationInfoAsUser(pkg, 0, mUserId); // If we haven't sent any data to this app yet, we probably // need to clear it first. Check that. diff --git a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java index d01f77bfd84cd..7763d7b9adc01 100644 --- a/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java +++ b/services/backup/java/com/android/server/backup/restore/PerformUnifiedRestoreTask.java @@ -232,7 +232,7 @@ public class PerformUnifiedRestoreTask implements BackupRestoreTask { continue; } - if (AppBackupUtils.appIsEligibleForBackup(info.applicationInfo, pm)) { + if (AppBackupUtils.appIsEligibleForBackup(info.applicationInfo, mUserId)) { mAcceptSet.add(info); } } catch (NameNotFoundException e) { diff --git a/services/backup/java/com/android/server/backup/utils/AppBackupUtils.java b/services/backup/java/com/android/server/backup/utils/AppBackupUtils.java index 054879b077ad8..2db89289e4fc0 100644 --- a/services/backup/java/com/android/server/backup/utils/AppBackupUtils.java +++ b/services/backup/java/com/android/server/backup/utils/AppBackupUtils.java @@ -18,19 +18,25 @@ package com.android.server.backup.utils; import static com.android.server.backup.BackupManagerService.MORE_DEBUG; import static com.android.server.backup.BackupManagerService.TAG; +import static com.android.server.backup.UserBackupManagerService.PACKAGE_MANAGER_SENTINEL; import static com.android.server.backup.UserBackupManagerService.SHARED_BACKUP_AGENT_PACKAGE; import android.annotation.Nullable; +import android.app.AppGlobals; import android.app.backup.BackupTransport; import android.content.pm.ApplicationInfo; +import android.content.pm.IPackageManager; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; import android.content.pm.PackageManagerInternal; import android.content.pm.Signature; import android.content.pm.SigningInfo; import android.os.Process; +import android.os.RemoteException; +import android.os.UserHandle; import android.util.Slog; +import com.android.internal.annotations.VisibleForTesting; import com.android.internal.backup.IBackupTransport; import com.android.internal.util.ArrayUtils; import com.android.server.backup.transport.TransportClient; @@ -39,7 +45,6 @@ import com.android.server.backup.transport.TransportClient; * Utility methods wrapping operations on ApplicationInfo and PackageInfo. */ public class AppBackupUtils { - private static final boolean DEBUG = false; /** @@ -54,15 +59,30 @@ public class AppBackupUtils { *
  • it is the special shared-storage backup package used for 'adb backup' * */ - public static boolean appIsEligibleForBackup(ApplicationInfo app, PackageManager pm) { + public static boolean appIsEligibleForBackup(ApplicationInfo app, int userId) { + return appIsEligibleForBackup(app, AppGlobals.getPackageManager(), userId); + } + + @VisibleForTesting + static boolean appIsEligibleForBackup(ApplicationInfo app, + IPackageManager packageManager, int userId) { // 1. their manifest states android:allowBackup="false" if ((app.flags & ApplicationInfo.FLAG_ALLOW_BACKUP) == 0) { return false; } - // 2. they run as a system-level uid but do not supply their own backup agent - if ((app.uid < Process.FIRST_APPLICATION_UID) && (app.backupAgentName == null)) { - return false; + // 2. they run as a system-level uid + if ((app.uid < Process.FIRST_APPLICATION_UID)) { + // and the backup is happening for non-system user + if (userId != UserHandle.USER_SYSTEM && !app.packageName.equals( + PACKAGE_MANAGER_SENTINEL)) { + return false; + } + + // or do not supply their own backup agent + if (app.backupAgentName == null) { + return false; + } } // 3. it is the special shared-storage backup package used for 'adb backup' @@ -75,9 +95,7 @@ public class AppBackupUtils { return false; } - // Everything else checks out; the only remaining roadblock would be if the - // package were disabled - return !appIsDisabled(app, pm); + return !appIsDisabled(app, packageManager, userId); } /** @@ -99,9 +117,9 @@ public class AppBackupUtils { PackageInfo packageInfo = pm.getPackageInfoAsUser(packageName, PackageManager.GET_SIGNING_CERTIFICATES, userId); ApplicationInfo applicationInfo = packageInfo.applicationInfo; - if (!appIsEligibleForBackup(applicationInfo, pm) + if (!appIsEligibleForBackup(applicationInfo, userId) || appIsStopped(applicationInfo) - || appIsDisabled(applicationInfo, pm)) { + || appIsDisabled(applicationInfo, userId)) { return false; } if (transportClient != null) { @@ -123,8 +141,22 @@ public class AppBackupUtils { } /** Avoid backups of 'disabled' apps. */ - public static boolean appIsDisabled(ApplicationInfo app, PackageManager pm) { - switch (pm.getApplicationEnabledSetting(app.packageName)) { + static boolean appIsDisabled(ApplicationInfo app, int userId) { + return appIsDisabled(app, AppGlobals.getPackageManager(), userId); + } + + @VisibleForTesting + static boolean appIsDisabled(ApplicationInfo app, + IPackageManager packageManager, int userId) { + int enabledSetting; + try { + enabledSetting = packageManager.getApplicationEnabledSetting(app.packageName, userId); + } catch (RemoteException e) { + Slog.e(TAG, "Failed to get application enabled setting: " + e); + return false; + } + + switch (enabledSetting) { case PackageManager.COMPONENT_ENABLED_STATE_DISABLED: case PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER: case PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED: diff --git a/services/backup/java/com/android/server/backup/utils/TarBackupReader.java b/services/backup/java/com/android/server/backup/utils/TarBackupReader.java index 0f4b6810f15b9..f4b235a3f3e11 100644 --- a/services/backup/java/com/android/server/backup/utils/TarBackupReader.java +++ b/services/backup/java/com/android/server/backup/utils/TarBackupReader.java @@ -383,11 +383,12 @@ public class TarBackupReader { * @param allowApks - allow restore set to include apks. * @param info - file metadata. * @param signatures - array of signatures parsed from backup file. + * @param userId - ID of the user for which restore is performed. * @return a restore policy constant. */ public RestorePolicy chooseRestorePolicy(PackageManager packageManager, boolean allowApks, FileMetadata info, Signature[] signatures, - PackageManagerInternal pmi) { + PackageManagerInternal pmi, int userId) { if (signatures == null) { return RestorePolicy.IGNORE; } @@ -396,8 +397,8 @@ public class TarBackupReader { // Okay, got the manifest info we need... try { - PackageInfo pkgInfo = packageManager.getPackageInfo( - info.packageName, PackageManager.GET_SIGNING_CERTIFICATES); + PackageInfo pkgInfo = packageManager.getPackageInfoAsUser( + info.packageName, PackageManager.GET_SIGNING_CERTIFICATES, userId); // Fall through to IGNORE if the app explicitly disallows backup final int flags = pkgInfo.applicationInfo.flags; if ((flags & ApplicationInfo.FLAG_ALLOW_BACKUP) != 0) { diff --git a/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java b/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java index 4811523b22f98..164570a84cb03 100644 --- a/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java +++ b/services/robotests/backup/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java @@ -116,6 +116,7 @@ import com.android.server.backup.testing.TransportTestUtils; import com.android.server.backup.testing.TransportTestUtils.TransportMock; import com.android.server.testing.shadows.FrameworkShadowLooper; import com.android.server.testing.shadows.ShadowApplicationPackageManager; +import com.android.server.testing.shadows.ShadowBackupActivityThread; import com.android.server.testing.shadows.ShadowBackupDataInput; import com.android.server.testing.shadows.ShadowBackupDataOutput; import com.android.server.testing.shadows.ShadowEventLog; @@ -163,6 +164,7 @@ import java.util.stream.Stream; ShadowBackupDataOutput.class, ShadowEventLog.class, ShadowQueuedWork.class, + ShadowBackupActivityThread.class, }) @Presubmit public class KeyValueBackupTaskTest { diff --git a/services/robotests/src/com/android/server/testing/shadows/ShadowAppBackupUtils.java b/services/robotests/src/com/android/server/testing/shadows/ShadowAppBackupUtils.java index aefc871d26396..33b8aa73d2938 100644 --- a/services/robotests/src/com/android/server/testing/shadows/ShadowAppBackupUtils.java +++ b/services/robotests/src/com/android/server/testing/shadows/ShadowAppBackupUtils.java @@ -62,7 +62,7 @@ public class ShadowAppBackupUtils { } @Implementation - protected static boolean appIsEligibleForBackup(ApplicationInfo app, PackageManager pm) { + protected static boolean appIsEligibleForBackup(ApplicationInfo app, int userId) { return sAppsEligibleForBackup.contains(app.packageName); } diff --git a/services/robotests/src/com/android/server/testing/shadows/ShadowBackupActivityThread.java b/services/robotests/src/com/android/server/testing/shadows/ShadowBackupActivityThread.java new file mode 100644 index 0000000000000..ca2e3b6dafef1 --- /dev/null +++ b/services/robotests/src/com/android/server/testing/shadows/ShadowBackupActivityThread.java @@ -0,0 +1,79 @@ +/* + * 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 com.android.server.testing.shadows; + +import android.app.ActivityThread; +import android.content.pm.ApplicationInfo; +import android.content.pm.IPackageManager; +import android.content.pm.PackageManager; +import android.os.RemoteException; + +import org.robolectric.RuntimeEnvironment; +import org.robolectric.annotation.Implementation; +import org.robolectric.annotation.Implements; +import org.robolectric.shadows.ShadowActivityThread; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; + +import javax.annotation.Nonnull; + +/** + * Extends the existing {@link ShadowActivityThread} to add support for + * {@link PackageManager#getApplicationEnabledSetting(String)} in the shadow {@link PackageManager} + * returned by {@link ShadowBackupActivityThread#getPackageManager()}. + */ +@Implements(value = ActivityThread.class, isInAndroidSdk = false, looseSignatures = true) +public class ShadowBackupActivityThread extends ShadowActivityThread { + @Implementation + public static Object getPackageManager() { + ClassLoader classLoader = ShadowActivityThread.class.getClassLoader(); + Class iPackageManagerClass; + try { + iPackageManagerClass = classLoader.loadClass("android.content.pm.IPackageManager"); + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + + return Proxy.newProxyInstance( + classLoader, + new Class[] {iPackageManagerClass}, + new InvocationHandler() { + @Override + public Object invoke(Object proxy, @Nonnull Method method, Object[] args) + throws Exception { + if (method.getName().equals("getApplicationInfo")) { + String packageName = (String) args[0]; + int flags = (Integer) args[1]; + + try { + return RuntimeEnvironment.application + .getPackageManager() + .getApplicationInfo(packageName, flags); + } catch (PackageManager.NameNotFoundException e) { + throw new RemoteException(e.getMessage()); + } + } else if (method.getName().equals("getApplicationEnabledSetting")) { + return 0; + } else { + return null; + } + } + }); + } +} diff --git a/services/tests/servicestests/src/com/android/server/backup/testutils/IPackageManagerStub.java b/services/tests/servicestests/src/com/android/server/backup/testutils/IPackageManagerStub.java new file mode 100644 index 0000000000000..095a1deac912b --- /dev/null +++ b/services/tests/servicestests/src/com/android/server/backup/testutils/IPackageManagerStub.java @@ -0,0 +1,1172 @@ +/* + * 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 com.android.server.backup.testutils; + +import android.content.ComponentName; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.IntentSender; +import android.content.pm.ActivityInfo; +import android.content.pm.ApplicationInfo; +import android.content.pm.ChangedPackages; +import android.content.pm.IDexModuleRegisterCallback; +import android.content.pm.IOnPermissionsChangeListener; +import android.content.pm.IPackageDataObserver; +import android.content.pm.IPackageDeleteObserver; +import android.content.pm.IPackageDeleteObserver2; +import android.content.pm.IPackageInstaller; +import android.content.pm.IPackageManager; +import android.content.pm.IPackageMoveObserver; +import android.content.pm.IPackageStatsObserver; +import android.content.pm.InstrumentationInfo; +import android.content.pm.KeySet; +import android.content.pm.ModuleInfo; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.content.pm.ParceledListSlice; +import android.content.pm.PermissionGroupInfo; +import android.content.pm.PermissionInfo; +import android.content.pm.ProviderInfo; +import android.content.pm.ResolveInfo; +import android.content.pm.ServiceInfo; +import android.content.pm.SuspendDialogInfo; +import android.content.pm.VerifierDeviceIdentity; +import android.content.pm.VersionedPackage; +import android.content.pm.dex.IArtManager; +import android.graphics.Bitmap; +import android.os.IBinder; +import android.os.PersistableBundle; +import android.os.RemoteException; +import java.util.List; + +/** + * Stub for IPackageManager to use in tests. + */ +public class IPackageManagerStub implements IPackageManager { + public static PackageInfo sPackageInfo; + public static int sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; + + @Override + public PackageInfo getPackageInfo(String packageName, int flags, int userId) + throws RemoteException { + return sPackageInfo; + } + + @Override + public int getApplicationEnabledSetting(String packageName, int userId) throws RemoteException { + return sApplicationEnabledSetting; + } + + @Override + public void checkPackageStartable(String packageName, int userId) throws RemoteException { + + } + + @Override + public boolean isPackageAvailable(String packageName, int userId) throws RemoteException { + return false; + } + + @Override + public PackageInfo getPackageInfoVersioned(VersionedPackage versionedPackage, int flags, + int userId) throws RemoteException { + return null; + } + + @Override + public int getPackageUid(String packageName, int flags, int userId) throws RemoteException { + return 0; + } + + @Override + public int[] getPackageGids(String packageName, int flags, int userId) throws RemoteException { + return new int[0]; + } + + @Override + public String[] currentToCanonicalPackageNames(String[] names) throws RemoteException { + return new String[0]; + } + + @Override + public String[] canonicalToCurrentPackageNames(String[] names) throws RemoteException { + return new String[0]; + } + + @Override + public PermissionInfo getPermissionInfo(String name, String packageName, int flags) + throws RemoteException { + return null; + } + + @Override + public ParceledListSlice queryPermissionsByGroup(String group, int flags) + throws RemoteException { + return null; + } + + @Override + public PermissionGroupInfo getPermissionGroupInfo(String name, int flags) + throws RemoteException { + return null; + } + + @Override + public ParceledListSlice getAllPermissionGroups(int flags) throws RemoteException { + return null; + } + + @Override + public ApplicationInfo getApplicationInfo(String packageName, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public ActivityInfo getActivityInfo(ComponentName className, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public boolean activitySupportsIntent(ComponentName className, Intent intent, + String resolvedType) + throws RemoteException { + return false; + } + + @Override + public ActivityInfo getReceiverInfo(ComponentName className, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public ServiceInfo getServiceInfo(ComponentName className, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public ProviderInfo getProviderInfo(ComponentName className, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public int checkPermission(String permName, String pkgName, int userId) throws RemoteException { + return 0; + } + + @Override + public int checkUidPermission(String permName, int uid) throws RemoteException { + return 0; + } + + @Override + public boolean addPermission(PermissionInfo info) throws RemoteException { + return false; + } + + @Override + public void removePermission(String name) throws RemoteException { + + } + + @Override + public void grantRuntimePermission(String packageName, String permissionName, int userId) + throws RemoteException { + + } + + @Override + public void revokeRuntimePermission(String packageName, String permissionName, int userId) + throws RemoteException { + + } + + @Override + public void resetRuntimePermissions() throws RemoteException { + + } + + @Override + public int getPermissionFlags(String permissionName, String packageName, int userId) + throws RemoteException { + return 0; + } + + @Override + public void updatePermissionFlags(String permissionName, String packageName, int flagMask, + int flagValues, int userId) throws RemoteException { + + } + + @Override + public void updatePermissionFlagsForAllApps(int flagMask, int flagValues, int userId) + throws RemoteException { + + } + + @Override + public boolean shouldShowRequestPermissionRationale(String permissionName, String packageName, + int userId) throws RemoteException { + return false; + } + + @Override + public boolean isProtectedBroadcast(String actionName) throws RemoteException { + return false; + } + + @Override + public int checkSignatures(String pkg1, String pkg2) throws RemoteException { + return 0; + } + + @Override + public int checkUidSignatures(int uid1, int uid2) throws RemoteException { + return 0; + } + + @Override + public List getAllPackages() throws RemoteException { + return null; + } + + @Override + public String[] getPackagesForUid(int uid) throws RemoteException { + return new String[0]; + } + + @Override + public String getNameForUid(int uid) throws RemoteException { + return null; + } + + @Override + public String[] getNamesForUids(int[] uids) throws RemoteException { + return new String[0]; + } + + @Override + public int getUidForSharedUser(String sharedUserName) throws RemoteException { + return 0; + } + + @Override + public int getFlagsForUid(int uid) throws RemoteException { + return 0; + } + + @Override + public int getPrivateFlagsForUid(int uid) throws RemoteException { + return 0; + } + + @Override + public boolean isUidPrivileged(int uid) throws RemoteException { + return false; + } + + @Override + public String[] getAppOpPermissionPackages(String permissionName) throws RemoteException { + return new String[0]; + } + + @Override + public ResolveInfo resolveIntent(Intent intent, String resolvedType, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public ResolveInfo findPersistentPreferredActivity(Intent intent, int userId) + throws RemoteException { + return null; + } + + @Override + public boolean canForwardTo(Intent intent, String resolvedType, int sourceUserId, + int targetUserId) throws RemoteException { + return false; + } + + @Override + public ParceledListSlice queryIntentActivities(Intent intent, String resolvedType, int flags, + int userId) throws RemoteException { + return null; + } + + @Override + public ParceledListSlice queryIntentActivityOptions(ComponentName caller, Intent[] specifics, + String[] specificTypes, Intent intent, String resolvedType, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public ParceledListSlice queryIntentReceivers(Intent intent, String resolvedType, int flags, + int userId) throws RemoteException { + return null; + } + + @Override + public ResolveInfo resolveService(Intent intent, String resolvedType, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public ParceledListSlice queryIntentServices(Intent intent, String resolvedType, int flags, + int userId) throws RemoteException { + return null; + } + + @Override + public ParceledListSlice queryIntentContentProviders(Intent intent, String resolvedType, + int flags, int userId) throws RemoteException { + return null; + } + + @Override + public ParceledListSlice getInstalledPackages(int flags, int userId) throws RemoteException { + return null; + } + + @Override + public ParceledListSlice getPackagesHoldingPermissions(String[] permissions, int flags, + int userId) throws RemoteException { + return null; + } + + @Override + public ParceledListSlice getInstalledApplications(int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public ParceledListSlice getPersistentApplications(int flags) throws RemoteException { + return null; + } + + @Override + public ProviderInfo resolveContentProvider(String name, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public void querySyncProviders(List outNames, List outInfo) + throws RemoteException { + + } + + @Override + public ParceledListSlice queryContentProviders(String processName, int uid, int flags, + String metaDataKey) throws RemoteException { + return null; + } + + @Override + public InstrumentationInfo getInstrumentationInfo(ComponentName className, int flags) + throws RemoteException { + return null; + } + + @Override + public ParceledListSlice queryInstrumentation(String targetPackage, int flags) + throws RemoteException { + return null; + } + + @Override + public void finishPackageInstall(int token, boolean didLaunch) throws RemoteException { + + } + + @Override + public void setInstallerPackageName(String targetPackage, String installerPackageName) + throws RemoteException { + + } + + @Override + public void setApplicationCategoryHint(String packageName, int categoryHint, + String callerPackageName) throws RemoteException { + + } + + @Override + public void deletePackageAsUser(String packageName, int versionCode, + IPackageDeleteObserver observer, int userId, int flags) throws RemoteException { + + } + + @Override + public void deletePackageVersioned(VersionedPackage versionedPackage, + IPackageDeleteObserver2 observer, int userId, int flags) throws RemoteException { + + } + + @Override + public String getInstallerPackageName(String packageName) throws RemoteException { + return null; + } + + @Override + public void resetApplicationPreferences(int userId) throws RemoteException { + + } + + @Override + public ResolveInfo getLastChosenActivity(Intent intent, String resolvedType, int flags) + throws RemoteException { + return null; + } + + @Override + public void setLastChosenActivity(Intent intent, String resolvedType, int flags, + IntentFilter filter, int match, ComponentName activity) throws RemoteException { + + } + + @Override + public void addPreferredActivity(IntentFilter filter, int match, ComponentName[] set, + ComponentName activity, int userId) throws RemoteException { + + } + + @Override + public void replacePreferredActivity(IntentFilter filter, int match, ComponentName[] set, + ComponentName activity, int userId) throws RemoteException { + + } + + @Override + public void clearPackagePreferredActivities(String packageName) throws RemoteException { + + } + + @Override + public int getPreferredActivities(List outFilters, + List outActivities, String packageName) throws RemoteException { + return 0; + } + + @Override + public void addPersistentPreferredActivity(IntentFilter filter, ComponentName activity, + int userId) throws RemoteException { + + } + + @Override + public void clearPackagePersistentPreferredActivities(String packageName, int userId) + throws RemoteException { + + } + + @Override + public void addCrossProfileIntentFilter(IntentFilter intentFilter, String ownerPackage, + int sourceUserId, int targetUserId, int flags) throws RemoteException { + + } + + @Override + public void clearCrossProfileIntentFilters(int sourceUserId, String ownerPackage) + throws RemoteException { + + } + + @Override + public String[] setDistractingPackageRestrictionsAsUser(String[] packageNames, + int restrictionFlags, int userId) throws RemoteException { + return new String[0]; + } + + @Override + public String[] setPackagesSuspendedAsUser(String[] packageNames, boolean suspended, + PersistableBundle appExtras, PersistableBundle launcherExtras, SuspendDialogInfo dialogInfo, + String callingPackage, int userId) throws RemoteException { + return new String[0]; + } + + @Override + public String[] getUnsuspendablePackagesForUser(String[] packageNames, int userId) + throws RemoteException { + return new String[0]; + } + + @Override + public boolean isPackageSuspendedForUser(String packageName, int userId) + throws RemoteException { + return false; + } + + @Override + public PersistableBundle getSuspendedPackageAppExtras(String packageName, int userId) + throws RemoteException { + return null; + } + + @Override + public byte[] getPreferredActivityBackup(int userId) throws RemoteException { + return new byte[0]; + } + + @Override + public void restorePreferredActivities(byte[] backup, int userId) throws RemoteException { + + } + + @Override + public byte[] getDefaultAppsBackup(int userId) throws RemoteException { + return new byte[0]; + } + + @Override + public void restoreDefaultApps(byte[] backup, int userId) throws RemoteException { + + } + + @Override + public byte[] getIntentFilterVerificationBackup(int userId) throws RemoteException { + return new byte[0]; + } + + @Override + public void restoreIntentFilterVerification(byte[] backup, int userId) throws RemoteException { + + } + + @Override + public byte[] getPermissionGrantBackup(int userId) throws RemoteException { + return new byte[0]; + } + + @Override + public void restorePermissionGrants(byte[] backup, int userId) throws RemoteException { + + } + + @Override + public ComponentName getHomeActivities(List outHomeCandidates) + throws RemoteException { + return null; + } + + @Override + public void setHomeActivity(ComponentName className, int userId) throws RemoteException { + + } + + @Override + public void setComponentEnabledSetting(ComponentName componentName, int newState, int flags, + int userId) throws RemoteException { + + } + + @Override + public int getComponentEnabledSetting(ComponentName componentName, int userId) + throws RemoteException { + return 0; + } + + @Override + public void setApplicationEnabledSetting(String packageName, int newState, int flags, + int userId, + String callingPackage) throws RemoteException { + + } + + @Override + public void logAppProcessStartIfNeeded(String processName, int uid, String seinfo, + String apkFile, + int pid) throws RemoteException { + + } + + @Override + public void flushPackageRestrictionsAsUser(int userId) throws RemoteException { + + } + + @Override + public void setPackageStoppedState(String packageName, boolean stopped, int userId) + throws RemoteException { + + } + + @Override + public void freeStorageAndNotify(String volumeUuid, long freeStorageSize, int storageFlags, + IPackageDataObserver observer) throws RemoteException { + + } + + @Override + public void freeStorage(String volumeUuid, long freeStorageSize, int storageFlags, + IntentSender pi) throws RemoteException { + + } + + @Override + public void deleteApplicationCacheFiles(String packageName, IPackageDataObserver observer) + throws RemoteException { + + } + + @Override + public void deleteApplicationCacheFilesAsUser(String packageName, int userId, + IPackageDataObserver observer) throws RemoteException { + + } + + @Override + public void clearApplicationUserData(String packageName, IPackageDataObserver observer, + int userId) throws RemoteException { + + } + + @Override + public void clearApplicationProfileData(String packageName) throws RemoteException { + + } + + @Override + public void getPackageSizeInfo(String packageName, int userHandle, + IPackageStatsObserver observer) + throws RemoteException { + + } + + @Override + public String[] getSystemSharedLibraryNames() throws RemoteException { + return new String[0]; + } + + @Override + public ParceledListSlice getSystemAvailableFeatures() throws RemoteException { + return null; + } + + @Override + public boolean hasSystemFeature(String name, int version) throws RemoteException { + return false; + } + + @Override + public void enterSafeMode() throws RemoteException { + + } + + @Override + public boolean isSafeMode() throws RemoteException { + return false; + } + + @Override + public void systemReady() throws RemoteException { + + } + + @Override + public boolean hasSystemUidErrors() throws RemoteException { + return false; + } + + @Override + public void performFstrimIfNeeded() throws RemoteException { + + } + + @Override + public void updatePackagesIfNeeded() throws RemoteException { + + } + + @Override + public void notifyPackageUse(String packageName, int reason) throws RemoteException { + + } + + @Override + public void notifyDexLoad(String loadingPackageName, List classLoadersNames, + List classPaths, String loaderIsa) throws RemoteException { + + } + + @Override + public void registerDexModule(String packageName, String dexModulePath, boolean isSharedModule, + IDexModuleRegisterCallback callback) throws RemoteException { + + } + + @Override + public boolean performDexOptMode(String packageName, boolean checkProfiles, + String targetCompilerFilter, boolean force, boolean bootComplete, String splitName) + throws RemoteException { + return false; + } + + @Override + public boolean performDexOptSecondary(String packageName, String targetCompilerFilter, + boolean force) throws RemoteException { + return false; + } + + @Override + public boolean compileLayouts(String packageName) throws RemoteException { + return false; + } + + @Override + public void dumpProfiles(String packageName) throws RemoteException { + + } + + @Override + public void forceDexOpt(String packageName) throws RemoteException { + + } + + @Override + public boolean runBackgroundDexoptJob(List packageNames) throws RemoteException { + return false; + } + + @Override + public void reconcileSecondaryDexFiles(String packageName) throws RemoteException { + + } + + @Override + public int getMoveStatus(int moveId) throws RemoteException { + return 0; + } + + @Override + public void registerMoveCallback(IPackageMoveObserver callback) throws RemoteException { + + } + + @Override + public void unregisterMoveCallback(IPackageMoveObserver callback) throws RemoteException { + + } + + @Override + public int movePackage(String packageName, String volumeUuid) throws RemoteException { + return 0; + } + + @Override + public int movePrimaryStorage(String volumeUuid) throws RemoteException { + return 0; + } + + @Override + public boolean addPermissionAsync(PermissionInfo info) throws RemoteException { + return false; + } + + @Override + public boolean setInstallLocation(int loc) throws RemoteException { + return false; + } + + @Override + public int getInstallLocation() throws RemoteException { + return 0; + } + + @Override + public int installExistingPackageAsUser(String packageName, int userId, int installFlags, + int installReason) throws RemoteException { + return 0; + } + + @Override + public void verifyPendingInstall(int id, int verificationCode) throws RemoteException { + + } + + @Override + public void extendVerificationTimeout(int id, int verificationCodeAtTimeout, + long millisecondsToDelay) throws RemoteException { + + } + + @Override + public void verifyIntentFilter(int id, int verificationCode, List failedDomains) + throws RemoteException { + + } + + @Override + public int getIntentVerificationStatus(String packageName, int userId) throws RemoteException { + return 0; + } + + @Override + public boolean updateIntentVerificationStatus(String packageName, int status, int userId) + throws RemoteException { + return false; + } + + @Override + public ParceledListSlice getIntentFilterVerifications(String packageName) + throws RemoteException { + return null; + } + + @Override + public ParceledListSlice getAllIntentFilters(String packageName) throws RemoteException { + return null; + } + + @Override + public boolean setDefaultBrowserPackageName(String packageName, int userId) + throws RemoteException { + return false; + } + + @Override + public String getDefaultBrowserPackageName(int userId) throws RemoteException { + return null; + } + + @Override + public VerifierDeviceIdentity getVerifierDeviceIdentity() throws RemoteException { + return null; + } + + @Override + public boolean isFirstBoot() throws RemoteException { + return false; + } + + @Override + public boolean isOnlyCoreApps() throws RemoteException { + return false; + } + + @Override + public boolean isUpgrade() throws RemoteException { + return false; + } + + @Override + public void setPermissionEnforced(String permission, boolean enforced) throws RemoteException { + + } + + @Override + public boolean isPermissionEnforced(String permission) throws RemoteException { + return false; + } + + @Override + public boolean isStorageLow() throws RemoteException { + return false; + } + + @Override + public boolean setApplicationHiddenSettingAsUser(String packageName, boolean hidden, int userId) + throws RemoteException { + return false; + } + + @Override + public boolean getApplicationHiddenSettingAsUser(String packageName, int userId) + throws RemoteException { + return false; + } + + @Override + public void setSystemAppHiddenUntilInstalled(String packageName, boolean hidden) + throws RemoteException { + + } + + @Override + public boolean setSystemAppInstallState(String packageName, boolean installed, int userId) + throws RemoteException { + return false; + } + + @Override + public IPackageInstaller getPackageInstaller() throws RemoteException { + return null; + } + + @Override + public boolean setBlockUninstallForUser(String packageName, boolean blockUninstall, int userId) + throws RemoteException { + return false; + } + + @Override + public boolean getBlockUninstallForUser(String packageName, int userId) throws RemoteException { + return false; + } + + @Override + public KeySet getKeySetByAlias(String packageName, String alias) throws RemoteException { + return null; + } + + @Override + public KeySet getSigningKeySet(String packageName) throws RemoteException { + return null; + } + + @Override + public boolean isPackageSignedByKeySet(String packageName, KeySet ks) throws RemoteException { + return false; + } + + @Override + public boolean isPackageSignedByKeySetExactly(String packageName, KeySet ks) + throws RemoteException { + return false; + } + + @Override + public void addOnPermissionsChangeListener(IOnPermissionsChangeListener listener) + throws RemoteException { + + } + + @Override + public void removeOnPermissionsChangeListener(IOnPermissionsChangeListener listener) + throws RemoteException { + + } + + @Override + public void grantDefaultPermissionsToEnabledCarrierApps(String[] packageNames, int userId) + throws RemoteException { + + } + + @Override + public void grantDefaultPermissionsToEnabledImsServices(String[] packageNames, int userId) + throws RemoteException { + + } + + @Override + public void grantDefaultPermissionsToEnabledTelephonyDataServices(String[] packageNames, + int userId) throws RemoteException { + + } + + @Override + public void revokeDefaultPermissionsFromDisabledTelephonyDataServices(String[] packageNames, + int userId) throws RemoteException { + + } + + @Override + public void grantDefaultPermissionsToActiveLuiApp(String packageName, int userId) + throws RemoteException { + + } + + @Override + public void revokeDefaultPermissionsFromLuiApps(String[] packageNames, int userId) + throws RemoteException { + + } + + @Override + public boolean isPermissionRevokedByPolicy(String permission, String packageName, int userId) + throws RemoteException { + return false; + } + + @Override + public String getPermissionControllerPackageName() throws RemoteException { + return null; + } + + @Override + public ParceledListSlice getInstantApps(int userId) throws RemoteException { + return null; + } + + @Override + public byte[] getInstantAppCookie(String packageName, int userId) throws RemoteException { + return new byte[0]; + } + + @Override + public boolean setInstantAppCookie(String packageName, byte[] cookie, int userId) + throws RemoteException { + return false; + } + + @Override + public Bitmap getInstantAppIcon(String packageName, int userId) throws RemoteException { + return null; + } + + @Override + public boolean isInstantApp(String packageName, int userId) throws RemoteException { + return false; + } + + @Override + public boolean setRequiredForSystemUser(String packageName, boolean systemUserApp) + throws RemoteException { + return false; + } + + @Override + public void setUpdateAvailable(String packageName, boolean updateAvaialble) + throws RemoteException { + + } + + @Override + public String getServicesSystemSharedLibraryPackageName() throws RemoteException { + return null; + } + + @Override + public String getSharedSystemSharedLibraryPackageName() throws RemoteException { + return null; + } + + @Override + public ChangedPackages getChangedPackages(int sequenceNumber, int userId) + throws RemoteException { + return null; + } + + @Override + public boolean isPackageDeviceAdminOnAnyUser(String packageName) throws RemoteException { + return false; + } + + @Override + public int getInstallReason(String packageName, int userId) throws RemoteException { + return 0; + } + + @Override + public ParceledListSlice getSharedLibraries(String packageName, int flags, int userId) + throws RemoteException { + return null; + } + + @Override + public boolean canRequestPackageInstalls(String packageName, int userId) + throws RemoteException { + return false; + } + + @Override + public void deletePreloadsFileCache() throws RemoteException { + + } + + @Override + public ComponentName getInstantAppResolverComponent() throws RemoteException { + return null; + } + + @Override + public ComponentName getInstantAppResolverSettingsComponent() throws RemoteException { + return null; + } + + @Override + public ComponentName getInstantAppInstallerComponent() throws RemoteException { + return null; + } + + @Override + public String getInstantAppAndroidId(String packageName, int userId) throws RemoteException { + return null; + } + + @Override + public IArtManager getArtManager() throws RemoteException { + return null; + } + + @Override + public void setHarmfulAppWarning(String packageName, CharSequence warning, int userId) + throws RemoteException { + + } + + @Override + public CharSequence getHarmfulAppWarning(String packageName, int userId) + throws RemoteException { + return null; + } + + @Override + public boolean hasSigningCertificate(String packageName, byte[] signingCertificate, int flags) + throws RemoteException { + return false; + } + + @Override + public boolean hasUidSigningCertificate(int uid, byte[] signingCertificate, int flags) + throws RemoteException { + return false; + } + + @Override + public String getSystemTextClassifierPackageName() throws RemoteException { + return null; + } + + @Override + public String getWellbeingPackageName() throws RemoteException { + return null; + } + + @Override + public boolean isPackageStateProtected(String packageName, int userId) throws RemoteException { + return false; + } + + @Override + public void sendDeviceCustomizationReadyBroadcast() throws RemoteException { + + } + + @Override + public List getInstalledModules(int flags) throws RemoteException { + return null; + } + + @Override + public ModuleInfo getModuleInfo(String packageName, int flags) throws RemoteException { + return null; + } + + @Override + public IBinder asBinder() { + return null; + } +} diff --git a/services/tests/servicestests/src/com/android/server/backup/testutils/PackageManagerStub.java b/services/tests/servicestests/src/com/android/server/backup/testutils/PackageManagerStub.java index 525135c6fc5a7..717275232a81d 100644 --- a/services/tests/servicestests/src/com/android/server/backup/testutils/PackageManagerStub.java +++ b/services/tests/servicestests/src/com/android/server/backup/testutils/PackageManagerStub.java @@ -48,11 +48,7 @@ public class PackageManagerStub extends PackageManager { @Override public PackageInfo getPackageInfo(String packageName, int flags) throws NameNotFoundException { - if (sPackageInfo == null) { - throw new NameNotFoundException(); - } - - return sPackageInfo; + return getPackageInfoAsUser(packageName, flags, UserHandle.USER_SYSTEM); } @Override @@ -64,7 +60,11 @@ public class PackageManagerStub extends PackageManager { @Override public PackageInfo getPackageInfoAsUser(String packageName, int flags, int userId) throws NameNotFoundException { - return null; + if (sPackageInfo == null) { + throw new NameNotFoundException(); + } + + return sPackageInfo; } @Override diff --git a/services/tests/servicestests/src/com/android/server/backup/utils/AppBackupUtilsTest.java b/services/tests/servicestests/src/com/android/server/backup/utils/AppBackupUtilsTest.java index 479a19b93ca7f..a92b576e5d0fa 100644 --- a/services/tests/servicestests/src/com/android/server/backup/utils/AppBackupUtilsTest.java +++ b/services/tests/servicestests/src/com/android/server/backup/utils/AppBackupUtilsTest.java @@ -29,13 +29,14 @@ import android.content.pm.PackageParser; import android.content.pm.Signature; import android.content.pm.SigningInfo; import android.os.Process; +import android.os.UserHandle; import android.platform.test.annotations.Presubmit; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; import com.android.server.backup.UserBackupManagerService; -import com.android.server.backup.testutils.PackageManagerStub; +import com.android.server.backup.testutils.IPackageManagerStub; import org.junit.Before; import org.junit.Test; @@ -53,13 +54,17 @@ public class AppBackupUtilsTest { private static final Signature SIGNATURE_3 = generateSignature((byte) 3); private static final Signature SIGNATURE_4 = generateSignature((byte) 4); - private PackageManagerStub mPackageManagerStub; + private IPackageManagerStub mPackageManagerStub; private PackageManagerInternal mMockPackageManagerInternal; + private int mUserId; + @Before public void setUp() throws Exception { - mPackageManagerStub = new PackageManagerStub(); + mPackageManagerStub = new IPackageManagerStub(); mMockPackageManagerInternal = mock(PackageManagerInternal.class); + + mUserId = UserHandle.USER_SYSTEM; } @Test @@ -71,7 +76,7 @@ public class AppBackupUtilsTest { applicationInfo.packageName = TEST_PACKAGE_NAME; boolean isEligible = AppBackupUtils.appIsEligibleForBackup(applicationInfo, - mPackageManagerStub); + mPackageManagerStub, mUserId); assertThat(isEligible).isFalse(); } @@ -86,7 +91,7 @@ public class AppBackupUtilsTest { applicationInfo.packageName = TEST_PACKAGE_NAME; boolean isEligible = AppBackupUtils.appIsEligibleForBackup(applicationInfo, - mPackageManagerStub); + mPackageManagerStub, mUserId); assertThat(isEligible).isFalse(); } @@ -100,7 +105,7 @@ public class AppBackupUtilsTest { applicationInfo.packageName = UserBackupManagerService.SHARED_BACKUP_AGENT_PACKAGE; boolean isEligible = AppBackupUtils.appIsEligibleForBackup(applicationInfo, - mPackageManagerStub); + mPackageManagerStub, mUserId); assertThat(isEligible).isFalse(); } @@ -114,11 +119,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = CUSTOM_BACKUP_AGENT_NAME; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED; boolean isEligible = AppBackupUtils.appIsEligibleForBackup(applicationInfo, - mPackageManagerStub); + mPackageManagerStub, mUserId); assertThat(isEligible).isTrue(); } @@ -132,11 +137,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = null; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED; boolean isEligible = AppBackupUtils.appIsEligibleForBackup(applicationInfo, - mPackageManagerStub); + mPackageManagerStub, mUserId); assertThat(isEligible).isTrue(); } @@ -150,11 +155,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = CUSTOM_BACKUP_AGENT_NAME; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED; boolean isEligible = AppBackupUtils.appIsEligibleForBackup(applicationInfo, - mPackageManagerStub); + mPackageManagerStub, mUserId); assertThat(isEligible).isTrue(); } @@ -168,11 +173,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = CUSTOM_BACKUP_AGENT_NAME; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED; boolean isEligible = AppBackupUtils.appIsEligibleForBackup(applicationInfo, - mPackageManagerStub); + mPackageManagerStub, mUserId); assertThat(isEligible).isFalse(); } @@ -186,11 +191,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = null; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED; boolean isEligible = AppBackupUtils.appIsEligibleForBackup(applicationInfo, - mPackageManagerStub); + mPackageManagerStub, mUserId); assertThat(isEligible).isFalse(); } @@ -204,11 +209,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = CUSTOM_BACKUP_AGENT_NAME; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED; boolean isEligible = AppBackupUtils.appIsEligibleForBackup(applicationInfo, - mPackageManagerStub); + mPackageManagerStub, mUserId); assertThat(isEligible).isFalse(); } @@ -222,10 +227,11 @@ public class AppBackupUtilsTest { applicationInfo.packageName = TEST_PACKAGE_NAME; applicationInfo.enabled = true; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; - boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub); + boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub, + mUserId); assertThat(isDisabled).isFalse(); } @@ -239,10 +245,11 @@ public class AppBackupUtilsTest { applicationInfo.packageName = TEST_PACKAGE_NAME; applicationInfo.enabled = false; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; - boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub); + boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub, + mUserId); assertThat(isDisabled).isTrue(); } @@ -255,10 +262,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = CUSTOM_BACKUP_AGENT_NAME; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED; - boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub); + boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub, + mUserId); assertThat(isDisabled).isFalse(); } @@ -271,10 +279,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = CUSTOM_BACKUP_AGENT_NAME; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED; - boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub); + boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub, + mUserId); assertThat(isDisabled).isTrue(); } @@ -287,10 +296,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = CUSTOM_BACKUP_AGENT_NAME; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER; - boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub); + boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub, + mUserId); assertThat(isDisabled).isTrue(); } @@ -303,10 +313,11 @@ public class AppBackupUtilsTest { applicationInfo.backupAgentName = CUSTOM_BACKUP_AGENT_NAME; applicationInfo.packageName = TEST_PACKAGE_NAME; - PackageManagerStub.sApplicationEnabledSetting = + IPackageManagerStub.sApplicationEnabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED; - boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub); + boolean isDisabled = AppBackupUtils.appIsDisabled(applicationInfo, mPackageManagerStub, + mUserId); assertThat(isDisabled).isTrue(); } diff --git a/services/tests/servicestests/src/com/android/server/backup/utils/TarBackupReaderTest.java b/services/tests/servicestests/src/com/android/server/backup/utils/TarBackupReaderTest.java index d43b677d0e505..5fcce671db1e0 100644 --- a/services/tests/servicestests/src/com/android/server/backup/utils/TarBackupReaderTest.java +++ b/services/tests/servicestests/src/com/android/server/backup/utils/TarBackupReaderTest.java @@ -44,6 +44,7 @@ import android.content.pm.Signature; import android.content.pm.SigningInfo; import android.os.Bundle; import android.os.Process; +import android.os.UserHandle; import android.platform.test.annotations.Presubmit; import androidx.test.InstrumentationRegistry; @@ -88,12 +89,14 @@ public class TarBackupReaderTest { private final PackageManagerStub mPackageManagerStub = new PackageManagerStub(); private Context mContext; + private int mUserId; @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); mContext = InstrumentationRegistry.getContext(); + mUserId = UserHandle.USER_SYSTEM; } @Test @@ -146,7 +149,7 @@ public class TarBackupReaderTest { fileMetadata); RestorePolicy restorePolicy = tarBackupReader.chooseRestorePolicy( mPackageManagerStub, false /* allowApks */, fileMetadata, signatures, - mMockPackageManagerInternal); + mMockPackageManagerInternal, mUserId); assertThat(restorePolicy).isEqualTo(RestorePolicy.IGNORE); assertThat(fileMetadata.packageName).isEqualTo(TEST_PACKAGE_NAME); @@ -160,7 +163,7 @@ public class TarBackupReaderTest { fileMetadata); restorePolicy = tarBackupReader.chooseRestorePolicy( mPackageManagerStub, false /* allowApks */, fileMetadata, signatures, - mMockPackageManagerInternal); + mMockPackageManagerInternal, mUserId); assertThat(restorePolicy).isEqualTo(RestorePolicy.IGNORE); assertThat(fileMetadata.packageName).isEqualTo(TEST_PACKAGE_NAME); @@ -223,7 +226,7 @@ public class TarBackupReaderTest { RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, true /* allowApks */, new FileMetadata(), null /* signatures */, - mMockPackageManagerInternal); + mMockPackageManagerInternal, mUserId); assertThat(policy).isEqualTo(RestorePolicy.IGNORE); verifyZeroInteractions(mBackupManagerMonitorMock); @@ -244,7 +247,7 @@ public class TarBackupReaderTest { RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, true /* allowApks */, info, new Signature[0] /* signatures */, - mMockPackageManagerInternal); + mMockPackageManagerInternal, mUserId); assertThat(policy).isEqualTo(RestorePolicy.ACCEPT_IF_APK); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class); @@ -269,7 +272,7 @@ public class TarBackupReaderTest { RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, true /* allowApks */, info, new Signature[0] /* signatures */, - mMockPackageManagerInternal); + mMockPackageManagerInternal, mUserId); assertThat(policy).isEqualTo(RestorePolicy.ACCEPT_IF_APK); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class); @@ -295,7 +298,7 @@ public class TarBackupReaderTest { RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, false /* allowApks */, new FileMetadata(), new Signature[0] /* signatures */, - mMockPackageManagerInternal); + mMockPackageManagerInternal, mUserId); assertThat(policy).isEqualTo(RestorePolicy.IGNORE); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class); @@ -320,7 +323,7 @@ public class TarBackupReaderTest { RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, false /* allowApks */, new FileMetadata(), new Signature[0] /* signatures */, - mMockPackageManagerInternal); + mMockPackageManagerInternal, mUserId); assertThat(policy).isEqualTo(RestorePolicy.IGNORE); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class); @@ -347,7 +350,7 @@ public class TarBackupReaderTest { RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, false /* allowApks */, new FileMetadata(), new Signature[0] /* signatures */, - mMockPackageManagerInternal); + mMockPackageManagerInternal, mUserId); assertThat(policy).isEqualTo(RestorePolicy.IGNORE); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class); @@ -381,7 +384,8 @@ public class TarBackupReaderTest { PackageManagerStub.sPackageInfo = packageInfo; RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, - false /* allowApks */, new FileMetadata(), signatures, mMockPackageManagerInternal); + false /* allowApks */, new FileMetadata(), signatures, + mMockPackageManagerInternal, mUserId); assertThat(policy).isEqualTo(RestorePolicy.IGNORE); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class); @@ -419,7 +423,8 @@ public class TarBackupReaderTest { doReturn(true).when(mMockPackageManagerInternal).isDataRestoreSafe(FAKE_SIGNATURE_1, packageInfo.packageName); RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, - false /* allowApks */, new FileMetadata(), signatures, mMockPackageManagerInternal); + false /* allowApks */, new FileMetadata(), signatures, + mMockPackageManagerInternal, mUserId); assertThat(policy).isEqualTo(RestorePolicy.ACCEPT); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class); @@ -456,7 +461,8 @@ public class TarBackupReaderTest { doReturn(true).when(mMockPackageManagerInternal).isDataRestoreSafe(FAKE_SIGNATURE_1, packageInfo.packageName); RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, - false /* allowApks */, new FileMetadata(), signatures, mMockPackageManagerInternal); + false /* allowApks */, new FileMetadata(), signatures, + mMockPackageManagerInternal, mUserId); assertThat(policy).isEqualTo(RestorePolicy.ACCEPT); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class); @@ -497,7 +503,8 @@ public class TarBackupReaderTest { doReturn(true).when(mMockPackageManagerInternal).isDataRestoreSafe(FAKE_SIGNATURE_1, packageInfo.packageName); RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, - false /* allowApks */, info, signatures, mMockPackageManagerInternal); + false /* allowApks */, info, signatures, mMockPackageManagerInternal, + mUserId); assertThat(policy).isEqualTo(RestorePolicy.ACCEPT); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class); @@ -540,7 +547,8 @@ public class TarBackupReaderTest { doReturn(true).when(mMockPackageManagerInternal).isDataRestoreSafe(FAKE_SIGNATURE_1, packageInfo.packageName); RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, - true /* allowApks */, info, signatures, mMockPackageManagerInternal); + true /* allowApks */, info, signatures, mMockPackageManagerInternal, + mUserId); assertThat(policy).isEqualTo(RestorePolicy.ACCEPT_IF_APK); verifyNoMoreInteractions(mBackupManagerMonitorMock); @@ -579,7 +587,8 @@ public class TarBackupReaderTest { doReturn(true).when(mMockPackageManagerInternal).isDataRestoreSafe(FAKE_SIGNATURE_1, packageInfo.packageName); RestorePolicy policy = tarBackupReader.chooseRestorePolicy(mPackageManagerStub, - false /* allowApks */, info, signatures, mMockPackageManagerInternal); + false /* allowApks */, info, signatures, mMockPackageManagerInternal, + mUserId); assertThat(policy).isEqualTo(RestorePolicy.IGNORE); ArgumentCaptor bundleCaptor = ArgumentCaptor.forClass(Bundle.class);