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

Commit 55468c64 authored by Svetoslav Ganov's avatar Svetoslav Ganov
Browse files

Occasionally triple tap on the keyboard toggles screen magnification. 

1. Sometimes unlocking the device when the IME is up and triple tapping on the keyboard
   toggles screen magnification. The core reason is that when the kayguard window is
   shown we hide all other windows and when it is hidden we show these windows. We did
   not notify the screen magnifier for windows being shown and hidden. Also when the
   windows are shown we may reassign layers to put the IME or the wallpaper in the
   right Z order. The screen magnifier is now notified upon such layer reassignment
   since window layers are used when computing the magnified region.

bug:7351531

Change-Id: I0931f4ba6cfa565d8eb1e3c432268ba1818feea6
parent 7789c9bb

core/java/android/view/IDisplayContentChangeListener.aidl

+1 −0
Original line number Diff line number Diff line
@@ -28,5 +28,6 @@ import android.graphics.Rect; 
oneway interface IDisplayContentChangeListener {

    void onWindowTransition(int displayId, int transition, in WindowInfo info);

    void onRectangleOnScreenRequested(int displayId, in Rect rectangle, boolean immediate);

    void onWindowLayersChanged(int displayId);

    void onRotationChanged(int rotation);

}

services/java/com/android/server/accessibility/ScreenMagnifier.java

+11 −18
Original line number Diff line number Diff line
@@ -850,6 +850,7 @@ public final class ScreenMagnifier implements EventStreamTransformation { 
        private static final int MESSAGE_ON_RECTANGLE_ON_SCREEN_REQUESTED = 3;

        private static final int MESSAGE_ON_WINDOW_TRANSITION = 4;

        private static final int MESSAGE_ON_ROTATION_CHANGED = 5;

        private static final int MESSAGE_ON_WINDOW_LAYERS_CHANGED = 6;



        private final Handler mHandler = new MyHandler();
@@ -880,24 +881,8 @@ public final class ScreenMagnifier implements EventStreamTransformation { 
            mDisplayContentChangeListener = new IDisplayContentChangeListener.Stub() {

                @Override

                public void onWindowTransition(int displayId, int transition, WindowInfo info) {

                    Message message = mHandler.obtainMessage(MESSAGE_ON_WINDOW_TRANSITION,

                            transition, 0, WindowInfo.obtain(info));

                    // TODO: This makes me quite unhappy but for the time being the

                    //       least risky fix for cases where the keyguard is removed but

                    //       the windows it force hides are not made visible yet. Hence,

                    //       we would compute the magnified frame before we have a stable

                    //       state. One more reason to move the magnified frame computation

                    //       in the window manager!

                    if (info.type == WindowManager.LayoutParams.TYPE_KEYGUARD

                                || info.type == WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG

                            && (transition == WindowManagerPolicy.TRANSIT_EXIT

                                || transition == WindowManagerPolicy.TRANSIT_HIDE)) {

                        final long delay = (long) (2 * mLongAnimationDuration

                                * mWindowAnimationScale);

                        mHandler.sendMessageDelayed(message, delay);

                    } else {

                        message.sendToTarget();

                    }

                    mHandler.obtainMessage(MESSAGE_ON_WINDOW_TRANSITION,

                            transition, 0, WindowInfo.obtain(info)).sendToTarget();

                }



                @Override
@@ -917,6 +902,11 @@ public final class ScreenMagnifier implements EventStreamTransformation { 
                    mHandler.obtainMessage(MESSAGE_ON_ROTATION_CHANGED, rotation, 0)

                            .sendToTarget();

                }



                @Override

                public void onWindowLayersChanged(int displayId) throws RemoteException {

                    mHandler.sendEmptyMessage(MESSAGE_ON_WINDOW_LAYERS_CHANGED);

                }

            };



            try {
@@ -1192,6 +1182,9 @@ public final class ScreenMagnifier implements EventStreamTransformation { 
                        final int rotation = message.arg1;

                        handleOnRotationChanged(rotation);

                    } break;

                    case MESSAGE_ON_WINDOW_LAYERS_CHANGED: {

                        mViewport.recomputeBounds(mMagnificationController.isMagnifying());

                    } break;

                    default: {

                        throw new IllegalArgumentException("Unknown message: " + action);

                    }

services/java/com/android/server/wm/WindowManagerService.java

+49 −4
Original line number Diff line number Diff line
@@ -6576,6 +6576,36 @@ public class WindowManagerService extends IWindowManager.Stub 
        }

    }



    private void scheduleNotifyWindowLayersChangedIfNeededLocked(DisplayContent displayContent) {

        if (displayContent.mDisplayContentChangeListeners != null

                && displayContent.mDisplayContentChangeListeners.getRegisteredCallbackCount() > 0) {

            mH.obtainMessage(H.NOTIFY_WINDOW_LAYERS_CHANGED, displayContent) .sendToTarget();

        }

    }



    private void handleNotifyWindowLayersChanged(DisplayContent displayContent) {

        RemoteCallbackList<IDisplayContentChangeListener> callbacks = null;

        synchronized (mWindowMap) {

            callbacks = displayContent.mDisplayContentChangeListeners;

            if (callbacks == null) {

                return;

            }

        }

        try {

            final int watcherCount = callbacks.beginBroadcast();

            for (int i = 0; i < watcherCount; i++) {

                try {

                    callbacks.getBroadcastItem(i).onWindowLayersChanged(

                            displayContent.getDisplayId());

                } catch (RemoteException re) {

                    /* ignore */

                }

            }

        } finally {

            callbacks.finishBroadcast();

        }

    }



    public void addWindowChangeListener(WindowChangeListener listener) {

        synchronized(mWindowMap) {

            mWindowChangeListeners.add(listener);
@@ -7222,12 +7252,13 @@ public class WindowManagerService extends IWindowManager.Stub 
        public static final int NOTIFY_ROTATION_CHANGED = 28;

        public static final int NOTIFY_WINDOW_TRANSITION = 29;

        public static final int NOTIFY_RECTANGLE_ON_SCREEN_REQUESTED = 30;

        public static final int NOTIFY_WINDOW_LAYERS_CHANGED = 31;



        public static final int DO_DISPLAY_ADDED = 31;

        public static final int DO_DISPLAY_REMOVED = 32;

        public static final int DO_DISPLAY_CHANGED = 33;

        public static final int DO_DISPLAY_ADDED = 32;

        public static final int DO_DISPLAY_REMOVED = 33;

        public static final int DO_DISPLAY_CHANGED = 34;



        public static final int CLIENT_FREEZE_TIMEOUT = 34;

        public static final int CLIENT_FREEZE_TIMEOUT = 35;



        public static final int ANIMATOR_WHAT_OFFSET = 100000;

        public static final int SET_TRANSPARENT_REGION = ANIMATOR_WHAT_OFFSET + 1;
@@ -7699,6 +7730,12 @@ public class WindowManagerService extends IWindowManager.Stub 
                    break;

                }



                case NOTIFY_WINDOW_LAYERS_CHANGED: {

                    DisplayContent displayContent = (DisplayContent) msg.obj;

                    handleNotifyWindowLayersChanged(displayContent);

                    break;

                }



                case DO_DISPLAY_ADDED:

                    synchronized (mWindowMap) {

                        handleDisplayAddedLocked(msg.arg1);
@@ -8075,6 +8112,8 @@ public class WindowManagerService extends IWindowManager.Stub 
            Slog.v(TAG, "Assigning layers", here);

        }



        boolean anyLayerChanged = false;



        for (i=0; i<N; i++) {

            final WindowState w = windows.get(i);

            final WindowStateAnimator winAnimator = w.mWinAnimator;
@@ -8090,6 +8129,7 @@ public class WindowManagerService extends IWindowManager.Stub 
            }

            if (w.mLayer != oldLayer) {

                layerChanged = true;

                anyLayerChanged = true;

            }

            oldLayer = winAnimator.mAnimLayer;

            if (w.mTargetAppToken != null) {
@@ -8108,6 +8148,7 @@ public class WindowManagerService extends IWindowManager.Stub 
            }

            if (winAnimator.mAnimLayer != oldLayer) {

                layerChanged = true;

                anyLayerChanged = true;

            }

            if (layerChanged && mAnimator.isDimmingLocked(winAnimator)) {

                // Force an animation pass just to update the mDimAnimator layer.
@@ -8122,6 +8163,10 @@ public class WindowManagerService extends IWindowManager.Stub 
            //System.out.println(

            //    "Assigned layer " + curLayer + " to " + w.mClient.asBinder());

        }



        if (anyLayerChanged) {

            scheduleNotifyWindowLayersChangedIfNeededLocked(getDefaultDisplayContentLocked());

        }

    }



    private boolean mInLayout = false;