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