1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware;
import android.annotation.NonNull;
import android.annotation.RequiresPermission;
import android.annotation.SystemService;
import android.content.Context;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.util.ArrayMap;
import com.android.internal.annotations.GuardedBy;
/**
* This class provides access to the sensor privacy services; sensor privacy allows the
* user to disable access to all sensors on the device. This class provides methods to query the
* current state of sensor privacy as well as to register / unregister for notification when
* the sensor privacy state changes.
*
* @hide
*/
@SystemService(Context.SENSOR_PRIVACY_SERVICE)
public final class SensorPrivacyManager {
/**
* A class implementing this interface can register with the {@link
* android.hardware.SensorPrivacyManager} to receive notification when the sensor privacy
* state changes.
*/
public interface OnSensorPrivacyChangedListener {
/**
* Callback invoked when the sensor privacy state changes.
*
* @param enabled true if sensor privacy is enabled, false otherwise.
*/
void onSensorPrivacyChanged(boolean enabled);
}
private static final Object sInstanceLock = new Object();
@GuardedBy("sInstanceLock")
private static SensorPrivacyManager sInstance;
@NonNull
private final Context mContext;
@NonNull
private final ISensorPrivacyManager mService;
@NonNull
private final ArrayMap<OnSensorPrivacyChangedListener, ISensorPrivacyListener> mListeners;
/**
* Private constructor to ensure only a single instance is created.
*/
private SensorPrivacyManager(Context context, ISensorPrivacyManager service) {
mContext = context;
mService = service;
mListeners = new ArrayMap<>();
}
/**
* Returns the single instance of the SensorPrivacyManager.
*/
public static SensorPrivacyManager getInstance(Context context) {
synchronized (sInstanceLock) {
if (sInstance == null) {
try {
IBinder b = ServiceManager.getServiceOrThrow(Context.SENSOR_PRIVACY_SERVICE);
ISensorPrivacyManager service = ISensorPrivacyManager.Stub.asInterface(b);
sInstance = new SensorPrivacyManager(context, service);
} catch (ServiceManager.ServiceNotFoundException e) {
throw new IllegalStateException(e);
}
}
return sInstance;
}
}
/**
* Sets sensor privacy to the specified state.
*
* @param enable the state to which sensor privacy should be set.
*/
@RequiresPermission(android.Manifest.permission.MANAGE_SENSOR_PRIVACY)
public void setSensorPrivacy(boolean enable) {
try {
mService.setSensorPrivacy(enable);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Registers a new listener to receive notification when the state of sensor privacy
* changes.
*
* @param listener the OnSensorPrivacyChangedListener to be notified when the state of sensor
* privacy changes.
*/
public void addSensorPrivacyListener(final OnSensorPrivacyChangedListener listener) {
synchronized (mListeners) {
ISensorPrivacyListener iListener = mListeners.get(listener);
if (iListener == null) {
iListener = new ISensorPrivacyListener.Stub() {
@Override
public void onSensorPrivacyChanged(boolean enabled) {
listener.onSensorPrivacyChanged(enabled);
}
};
mListeners.put(listener, iListener);
}
try {
mService.addSensorPrivacyListener(iListener);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
/**
* Unregisters the specified listener from receiving notifications when the state of sensor
* privacy changes.
*
* @param listener the OnSensorPrivacyChangedListener to be unregistered from notifications when
* sensor privacy changes.
*/
public void removeSensorPrivacyListener(OnSensorPrivacyChangedListener listener) {
synchronized (mListeners) {
ISensorPrivacyListener iListener = mListeners.get(listener);
if (iListener != null) {
mListeners.remove(iListener);
try {
mService.removeSensorPrivacyListener(iListener);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
}
/**
* Returns whether sensor privacy is currently enabled.
*
* @return true if sensor privacy is currently enabled, false otherwise.
*/
public boolean isSensorPrivacyEnabled() {
try {
return mService.isSensorPrivacyEnabled();
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
}
|
