Update the settings privacy page to the latest mocks
Add the mic and camera toggles to the page. Also create an helper class to keep binder calls to the system_server at a minimum. Test: make RunSettingsRoboTests Test: atest SettingsUnitTests Test: Manual Bug: 183985427 Change-Id: Iff6ee1c9a2c30095307f636decbcfcf298ed31b0
This commit is contained in:
Evan Severson
270
src/com/android/settings/utils/SensorPrivacyManagerHelper.java
Normal file
270
src/com/android/settings/utils/SensorPrivacyManagerHelper.java
Normal file
@@ -0,0 +1,270 @@
|
||||
/*
|
||||
* Copyright (C) 2021 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 com.android.settings.utils;
|
||||
|
||||
import android.content.Context;
|
||||
import android.hardware.SensorPrivacyManager;
|
||||
import android.hardware.SensorPrivacyManager.OnSensorPrivacyChangedListener;
|
||||
import android.util.ArraySet;
|
||||
import android.util.SparseArray;
|
||||
|
||||
import java.util.concurrent.Executor;
|
||||
|
||||
/**
|
||||
* A class to help with calls to the sensor privacy manager. This class caches state when needed and
|
||||
* multiplexes multiple listeners to a minimal set of binder calls.
|
||||
*/
|
||||
public class SensorPrivacyManagerHelper {
|
||||
|
||||
public static final int MICROPHONE = SensorPrivacyManager.Sensors.MICROPHONE;
|
||||
public static final int CAMERA = SensorPrivacyManager.Sensors.CAMERA;
|
||||
|
||||
private static SensorPrivacyManagerHelper sInstance;
|
||||
|
||||
private final SensorPrivacyManager mSensorPrivacyManager;
|
||||
|
||||
private final SparseArray<Boolean> mCurrentUserCachedState = new SparseArray<>();
|
||||
private final SparseArray<SparseArray<Boolean>> mCachedState = new SparseArray<>();
|
||||
|
||||
private final SparseArray<OnSensorPrivacyChangedListener>
|
||||
mCurrentUserServiceListeners = new SparseArray<>();
|
||||
private final SparseArray<SparseArray<OnSensorPrivacyChangedListener>>
|
||||
mServiceListeners = new SparseArray<>();
|
||||
|
||||
private final ArraySet<CallbackInfo> mCallbacks = new ArraySet<>();
|
||||
|
||||
private final Object mLock = new Object();
|
||||
|
||||
/**
|
||||
* Callback for when the state of the sensor privacy changes.
|
||||
*/
|
||||
public interface Callback {
|
||||
|
||||
/**
|
||||
* Method invoked when the sensor privacy changes.
|
||||
* @param sensor The sensor which changed
|
||||
* @param blocked If the sensor is blocked
|
||||
*/
|
||||
void onSensorPrivacyChanged(int sensor, boolean blocked);
|
||||
}
|
||||
|
||||
private static class CallbackInfo {
|
||||
static final int CURRENT_USER = -1;
|
||||
|
||||
Callback mCallback;
|
||||
Executor mExecutor;
|
||||
int mSensor;
|
||||
int mUserId;
|
||||
|
||||
CallbackInfo(Callback callback, Executor executor, int sensor, int userId) {
|
||||
mCallback = callback;
|
||||
mExecutor = executor;
|
||||
mSensor = sensor;
|
||||
mUserId = userId;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the singleton instance
|
||||
* @param context The context which is needed if the instance hasn't been created
|
||||
* @return the instance
|
||||
*/
|
||||
public static SensorPrivacyManagerHelper getInstance(Context context) {
|
||||
if (sInstance == null) {
|
||||
sInstance = new SensorPrivacyManagerHelper(context);
|
||||
}
|
||||
return sInstance;
|
||||
}
|
||||
|
||||
/**
|
||||
* Only to be used in tests
|
||||
*/
|
||||
private static void clearInstance() {
|
||||
sInstance = null;
|
||||
}
|
||||
|
||||
private SensorPrivacyManagerHelper(Context context) {
|
||||
mSensorPrivacyManager = context.getSystemService(SensorPrivacyManager.class);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the given toggle is supported on this device
|
||||
* @param sensor The sensor to check
|
||||
* @return whether the toggle for the sensor is supported on this device.
|
||||
*/
|
||||
public boolean supportsSensorToggle(int sensor) {
|
||||
return mSensorPrivacyManager.supportsSensorToggle(sensor);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the sensor is blocked for the current user. If the user switches and the state of
|
||||
* the new user is different, this value will change.
|
||||
* @param sensor the sensor to check
|
||||
* @return true if the sensor is blocked for the current user
|
||||
*/
|
||||
public boolean isSensorBlocked(int sensor) {
|
||||
synchronized (mLock) {
|
||||
Boolean blocked = mCurrentUserCachedState.get(sensor);
|
||||
if (blocked == null) {
|
||||
registerCurrentUserListenerIfNeeded(sensor);
|
||||
|
||||
blocked = mSensorPrivacyManager.isSensorPrivacyEnabled(sensor);
|
||||
mCurrentUserCachedState.put(sensor, blocked);
|
||||
}
|
||||
|
||||
return blocked;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the sensor is or would be blocked if the given user is the foreground user
|
||||
* @param sensor the sensor to check
|
||||
* @param userId the user to check
|
||||
* @return true if the sensor is or would be blocked if the given user is the foreground user
|
||||
*/
|
||||
public boolean isSensorBlocked(int sensor, int userId) {
|
||||
synchronized (mLock) {
|
||||
SparseArray<Boolean> userCachedState = createUserCachedStateIfNeededLocked(userId);
|
||||
Boolean blocked = userCachedState.get(sensor);
|
||||
if (blocked == null) {
|
||||
registerListenerIfNeeded(sensor, userId);
|
||||
|
||||
blocked = mSensorPrivacyManager.isSensorPrivacyEnabled(sensor);
|
||||
userCachedState.put(sensor, blocked);
|
||||
}
|
||||
|
||||
return blocked;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the sensor privacy for the current user.
|
||||
* @param sensor The sensor to set for
|
||||
* @param blocked The state to set to
|
||||
*/
|
||||
public void setSensorBlocked(int sensor, boolean blocked) {
|
||||
mSensorPrivacyManager.setSensorPrivacy(sensor, blocked);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the sensor privacy for the given user.
|
||||
* @param sensor The sensor to set for
|
||||
* @param blocked The state to set to
|
||||
* @param userId The user to set for
|
||||
*/
|
||||
public void setSensorBlocked(int sensor, boolean blocked, int userId) {
|
||||
mSensorPrivacyManager.setSensorPrivacy(sensor, blocked, userId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a listener for the state of the current user. If the current user changes and the state
|
||||
* of the new user is different, a callback will be received.
|
||||
* @param sensor The sensor to watch
|
||||
* @param callback The callback to invoke
|
||||
* @param executor The executor to invoke on
|
||||
*/
|
||||
public void addSensorBlockedListener(int sensor, Callback callback, Executor executor) {
|
||||
synchronized (mLock) {
|
||||
mCallbacks.add(new CallbackInfo(callback, executor, sensor, CallbackInfo.CURRENT_USER));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a listener for the state of the given user
|
||||
* @param sensor The sensor to watch
|
||||
* @param callback The callback to invoke
|
||||
* @param executor The executor to invoke on
|
||||
*/
|
||||
public void addSensorBlockedListener(int sensor, int userId, Callback callback,
|
||||
Executor executor) {
|
||||
synchronized (mLock) {
|
||||
mCallbacks.add(new CallbackInfo(callback, executor, sensor, userId));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a callback
|
||||
* @param callback The callback to remove
|
||||
*/
|
||||
public void removeBlockedListener(Callback callback) {
|
||||
synchronized (mLock) {
|
||||
mCallbacks.removeIf(callbackInfo -> callbackInfo.mCallback == callback);
|
||||
}
|
||||
}
|
||||
|
||||
private void registerCurrentUserListenerIfNeeded(int sensor) {
|
||||
synchronized (mLock) {
|
||||
if (!mCurrentUserServiceListeners.contains(sensor)) {
|
||||
OnSensorPrivacyChangedListener listener = (s, enabled) -> {
|
||||
mCurrentUserCachedState.put(sensor, enabled);
|
||||
dispatchStateChangedLocked(sensor, enabled, CallbackInfo.CURRENT_USER);
|
||||
};
|
||||
mCurrentUserServiceListeners.put(sensor, listener);
|
||||
mSensorPrivacyManager.addSensorPrivacyListener(sensor, listener);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void registerListenerIfNeeded(int sensor, int userId) {
|
||||
synchronized (mLock) {
|
||||
SparseArray<OnSensorPrivacyChangedListener>
|
||||
userServiceListeners = createUserServiceListenersIfNeededLocked(userId);
|
||||
|
||||
if (!userServiceListeners.contains(sensor)) {
|
||||
OnSensorPrivacyChangedListener listener = (s, enabled) -> {
|
||||
SparseArray<Boolean> userCachedState =
|
||||
createUserCachedStateIfNeededLocked(userId);
|
||||
userCachedState.put(sensor, enabled);
|
||||
dispatchStateChangedLocked(sensor, enabled, userId);
|
||||
};
|
||||
mCurrentUserServiceListeners.put(sensor, listener);
|
||||
mSensorPrivacyManager.addSensorPrivacyListener(sensor, listener);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void dispatchStateChangedLocked(int sensor, boolean blocked, int userId) {
|
||||
for (CallbackInfo callbackInfo : mCallbacks) {
|
||||
if (callbackInfo.mUserId == userId && callbackInfo.mSensor == sensor) {
|
||||
Callback callback = callbackInfo.mCallback;
|
||||
Executor executor = callbackInfo.mExecutor;
|
||||
|
||||
executor.execute(() -> callback.onSensorPrivacyChanged(sensor, blocked));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private SparseArray<Boolean> createUserCachedStateIfNeededLocked(int userId) {
|
||||
SparseArray<Boolean> userCachedState = mCachedState.get(userId);
|
||||
if (userCachedState == null) {
|
||||
userCachedState = new SparseArray<>();
|
||||
mCachedState.put(userId, userCachedState);
|
||||
}
|
||||
return userCachedState;
|
||||
}
|
||||
|
||||
private SparseArray<OnSensorPrivacyChangedListener> createUserServiceListenersIfNeededLocked(
|
||||
int userId) {
|
||||
SparseArray<OnSensorPrivacyChangedListener> userServiceListeners =
|
||||
mServiceListeners.get(userId);
|
||||
if (userServiceListeners == null) {
|
||||
userServiceListeners = new SparseArray<>();
|
||||
mServiceListeners.put(userId, userServiceListeners);
|
||||
}
|
||||
return userServiceListeners;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user