From bc34c3239543549af88b0b6f323b88fae3690426 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Aur=C3=A9lien=20Pomini?= Date: Fri, 2 Jun 2023 16:34:34 +0000 Subject: [PATCH 1/2] Don't log an error if system wallpaper is applied to lock MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Don't log an error if the lock image doesn't exist and the system image exists, since this is an intended behaviour. If the lockscreen was supposed to have an image but the image could not be backed up, we will see the error from the backup side. Adapt the test accordingly. Now, we only call either both restoreFromStage(FLAG_LOCK) and restoreFromStage(FLAG_SYSTEM), or call only restoreFromStage(FLAG_SYSTEM | FLAG_LOCK). Also, use this opportunity to make sure we only call file.exists() at most once, to reduce IO operations. Test: atest WallpaperBackupAgentTest Bug: 283091821 Change-Id: Ia19fcefc1676e8bd1fc0cf80c7a959c4d6f5839f --- .../wallpaperbackup/WallpaperBackupAgent.java | 16 +++++++++++----- .../WallpaperBackupAgentTest.java | 15 ++++++++------- 2 files changed, 19 insertions(+), 12 deletions(-) diff --git a/packages/WallpaperBackup/src/com/android/wallpaperbackup/WallpaperBackupAgent.java b/packages/WallpaperBackup/src/com/android/wallpaperbackup/WallpaperBackupAgent.java index 308e2cf017873..2ea6b51fc369f 100644 --- a/packages/WallpaperBackup/src/com/android/wallpaperbackup/WallpaperBackupAgent.java +++ b/packages/WallpaperBackup/src/com/android/wallpaperbackup/WallpaperBackupAgent.java @@ -359,11 +359,12 @@ public class WallpaperBackupAgent extends BackupAgent { final File infoStage = new File(filesDir, WALLPAPER_INFO_STAGE); final File imageStage = new File(filesDir, SYSTEM_WALLPAPER_STAGE); final File lockImageStage = new File(filesDir, LOCK_WALLPAPER_STAGE); + boolean lockImageStageExists = lockImageStage.exists(); // If we restored separate lock imagery, the system wallpaper should be // applied as system-only; but if there's no separate lock image, make // sure to apply the restored system wallpaper as both. - final int sysWhich = FLAG_SYSTEM | (lockImageStage.exists() ? 0 : FLAG_LOCK); + final int sysWhich = FLAG_SYSTEM | (lockImageStageExists ? 0 : FLAG_LOCK); try { // First parse the live component name so that we know for logging if we care about @@ -374,11 +375,14 @@ public class WallpaperBackupAgent extends BackupAgent { // It is valid for the imagery to be absent; it means that we were not permitted // to back up the original image on the source device, or there was no user-supplied // wallpaper image present. + restoreFromStage(imageStage, infoStage, "wp", sysWhich); - restoreFromStage(lockImageStage, infoStage, "kwp", FLAG_LOCK); + if (lockImageStageExists) { + restoreFromStage(lockImageStage, infoStage, "kwp", FLAG_LOCK); + } // And reset to the wallpaper service we should be using - updateWallpaperComponent(wpService, !lockImageStage.exists()); + updateWallpaperComponent(wpService, !lockImageStageExists); } catch (Exception e) { Slog.e(TAG, "Unable to restore wallpaper: " + e.getMessage()); mEventLogger.onRestoreException(e); @@ -437,7 +441,8 @@ public class WallpaperBackupAgent extends BackupAgent { // And log the success if ((which & FLAG_SYSTEM) > 0) { mEventLogger.onSystemImageWallpaperRestored(); - } else { + } + if ((which & FLAG_LOCK) > 0) { mEventLogger.onLockImageWallpaperRestored(); } } @@ -460,7 +465,8 @@ public class WallpaperBackupAgent extends BackupAgent { private void logRestoreError(int which, String error) { if ((which & FLAG_SYSTEM) == FLAG_SYSTEM) { mEventLogger.onSystemImageWallpaperRestoreFailed(error); - } else if ((which & FLAG_LOCK) == FLAG_LOCK) { + } + if ((which & FLAG_LOCK) == FLAG_LOCK) { mEventLogger.onLockImageWallpaperRestoreFailed(error); } } diff --git a/packages/WallpaperBackup/test/src/com/android/wallpaperbackup/WallpaperBackupAgentTest.java b/packages/WallpaperBackup/test/src/com/android/wallpaperbackup/WallpaperBackupAgentTest.java index 9b07ad41ef9ab..9cb9b20f681fb 100644 --- a/packages/WallpaperBackup/test/src/com/android/wallpaperbackup/WallpaperBackupAgentTest.java +++ b/packages/WallpaperBackup/test/src/com/android/wallpaperbackup/WallpaperBackupAgentTest.java @@ -649,19 +649,20 @@ public class WallpaperBackupAgentTest { } @Test - public void testOnRestore_lockWallpaperImgMissingAndNoLive_logsFailure() throws Exception { + public void testOnRestore_wallpaperImgMissingAndNoLive_logsFailure() throws Exception { mockStagedWallpaperFile(WALLPAPER_INFO_STAGE); - mockStagedWallpaperFile(SYSTEM_WALLPAPER_STAGE); mWallpaperBackupAgent.onCreate(USER_HANDLE, BackupAnnotations.BackupDestination.CLOUD, BackupAnnotations.OperationType.RESTORE); mWallpaperBackupAgent.onRestoreFinished(); - DataTypeResult result = getLoggingResult(WALLPAPER_IMG_LOCK, - mWallpaperBackupAgent.getBackupRestoreEventLogger().getLoggingResults()); - assertThat(result).isNotNull(); - assertThat(result.getFailCount()).isEqualTo(1); - assertThat(result.getErrors()).containsKey(ERROR_NO_WALLPAPER); + for (String wallpaper: List.of(WALLPAPER_IMG_LOCK, WALLPAPER_IMG_SYSTEM)) { + DataTypeResult result = getLoggingResult(wallpaper, + mWallpaperBackupAgent.getBackupRestoreEventLogger().getLoggingResults()); + assertThat(result).isNotNull(); + assertThat(result.getFailCount()).isEqualTo(1); + assertThat(result.getErrors()).containsKey(ERROR_NO_WALLPAPER); + } } @Test From c187b71d9c43eab65fafd6d7042ac59a64696087 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Aur=C3=A9lien=20Pomini?= Date: Wed, 17 May 2023 15:14:43 +0000 Subject: [PATCH 2/2] Adapt Wallpaper backup for lockscreen lwp Starting from U-QPR1, users can set a live wallpaper on the lock screen only. The feature is gated through the flag WallpaperManager.isLockscreenLiveWallpaperEnabled. This CL adapts the backup and restore logic accordingly when the flag is true. It should have no effect when the flag is false. Note: if a post u-qpr backup contains a lockscreen only live wallpaper, and gets restored to an older device not supporting lockscreen live wallpapers, the lockscreen wallpaper will be ignored and the home wallpaper will be applied to home+lock. Bug: 283091821 Test: backup & restore manually with two live wallpapers Test: atest WallpaperBackupAgentTest Change-Id: I98f847c97f42eb65fa626bf601e75daf15d59a45 --- .../wallpaperbackup/WallpaperBackupAgent.java | 77 ++++++++++++++----- .../WallpaperBackupAgentTest.java | 58 ++++++++++---- 2 files changed, 102 insertions(+), 33 deletions(-) diff --git a/packages/WallpaperBackup/src/com/android/wallpaperbackup/WallpaperBackupAgent.java b/packages/WallpaperBackup/src/com/android/wallpaperbackup/WallpaperBackupAgent.java index 2ea6b51fc369f..3406102b28ac4 100644 --- a/packages/WallpaperBackup/src/com/android/wallpaperbackup/WallpaperBackupAgent.java +++ b/packages/WallpaperBackup/src/com/android/wallpaperbackup/WallpaperBackupAgent.java @@ -361,28 +361,37 @@ public class WallpaperBackupAgent extends BackupAgent { final File lockImageStage = new File(filesDir, LOCK_WALLPAPER_STAGE); boolean lockImageStageExists = lockImageStage.exists(); - // If we restored separate lock imagery, the system wallpaper should be - // applied as system-only; but if there's no separate lock image, make - // sure to apply the restored system wallpaper as both. - final int sysWhich = FLAG_SYSTEM | (lockImageStageExists ? 0 : FLAG_LOCK); - try { // First parse the live component name so that we know for logging if we care about // logging errors with the image restore. ComponentName wpService = parseWallpaperComponent(infoStage, "wp"); mSystemHasLiveComponent = wpService != null; + ComponentName kwpService = null; + boolean lockscreenLiveWallpaper = mWallpaperManager.isLockscreenLiveWallpaperEnabled(); + if (lockscreenLiveWallpaper) { + kwpService = parseWallpaperComponent(infoStage, "kwp"); + } + mLockHasLiveComponent = kwpService != null; + boolean separateLockWallpaper = mLockHasLiveComponent || lockImageStage.exists(); + + // if there's no separate lock wallpaper, apply the system wallpaper to both screens. + final int sysWhich = separateLockWallpaper ? FLAG_SYSTEM : FLAG_SYSTEM | FLAG_LOCK; + // It is valid for the imagery to be absent; it means that we were not permitted // to back up the original image on the source device, or there was no user-supplied // wallpaper image present. - - restoreFromStage(imageStage, infoStage, "wp", sysWhich); + if (!lockscreenLiveWallpaper) restoreFromStage(imageStage, infoStage, "wp", sysWhich); if (lockImageStageExists) { restoreFromStage(lockImageStage, infoStage, "kwp", FLAG_LOCK); } + if (lockscreenLiveWallpaper) restoreFromStage(imageStage, infoStage, "wp", sysWhich); // And reset to the wallpaper service we should be using - updateWallpaperComponent(wpService, !lockImageStageExists); + if (lockscreenLiveWallpaper && mLockHasLiveComponent) { + updateWallpaperComponent(kwpService, false, FLAG_LOCK); + } + updateWallpaperComponent(wpService, !lockImageStageExists, sysWhich); } catch (Exception e) { Slog.e(TAG, "Unable to restore wallpaper: " + e.getMessage()); mEventLogger.onRestoreException(e); @@ -401,9 +410,21 @@ public class WallpaperBackupAgent extends BackupAgent { } @VisibleForTesting - void updateWallpaperComponent(ComponentName wpService, boolean applyToLock) throws IOException { + void updateWallpaperComponent(ComponentName wpService, boolean applyToLock, int which) + throws IOException { + boolean lockscreenLiveWallpaper = mWallpaperManager.isLockscreenLiveWallpaperEnabled(); if (servicePackageExists(wpService)) { Slog.i(TAG, "Using wallpaper service " + wpService); + if (lockscreenLiveWallpaper) { + mWallpaperManager.setWallpaperComponentWithFlags(wpService, which); + if ((which & FLAG_LOCK) != 0) { + mEventLogger.onLockLiveWallpaperRestored(wpService); + } + if ((which & FLAG_SYSTEM) != 0) { + mEventLogger.onSystemLiveWallpaperRestored(wpService); + } + return; + } mWallpaperManager.setWallpaperComponent(wpService); if (applyToLock) { // We have a live wallpaper and no static lock image, @@ -418,7 +439,7 @@ public class WallpaperBackupAgent extends BackupAgent { // in reports from users if (wpService != null) { // TODO(b/268471749): Handle delayed case - applyComponentAtInstall(wpService, applyToLock); + applyComponentAtInstall(wpService, applyToLock, which); Slog.w(TAG, "Wallpaper service " + wpService + " isn't available. " + " Will try to apply later"); } @@ -558,16 +579,21 @@ public class WallpaperBackupAgent extends BackupAgent { // Intentionally blank } - private void applyComponentAtInstall(ComponentName componentName, boolean applyToLock) { - PackageMonitor packageMonitor = getWallpaperPackageMonitor(componentName, applyToLock); + private void applyComponentAtInstall(ComponentName componentName, boolean applyToLock, + int which) { + PackageMonitor packageMonitor = getWallpaperPackageMonitor( + componentName, applyToLock, which); packageMonitor.register(getBaseContext(), null, UserHandle.ALL, true); } @VisibleForTesting - PackageMonitor getWallpaperPackageMonitor(ComponentName componentName, boolean applyToLock) { + PackageMonitor getWallpaperPackageMonitor(ComponentName componentName, boolean applyToLock, + int which) { return new PackageMonitor() { @Override public void onPackageAdded(String packageName, int uid) { + boolean lockscreenLiveWallpaper = + mWallpaperManager.isLockscreenLiveWallpaperEnabled(); if (!isDeviceInRestore()) { // We don't want to reapply the wallpaper outside a restore. unregister(); @@ -588,16 +614,29 @@ public class WallpaperBackupAgent extends BackupAgent { if (componentName.getPackageName().equals(packageName)) { Slog.d(TAG, "Applying component " + componentName); - boolean sysResult = mWallpaperManager.setWallpaperComponent(componentName); + boolean success = lockscreenLiveWallpaper + ? mWallpaperManager.setWallpaperComponentWithFlags(componentName, which) + : mWallpaperManager.setWallpaperComponent(componentName); WallpaperEventLogger logger = new WallpaperEventLogger( mBackupManager.getDelayedRestoreLogger()); - if (sysResult) { - logger.onSystemLiveWallpaperRestored(componentName); + if (success) { + if (!lockscreenLiveWallpaper || (which & FLAG_SYSTEM) != 0) { + logger.onSystemLiveWallpaperRestored(componentName); + } + if (lockscreenLiveWallpaper && (which & FLAG_LOCK) != 0) { + logger.onLockLiveWallpaperRestored(componentName); + } } else { - logger.onSystemLiveWallpaperRestoreFailed( - WallpaperEventLogger.ERROR_SET_COMPONENT_EXCEPTION); + if (!lockscreenLiveWallpaper || (which & FLAG_SYSTEM) != 0) { + logger.onSystemLiveWallpaperRestoreFailed( + WallpaperEventLogger.ERROR_SET_COMPONENT_EXCEPTION); + } + if (lockscreenLiveWallpaper && (which & FLAG_LOCK) != 0) { + logger.onLockLiveWallpaperRestoreFailed( + WallpaperEventLogger.ERROR_SET_COMPONENT_EXCEPTION); + } } - if (applyToLock) { + if (applyToLock && !lockscreenLiveWallpaper) { try { mWallpaperManager.clear(FLAG_LOCK); logger.onLockLiveWallpaperRestored(componentName); diff --git a/packages/WallpaperBackup/test/src/com/android/wallpaperbackup/WallpaperBackupAgentTest.java b/packages/WallpaperBackup/test/src/com/android/wallpaperbackup/WallpaperBackupAgentTest.java index 9cb9b20f681fb..dc1126edde410 100644 --- a/packages/WallpaperBackup/test/src/com/android/wallpaperbackup/WallpaperBackupAgentTest.java +++ b/packages/WallpaperBackup/test/src/com/android/wallpaperbackup/WallpaperBackupAgentTest.java @@ -117,6 +117,7 @@ public class WallpaperBackupAgentTest { public void setUp() { MockitoAnnotations.initMocks(this); + when(mWallpaperManager.isLockscreenLiveWallpaperEnabled()).thenReturn(true); when(mWallpaperManager.isWallpaperBackupEligible(eq(FLAG_SYSTEM))).thenReturn(true); when(mWallpaperManager.isWallpaperBackupEligible(eq(FLAG_LOCK))).thenReturn(true); @@ -364,14 +365,23 @@ public class WallpaperBackupAgentTest { mWallpaperBackupAgent.mIsDeviceInRestore = true; mWallpaperBackupAgent.updateWallpaperComponent(mWallpaperComponent, - /* applyToLock */ true); + /* applyToLock */ true, FLAG_LOCK | FLAG_SYSTEM); // Imitate wallpaper component installation. mWallpaperBackupAgent.mWallpaperPackageMonitor.onPackageAdded(TEST_WALLPAPER_PACKAGE, /* uid */0); - - verify(mWallpaperManager, times(1)).setWallpaperComponent(mWallpaperComponent); - verify(mWallpaperManager, times(1)).clear(eq(FLAG_LOCK)); + if (mWallpaperManager.isLockscreenLiveWallpaperEnabled()) { + verify(mWallpaperManager, times(1)) + .setWallpaperComponentWithFlags(mWallpaperComponent, FLAG_LOCK | FLAG_SYSTEM); + verify(mWallpaperManager, never()) + .setWallpaperComponentWithFlags(mWallpaperComponent, FLAG_SYSTEM); + verify(mWallpaperManager, never()) + .setWallpaperComponentWithFlags(mWallpaperComponent, FLAG_LOCK); + verify(mWallpaperManager, never()).clear(anyInt()); + } else { + verify(mWallpaperManager, times(1)).setWallpaperComponent(mWallpaperComponent); + verify(mWallpaperManager, times(1)).clear(eq(FLAG_LOCK)); + } } @Test @@ -380,14 +390,24 @@ public class WallpaperBackupAgentTest { mWallpaperBackupAgent.mIsDeviceInRestore = true; mWallpaperBackupAgent.updateWallpaperComponent(mWallpaperComponent, - /* applyToLock */ false); + /* applyToLock */ false, FLAG_SYSTEM); // Imitate wallpaper component installation. mWallpaperBackupAgent.mWallpaperPackageMonitor.onPackageAdded(TEST_WALLPAPER_PACKAGE, /* uid */0); - verify(mWallpaperManager, times(1)).setWallpaperComponent(mWallpaperComponent); - verify(mWallpaperManager, never()).clear(eq(FLAG_LOCK)); + if (mWallpaperManager.isLockscreenLiveWallpaperEnabled()) { + verify(mWallpaperManager, times(1)) + .setWallpaperComponentWithFlags(mWallpaperComponent, FLAG_SYSTEM); + verify(mWallpaperManager, never()) + .setWallpaperComponentWithFlags(mWallpaperComponent, FLAG_LOCK); + verify(mWallpaperManager, never()) + .setWallpaperComponentWithFlags(mWallpaperComponent, FLAG_LOCK | FLAG_SYSTEM); + verify(mWallpaperManager, never()).clear(anyInt()); + } else { + verify(mWallpaperManager, times(1)).setWallpaperComponent(mWallpaperComponent); + verify(mWallpaperManager, never()).clear(eq(FLAG_LOCK)); + } } @Test @@ -396,7 +416,7 @@ public class WallpaperBackupAgentTest { mWallpaperBackupAgent.mIsDeviceInRestore = false; mWallpaperBackupAgent.updateWallpaperComponent(mWallpaperComponent, - /* applyToLock */ true); + /* applyToLock */ true, FLAG_LOCK | FLAG_SYSTEM); // Imitate wallpaper component installation. mWallpaperBackupAgent.mWallpaperPackageMonitor.onPackageAdded(TEST_WALLPAPER_PACKAGE, @@ -412,7 +432,7 @@ public class WallpaperBackupAgentTest { mWallpaperBackupAgent.mIsDeviceInRestore = false; mWallpaperBackupAgent.updateWallpaperComponent(mWallpaperComponent, - /* applyToLock */ true); + /* applyToLock */ true, FLAG_LOCK | FLAG_SYSTEM); // Imitate "wrong" wallpaper component installation. mWallpaperBackupAgent.mWallpaperPackageMonitor.onPackageAdded(/* packageName */"", @@ -614,6 +634,13 @@ public class WallpaperBackupAgentTest { mWallpaperBackupAgent.getBackupRestoreEventLogger().getLoggingResults()); assertThat(result).isNotNull(); assertThat(result.getSuccessCount()).isEqualTo(1); + + if (mWallpaperManager.isLockscreenLiveWallpaperEnabled()) { + result = getLoggingResult(WALLPAPER_IMG_LOCK, + mWallpaperBackupAgent.getBackupRestoreEventLogger().getLoggingResults()); + assertThat(result).isNotNull(); + assertThat(result.getSuccessCount()).isEqualTo(1); + } } @Test @@ -723,13 +750,15 @@ public class WallpaperBackupAgentTest { public void testUpdateWallpaperComponent_delayedRestore_logsSuccess() throws Exception { mWallpaperBackupAgent.mIsDeviceInRestore = true; when(mWallpaperManager.setWallpaperComponent(any())).thenReturn(true); + when(mWallpaperManager.setWallpaperComponentWithFlags(any(), eq(FLAG_LOCK | FLAG_SYSTEM))) + .thenReturn(true); BackupRestoreEventLogger logger = new BackupRestoreEventLogger( BackupAnnotations.OperationType.RESTORE); when(mBackupManager.getDelayedRestoreLogger()).thenReturn(logger); mWallpaperBackupAgent.setBackupManagerForTesting(mBackupManager); mWallpaperBackupAgent.updateWallpaperComponent(mWallpaperComponent, - /* applyToLock */ true); + /* applyToLock */ true, FLAG_LOCK | FLAG_SYSTEM); // Imitate wallpaper component installation. mWallpaperBackupAgent.mWallpaperPackageMonitor.onPackageAdded(TEST_WALLPAPER_PACKAGE, /* uid */0); @@ -753,7 +782,7 @@ public class WallpaperBackupAgentTest { mWallpaperBackupAgent.setBackupManagerForTesting(mBackupManager); mWallpaperBackupAgent.updateWallpaperComponent(mWallpaperComponent, - /* applyToLock */ true); + /* applyToLock */ true, FLAG_LOCK | FLAG_SYSTEM); // Imitate wallpaper component installation. mWallpaperBackupAgent.mWallpaperPackageMonitor.onPackageAdded(TEST_WALLPAPER_PACKAGE, /* uid */0); @@ -775,7 +804,7 @@ public class WallpaperBackupAgentTest { mWallpaperBackupAgent.setBackupManagerForTesting(mBackupManager); mWallpaperBackupAgent.updateWallpaperComponent(mWallpaperComponent, - /* applyToLock */ true); + /* applyToLock */ true, FLAG_LOCK | FLAG_SYSTEM); // Imitate wallpaper component installation. mWallpaperBackupAgent.mWallpaperPackageMonitor.onPackageAdded(TEST_WALLPAPER_PACKAGE, @@ -910,8 +939,9 @@ public class WallpaperBackupAgentTest { @Override PackageMonitor getWallpaperPackageMonitor(ComponentName componentName, - boolean applyToLock) { - mWallpaperPackageMonitor = super.getWallpaperPackageMonitor(componentName, applyToLock); + boolean applyToLock, int which) { + mWallpaperPackageMonitor = super.getWallpaperPackageMonitor( + componentName, applyToLock, which); return mWallpaperPackageMonitor; }