1 /*
2  * Copyright (C) 2021 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.server.sensorprivacy;
18 
19 import android.annotation.FlaggedApi;
20 import android.os.Handler;
21 
22 import com.android.internal.annotations.GuardedBy;
23 import com.android.internal.camera.flags.Flags;
24 import com.android.internal.util.dump.DualDumpOutputStream;
25 import com.android.internal.util.function.pooled.PooledLambda;
26 
27 abstract class SensorPrivacyStateController {
28 
29     private static SensorPrivacyStateController sInstance;
30 
31     AllSensorStateController mAllSensorStateController = AllSensorStateController.getInstance();
32 
33     private final Object mLock = new Object();
34 
getInstance()35     static SensorPrivacyStateController getInstance() {
36         if (sInstance == null) {
37             sInstance = SensorPrivacyStateControllerImpl.getInstance();
38         }
39 
40         return sInstance;
41     }
42 
getState(int toggleType, int userId, int sensor)43     SensorState getState(int toggleType, int userId, int sensor) {
44         synchronized (mLock) {
45             return getStateLocked(toggleType, userId, sensor);
46         }
47     }
48 
setState(int toggleType, int userId, int sensor, boolean enabled, Handler callbackHandler, SetStateResultCallback callback)49     void setState(int toggleType, int userId, int sensor, boolean enabled, Handler callbackHandler,
50             SetStateResultCallback callback) {
51         synchronized (mLock) {
52             setStateLocked(toggleType, userId, sensor, enabled, callbackHandler, callback);
53         }
54     }
55 
56     @FlaggedApi(Flags.FLAG_CAMERA_PRIVACY_ALLOWLIST)
setState(int toggleType, int userId, int sensor, int state, Handler callbackHandler, SetStateResultCallback callback)57     void setState(int toggleType, int userId, int sensor, int state, Handler callbackHandler,
58             SetStateResultCallback callback) {
59         synchronized (mLock) {
60             setStateLocked(toggleType, userId, sensor, state, callbackHandler, callback);
61         }
62     }
63 
setSensorPrivacyListener(Handler handler, SensorPrivacyListener listener)64     void setSensorPrivacyListener(Handler handler,
65             SensorPrivacyListener listener) {
66         synchronized (mLock) {
67             setSensorPrivacyListenerLocked(handler, listener);
68         }
69     }
70 
71     // Following calls are for the developer settings sensor mute feature
getAllSensorState()72     boolean getAllSensorState() {
73         synchronized (mLock) {
74             return mAllSensorStateController.getAllSensorStateLocked();
75         }
76     }
77 
setAllSensorState(boolean enable)78     void setAllSensorState(boolean enable) {
79         synchronized (mLock) {
80             mAllSensorStateController.setAllSensorStateLocked(enable);
81         }
82     }
83 
setAllSensorPrivacyListener(Handler handler, AllSensorPrivacyListener listener)84     void setAllSensorPrivacyListener(Handler handler, AllSensorPrivacyListener listener) {
85         synchronized (mLock) {
86             mAllSensorStateController.setAllSensorPrivacyListenerLocked(handler, listener);
87         }
88     }
89 
persistAll()90     void persistAll() {
91         synchronized (mLock) {
92             mAllSensorStateController.schedulePersistLocked();
93             schedulePersistLocked();
94         }
95     }
96 
forEachState(SensorPrivacyStateConsumer consumer)97     void forEachState(SensorPrivacyStateConsumer consumer) {
98         synchronized (mLock) {
99             forEachStateLocked(consumer);
100         }
101     }
102 
dump(DualDumpOutputStream dumpStream)103     void dump(DualDumpOutputStream dumpStream) {
104         synchronized (mLock) {
105             mAllSensorStateController.dumpLocked(dumpStream);
106             dumpLocked(dumpStream);
107         }
108         dumpStream.flush();
109     }
110 
atomic(Runnable r)111     public void atomic(Runnable r) {
112         synchronized (mLock) {
113             r.run();
114         }
115     }
116 
117     interface SensorPrivacyListener {
onSensorPrivacyChanged(int toggleType, int userId, int sensor, SensorState state)118         void onSensorPrivacyChanged(int toggleType, int userId, int sensor, SensorState state);
119     }
120 
121     interface SensorPrivacyStateConsumer {
accept(int toggleType, int userId, int sensor, SensorState state)122         void accept(int toggleType, int userId, int sensor, SensorState state);
123     }
124 
125     interface SetStateResultCallback {
callback(boolean changed)126         void callback(boolean changed);
127     }
128 
129     interface AllSensorPrivacyListener {
onAllSensorPrivacyChanged(boolean enabled)130         void onAllSensorPrivacyChanged(boolean enabled);
131     }
132 
133     @GuardedBy("mLock")
getStateLocked(int toggleType, int userId, int sensor)134     abstract SensorState getStateLocked(int toggleType, int userId, int sensor);
135 
136     @GuardedBy("mLock")
setStateLocked(int toggleType, int userId, int sensor, boolean enabled, Handler callbackHandler, SetStateResultCallback callback)137     abstract void setStateLocked(int toggleType, int userId, int sensor, boolean enabled,
138             Handler callbackHandler, SetStateResultCallback callback);
139 
140     @GuardedBy("mLock")
141     @FlaggedApi(Flags.FLAG_CAMERA_PRIVACY_ALLOWLIST)
setStateLocked(int toggleType, int userId, int sensor, int state, Handler callbackHandler, SetStateResultCallback callback)142     abstract void setStateLocked(int toggleType, int userId, int sensor, int state,
143             Handler callbackHandler, SetStateResultCallback callback);
144 
145     @GuardedBy("mLock")
setSensorPrivacyListenerLocked(Handler handler, SensorPrivacyListener listener)146     abstract void setSensorPrivacyListenerLocked(Handler handler,
147             SensorPrivacyListener listener);
148 
149     @GuardedBy("mLock")
schedulePersistLocked()150     abstract void schedulePersistLocked();
151 
152     @GuardedBy("mLock")
forEachStateLocked(SensorPrivacyStateConsumer consumer)153     abstract void forEachStateLocked(SensorPrivacyStateConsumer consumer);
154 
155     @GuardedBy("mLock")
dumpLocked(DualDumpOutputStream dumpStream)156     abstract void dumpLocked(DualDumpOutputStream dumpStream);
157 
sendSetStateCallback(Handler callbackHandler, SetStateResultCallback callback, boolean success)158     static void sendSetStateCallback(Handler callbackHandler,
159             SetStateResultCallback callback, boolean success) {
160         callbackHandler.sendMessage(PooledLambda.obtainMessage(SetStateResultCallback::callback,
161                 callback, success));
162     }
163 
164     /**
165      * Used for unit testing
166      */
resetForTesting()167     void resetForTesting() {
168         mAllSensorStateController.resetForTesting();
169         resetForTestingImpl();
170         sInstance = null;
171     }
resetForTestingImpl()172     abstract void resetForTestingImpl();
173 }
174