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

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

Move wallpaper local color extraction to background 

This also moves all local color extraction related fields to the same
location, and remove unused parameters, in preparation for further refactors.

Test: treehugger
Test: perfetto trace
Test: atest WallpaperManagerTest
Bug: 268057764
Change-Id: I767889ae58d0132c987c5eda5519faf46150c67b
parent c001c9d1

core/java/android/service/wallpaper/WallpaperService.java

+99 −61
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ import android.hardware.display.DisplayManager.DisplayListener; 
import android.os.Build;

import android.os.Bundle;

import android.os.Handler;

import android.os.HandlerThread;

import android.os.IBinder;

import android.os.Looper;

import android.os.Message;
@@ -179,6 +180,8 @@ public abstract class WallpaperService extends Service { 


    private final ArrayList<Engine> mActiveEngines

            = new ArrayList<Engine>();

    private Handler mBackgroundHandler;

    private HandlerThread mBackgroundThread;



    static final class WallpaperCommand {

        String action;
@@ -198,14 +201,6 @@ public abstract class WallpaperService extends Service { 
     */

    public class Engine {

        IWallpaperEngineWrapper mIWallpaperEngine;

        final ArraySet<RectF> mLocalColorAreas = new ArraySet<>(4);

        final ArraySet<RectF> mLocalColorsToAdd = new ArraySet<>(4);



        // 2D matrix [x][y] to represent a page of a portion of a window

        EngineWindowPage[] mWindowPages = new EngineWindowPage[0];

        Bitmap mLastScreenshot;

        int mLastWindowPage = -1;

        private boolean mResetWindowPages;



        // Copies from mIWallpaperEngine.

        HandlerCaller mCaller;
@@ -267,11 +262,27 @@ public abstract class WallpaperService extends Service { 


        final Object mLock = new Object();

        boolean mOffsetMessageEnqueued;



        @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)

        float mPendingXOffset;

        float mPendingYOffset;

        float mPendingXOffsetStep;

        float mPendingYOffsetStep;



        /**

         * local color extraction related fields

         * to be used by the background thread only (except the atomic boolean)

         */

        final ArraySet<RectF> mLocalColorAreas = new ArraySet<>(4);

        final ArraySet<RectF> mLocalColorsToAdd = new ArraySet<>(4);

        private long mLastProcessLocalColorsTimestamp;

        private AtomicBoolean mProcessLocalColorsPending = new AtomicBoolean(false);

        private int mPixelCopyCount = 0;

        // 2D matrix [x][y] to represent a page of a portion of a window

        EngineWindowPage[] mWindowPages = new EngineWindowPage[0];

        Bitmap mLastScreenshot;

        private boolean mResetWindowPages;



        boolean mPendingSync;

        MotionEvent mPendingMove;

        boolean mIsInAmbientMode;
@@ -280,12 +291,8 @@ public abstract class WallpaperService extends Service { 
        private long mLastColorInvalidation;

        private final Runnable mNotifyColorsChanged = this::notifyColorsChanged;



        // used to throttle processLocalColors

        private long mLastProcessLocalColorsTimestamp;

        private AtomicBoolean mProcessLocalColorsPending = new AtomicBoolean(false);

        private final Supplier<Long> mClockFunction;

        private final Handler mHandler;



        private Display mDisplay;

        private Context mDisplayContext;

        private int mDisplayState;
@@ -825,7 +832,7 @@ public abstract class WallpaperService extends Service { 
                            + "was not established.");

                }

                mResetWindowPages = true;

                processLocalColors(mPendingXOffset, mPendingXOffsetStep);

                processLocalColors();

            } catch (RemoteException e) {

                Log.w(TAG, "Can't notify system because wallpaper connection was lost.", e);

            }
@@ -1364,7 +1371,7 @@ public abstract class WallpaperService extends Service { 
                            resetWindowPages();

                            mSession.finishDrawing(mWindow, null /* postDrawTransaction */,

                                                   Integer.MAX_VALUE);

                            processLocalColors(mPendingXOffset, mPendingXOffsetStep);

                            processLocalColors();

                        }

                        reposition();

                        reportEngineShown(shouldWaitForEngineShown());
@@ -1509,7 +1516,7 @@ public abstract class WallpaperService extends Service { 
            if (!mDestroyed) {

                mVisible = visible;

                reportVisibility();

                if (mReportedVisible) processLocalColors(mPendingXOffset, mPendingXOffsetStep);

                if (mReportedVisible) processLocalColors();

            } else {

                AnimationHandler.requestAnimatorsEnabled(visible, this);

            }
@@ -1593,31 +1600,44 @@ public abstract class WallpaperService extends Service { 
            }



            // setup local color extraction data

            processLocalColors(xOffset, xOffsetStep);

            processLocalColors();

        }



        /**

         * Thread-safe util to call {@link #processLocalColorsInternal} with a minimum interval of

         * {@link #PROCESS_LOCAL_COLORS_INTERVAL_MS} between two calls.

         */

        private void processLocalColors(float xOffset, float xOffsetStep) {

        private void processLocalColors() {

            if (mProcessLocalColorsPending.compareAndSet(false, true)) {

                final long now = mClockFunction.get();

                final long timeSinceLastColorProcess = now - mLastProcessLocalColorsTimestamp;

                final long timeToWait = Math.max(0,

                        PROCESS_LOCAL_COLORS_INTERVAL_MS - timeSinceLastColorProcess);



                mHandler.postDelayed(() -> {

                mBackgroundHandler.postDelayed(() -> {

                    mLastProcessLocalColorsTimestamp = now + timeToWait;

                    mProcessLocalColorsPending.set(false);

                    processLocalColorsInternal(xOffset, xOffsetStep);

                    processLocalColorsInternal();

                }, timeToWait);

            }

        }



        private void processLocalColorsInternal(float xOffset, float xOffsetStep) {

        private void processLocalColorsInternal() {

            // implemented by the wallpaper

            if (supportsLocalColorExtraction()) return;

            if (!mBackgroundHandler.getLooper().isCurrentThread()) {

                throw new IllegalStateException(

                        "ProcessLocalColors should be called from the background thread");

            }

            float xOffset;

            float xOffsetStep;

            float wallpaperDimAmount;

            synchronized (mLock) {

                xOffset = mPendingXOffset;

                xOffsetStep = mPendingXOffsetStep;

                wallpaperDimAmount = mWallpaperDimAmount;

            }



            if (DEBUG) {

                Log.d(TAG, "processLocalColors " + xOffset + " of step "

                        + xOffsetStep);
@@ -1680,7 +1700,7 @@ public abstract class WallpaperService extends Service { 
                xPage = mWindowPages.length - 1;

            }

            current = mWindowPages[xPage];

            updatePage(current, xPage, xPages, finalXOffsetStep);

            updatePage(current, xPage, xPages, wallpaperDimAmount);

            Trace.endSection();

        }
@@ -1700,16 +1720,21 @@ public abstract class WallpaperService extends Service { 
            }

        }



        /**

         * Must be called with the surface lock held.

         * Must not be called if the surface is not valid.

         * Will unlock the surface when done using it.

         */

        void updatePage(EngineWindowPage currentPage, int pageIndx, int numPages,

                float xOffsetStep) {

                float wallpaperDimAmount) {



            // in case the clock is zero, we start with negative time

            long current = SystemClock.elapsedRealtime() - DEFAULT_UPDATE_SCREENSHOT_DURATION;

            long lapsed = current - currentPage.getLastUpdateTime();

            // Always update the page when the last update time is <= 0

            // This is important especially when the device first boots

            if (lapsed < DEFAULT_UPDATE_SCREENSHOT_DURATION) {

                return;

            }

            if (lapsed < DEFAULT_UPDATE_SCREENSHOT_DURATION) return;



            Surface surface = mSurfaceHolder.getSurface();

            if (!surface.isValid()) return;

            boolean widthIsLarger = mSurfaceSize.x > mSurfaceSize.y;
@@ -1725,9 +1750,13 @@ public abstract class WallpaperService extends Service { 
            Bitmap screenShot = Bitmap.createBitmap(width, height,

                    Bitmap.Config.ARGB_8888);

            final Bitmap finalScreenShot = screenShot;

            Trace.beginSection("WallpaperService#pixelCopy");

            final String pixelCopySectionName = "WallpaperService#pixelCopy";

            final int pixelCopyCount = mPixelCopyCount++;

            Trace.beginAsyncSection(pixelCopySectionName, pixelCopyCount);

            try {

                PixelCopy.request(surface, screenShot, (res) -> {

                Trace.endSection();

                    mSurfaceHolder.mSurfaceLock.unlock();

                    Trace.endAsyncSection(pixelCopySectionName, pixelCopyCount);

                    if (DEBUG) Log.d(TAG, "result of pixel copy is " + res);

                    if (res != PixelCopy.SUCCESS) {

                        Bitmap lastBitmap = currentPage.getBitmap();
@@ -1736,21 +1765,26 @@ public abstract class WallpaperService extends Service { 
                        Bitmap lastScreenshot = mLastScreenshot;

                        if (lastScreenshot != null && !lastScreenshot.isRecycled()

                                && !Objects.equals(lastBitmap, lastScreenshot)) {

                        updatePageColors(currentPage, pageIndx, numPages, xOffsetStep);

                            updatePageColors(currentPage, pageIndx, numPages, wallpaperDimAmount);

                        }

                    } else {

                        mLastScreenshot = finalScreenShot;

                        // going to hold this lock for a while

                        currentPage.setBitmap(finalScreenShot);

                        currentPage.setLastUpdateTime(current);

                    updatePageColors(currentPage, pageIndx, numPages, xOffsetStep);

                        updatePageColors(currentPage, pageIndx, numPages, wallpaperDimAmount);

                    }

                }, mBackgroundHandler);

            } catch (IllegalArgumentException e) {

                // this can potentially happen if the surface is invalidated right between the

                // surface.isValid() check and the PixelCopy operation.

                // in this case, stop: we'll compute colors on the next processLocalColors call.

                Log.i(TAG, "Cancelling processLocalColors: exception caught during PixelCopy");

            }

            }, mHandler);



        }

        // locked by the passed page

        private void updatePageColors(EngineWindowPage page, int pageIndx, int numPages,

                float xOffsetStep) {

        private void updatePageColors(

                EngineWindowPage page, int pageIndx, int numPages, float wallpaperDimAmount) {

            if (page.getBitmap() == null) return;

            Trace.beginSection("WallpaperService#updatePageColors");

            if (DEBUG) {
@@ -1773,7 +1807,7 @@ public abstract class WallpaperService extends Service { 
                    Log.e(TAG, "Error creating page local color bitmap", e);

                    continue;

                }

                WallpaperColors color = WallpaperColors.fromBitmap(target, mWallpaperDimAmount);

                WallpaperColors color = WallpaperColors.fromBitmap(target, wallpaperDimAmount);

                target.recycle();

                WallpaperColors currentColor = page.getColors(area);
@@ -1790,12 +1824,14 @@ public abstract class WallpaperService extends Service { 
                                + " local color callback for area" + area + " for page " + pageIndx

                                + " of " + numPages);

                    }

                    mHandler.post(() -> {

                        try {

                            mConnection.onLocalWallpaperColorsChanged(area, color,

                                    mDisplayContext.getDisplayId());

                        } catch (RemoteException e) {

                            Log.e(TAG, "Error calling Connection.onLocalWallpaperColorsChanged", e);

                        }

                    });

                }

            }

            Trace.endSection();
@@ -1825,7 +1861,6 @@ public abstract class WallpaperService extends Service { 
            if (supportsLocalColorExtraction()) return;

            if (!mResetWindowPages) return;

            mResetWindowPages = false;

            mLastWindowPage = -1;

            for (int i = 0; i < mWindowPages.length; i++) {

                mWindowPages[i].setLastUpdateTime(0L);

            }
@@ -1851,12 +1886,10 @@ public abstract class WallpaperService extends Service { 
            if (DEBUG) {

                Log.d(TAG, "addLocalColorsAreas adding local color areas " + regions);

            }

            mHandler.post(() -> {

            mBackgroundHandler.post(() -> {

                mLocalColorsToAdd.addAll(regions);

                processLocalColors(mPendingXOffset, mPendingYOffset);

                processLocalColors();

            });





        }



        /**
@@ -1866,7 +1899,7 @@ public abstract class WallpaperService extends Service { 
         */

        public void removeLocalColorsAreas(@NonNull List<RectF> regions) {

            if (supportsLocalColorExtraction()) return;

            mHandler.post(() -> {

            mBackgroundHandler.post(() -> {

                float step = mPendingXOffsetStep;

                mLocalColorsToAdd.removeAll(regions);

                mLocalColorAreas.removeAll(regions);
@@ -2497,6 +2530,10 @@ public abstract class WallpaperService extends Service { 
    @Override

    public void onCreate() {

        Trace.beginSection("WPMS.onCreate");

        final String localColorExtractorThreadName = "DefaultWallpaperLocalColorExtractor";

        mBackgroundThread = new HandlerThread(localColorExtractorThreadName);

        mBackgroundThread.start();

        mBackgroundHandler = new Handler(mBackgroundThread.getLooper());

        super.onCreate();

        Trace.endSection();

    }
@@ -2509,6 +2546,7 @@ public abstract class WallpaperService extends Service { 
            mActiveEngines.get(i).detach();

        }

        mActiveEngines.clear();

        mBackgroundThread.quitSafely();

        Trace.endSection();

    }