1 /*
2  * Copyright (C) 2020 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.android.systemui.accessibility;
18 
19 import android.annotation.NonNull;
20 import android.graphics.Rect;
21 import android.os.Handler;
22 import android.os.RemoteException;
23 import android.util.Log;
24 import android.view.accessibility.IMagnificationConnection;
25 import android.view.accessibility.IMagnificationConnectionCallback;
26 import android.view.accessibility.IRemoteMagnificationAnimationCallback;
27 
28 import com.android.systemui.dagger.qualifiers.Main;
29 
30 /**
31  * Implementation of window magnification connection.
32  *
33  * @see IMagnificationConnection
34  */
35 class MagnificationConnectionImpl extends IMagnificationConnection.Stub {
36 
37     private static final String TAG = "WindowMagnificationConnectionImpl";
38 
39     private IMagnificationConnectionCallback mConnectionCallback;
40     private final Magnification mMagnification;
41     private final Handler mHandler;
42 
MagnificationConnectionImpl(@onNull Magnification magnification, @Main Handler mainHandler)43     MagnificationConnectionImpl(@NonNull Magnification magnification,
44             @Main Handler mainHandler) {
45         mMagnification = magnification;
46         mHandler = mainHandler;
47     }
48 
49     @Override
onFullscreenMagnificationActivationChanged(int displayId, boolean activated)50     public void onFullscreenMagnificationActivationChanged(int displayId, boolean activated) {
51         mHandler.post(() -> mMagnification
52                 .onFullscreenMagnificationActivationChanged(displayId, activated));
53     }
54 
55     @Override
enableWindowMagnification(int displayId, float scale, float centerX, float centerY, float magnificationFrameOffsetRatioX, float magnificationFrameOffsetRatioY, IRemoteMagnificationAnimationCallback callback)56     public void enableWindowMagnification(int displayId, float scale, float centerX, float centerY,
57             float magnificationFrameOffsetRatioX, float magnificationFrameOffsetRatioY,
58             IRemoteMagnificationAnimationCallback callback) {
59         mHandler.post(
60                 () -> mMagnification.enableWindowMagnification(displayId, scale, centerX,
61                         centerY, magnificationFrameOffsetRatioX,
62                         magnificationFrameOffsetRatioY, callback));
63     }
64 
65     @Override
setScaleForWindowMagnification(int displayId, float scale)66     public void setScaleForWindowMagnification(int displayId, float scale) {
67         mHandler.post(() -> mMagnification.setScaleForWindowMagnification(displayId, scale));
68     }
69 
70     @Override
disableWindowMagnification(int displayId, IRemoteMagnificationAnimationCallback callback)71     public void disableWindowMagnification(int displayId,
72             IRemoteMagnificationAnimationCallback callback) {
73         mHandler.post(() -> mMagnification.disableWindowMagnification(displayId,
74                 callback));
75     }
76 
77     @Override
moveWindowMagnifier(int displayId, float offsetX, float offsetY)78     public void moveWindowMagnifier(int displayId, float offsetX, float offsetY) {
79         mHandler.post(
80                 () -> mMagnification.moveWindowMagnifier(displayId, offsetX, offsetY));
81     }
82 
83     @Override
moveWindowMagnifierToPosition(int displayId, float positionX, float positionY, IRemoteMagnificationAnimationCallback callback)84     public void moveWindowMagnifierToPosition(int displayId, float positionX, float positionY,
85             IRemoteMagnificationAnimationCallback callback) {
86         mHandler.post(() -> mMagnification.moveWindowMagnifierToPositionInternal(
87                 displayId, positionX, positionY, callback));
88     }
89 
90     @Override
showMagnificationButton(int displayId, int magnificationMode)91     public void showMagnificationButton(int displayId, int magnificationMode) {
92         mHandler.post(
93                 () -> mMagnification.showMagnificationButton(displayId, magnificationMode));
94     }
95 
96     @Override
removeMagnificationButton(int displayId)97     public void removeMagnificationButton(int displayId) {
98         mHandler.post(
99                 () -> mMagnification.removeMagnificationButton(displayId));
100     }
101 
102     @Override
removeMagnificationSettingsPanel(int display)103     public void removeMagnificationSettingsPanel(int display) {
104         mHandler.post(() -> mMagnification.hideMagnificationSettingsPanel(display));
105     }
106 
107     @Override
onUserMagnificationScaleChanged(int userId, int displayId, float scale)108     public void onUserMagnificationScaleChanged(int userId, int displayId, float scale) {
109         mHandler.post(() -> mMagnification.setUserMagnificationScale(
110                 userId, displayId, scale));
111     }
112 
113     @Override
setConnectionCallback(IMagnificationConnectionCallback callback)114     public void setConnectionCallback(IMagnificationConnectionCallback callback) {
115         mConnectionCallback = callback;
116     }
117 
onWindowMagnifierBoundsChanged(int displayId, Rect frame)118     void onWindowMagnifierBoundsChanged(int displayId, Rect frame) {
119         if (mConnectionCallback != null) {
120             try {
121                 mConnectionCallback.onWindowMagnifierBoundsChanged(displayId, frame);
122             } catch (RemoteException e) {
123                 Log.e(TAG, "Failed to inform bounds changed", e);
124             }
125         }
126     }
127 
onSourceBoundsChanged(int displayId, Rect sourceBounds)128     void onSourceBoundsChanged(int displayId, Rect sourceBounds) {
129         if (mConnectionCallback != null) {
130             try {
131                 mConnectionCallback.onSourceBoundsChanged(displayId, sourceBounds);
132             } catch (RemoteException e) {
133                 Log.e(TAG, "Failed to inform source bounds changed", e);
134             }
135         }
136     }
137 
onPerformScaleAction(int displayId, float scale, boolean updatePersistence)138     void onPerformScaleAction(int displayId, float scale, boolean updatePersistence) {
139         if (mConnectionCallback != null) {
140             try {
141                 mConnectionCallback.onPerformScaleAction(displayId, scale, updatePersistence);
142             } catch (RemoteException e) {
143                 Log.e(TAG, "Failed to inform performing scale action", e);
144             }
145         }
146     }
147 
onAccessibilityActionPerformed(int displayId)148     void onAccessibilityActionPerformed(int displayId) {
149         if (mConnectionCallback != null) {
150             try {
151                 mConnectionCallback.onAccessibilityActionPerformed(displayId);
152             } catch (RemoteException e) {
153                 Log.e(TAG, "Failed to inform an accessibility action is already performed", e);
154             }
155         }
156     }
157 
onChangeMagnificationMode(int displayId, int mode)158     void onChangeMagnificationMode(int displayId, int mode) {
159         if (mConnectionCallback != null) {
160             try {
161                 mConnectionCallback.onChangeMagnificationMode(displayId, mode);
162             } catch (RemoteException e) {
163                 Log.e(TAG, "Failed to inform changing magnification mode", e);
164             }
165         }
166     }
167 
onMove(int displayId)168     void onMove(int displayId) {
169         if (mConnectionCallback != null) {
170             try {
171                 mConnectionCallback.onMove(displayId);
172             } catch (RemoteException e) {
173                 Log.e(TAG, "Failed to inform taking control by a user", e);
174             }
175         }
176     }
177 }
178