Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c187b71d authored by Aurélien Pomini's avatar Aurélien Pomini
Browse files

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
parent bc34c323

packages/WallpaperBackup/src/com/android/wallpaperbackup/WallpaperBackupAgent.java

+58 −19
Original line number Diff line number Diff line
@@ -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) {

                    if (success) {

                        if (!lockscreenLiveWallpaper || (which & FLAG_SYSTEM) != 0) {

                            logger.onSystemLiveWallpaperRestored(componentName);

                        }

                        if (lockscreenLiveWallpaper && (which & FLAG_LOCK) != 0) {

                            logger.onLockLiveWallpaperRestored(componentName);

                        }

                    } else {

                        if (!lockscreenLiveWallpaper || (which & FLAG_SYSTEM) != 0) {

                            logger.onSystemLiveWallpaperRestoreFailed(

                                    WallpaperEventLogger.ERROR_SET_COMPONENT_EXCEPTION);

                        }

                    if (applyToLock) {

                        if (lockscreenLiveWallpaper && (which & FLAG_LOCK) != 0) {

                            logger.onLockLiveWallpaperRestoreFailed(

                                    WallpaperEventLogger.ERROR_SET_COMPONENT_EXCEPTION);

                        }

                    }

                    if (applyToLock && !lockscreenLiveWallpaper) {

                        try {

                            mWallpaperManager.clear(FLAG_LOCK);

                            logger.onLockLiveWallpaperRestored(componentName);

packages/WallpaperBackup/test/src/com/android/wallpaperbackup/WallpaperBackupAgentTest.java

+44 −14
Original line number Diff line number Diff line
@@ -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,15 +365,24 @@ 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);



        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

    public void testUpdateWallpaperComponent_applyToLockFalse_doesApplyLaterOnlyToMainScreen()
@@ -380,15 +390,25 @@ 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);



        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

    public void testUpdateWallpaperComponent_deviceNotInRestore_doesNotApply()
@@ -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;

        }