Merge "Add SensorPrivacyManagerInternal api for system server usage" into sc-dev (706c23e6) · Commits · e / os / android_frameworks_base

core/java/android/hardware/SensorPrivacyManagerInternal.java

0 → 100644

+64 −0

Original line number	Diff line number	Diff line
		/*
		* 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 android.hardware;

		/**
		* SensorPrivacyManager calls for within the system server
		* @hide
		*/
		public abstract class SensorPrivacyManagerInternal {

		/**
		* A class implementing this interface can register to receive a callback when state changes.
		*/
		public interface OnSensorPrivacyChangedListener {
		/**
		* The callback invoked when the state changes.
		*/
		void onSensorPrivacyChanged(boolean enabled);
		}

		/**
		* A class implementing this interface can register to receive a callback when state changes for
		* any user.
		*/
		public interface OnUserSensorPrivacyChangedListener {
		/**
		* The callback invoked when the state changes.
		*/
		void onSensorPrivacyChanged(int userId, boolean enabled);
		}

		/**
		* Get the individual sensor privacy state for a given user.
		*/
		public abstract boolean isSensorPrivacyEnabled(int userId, int sensor);

		/**
		* Registers a new listener to receive notification when the state of sensor privacy
		* changes.
		*/
		public abstract void addSensorPrivacyListener(int userId, int sensor,
		OnSensorPrivacyChangedListener listener);

		/**
		* Registers a new listener to receive notification when the state of sensor privacy
		* changes for any user.
		*/
		public abstract void addSensorPrivacyListenerForAllUsers(int sensor,
		OnUserSensorPrivacyChangedListener listener);
		}

services/core/java/com/android/server/SensorPrivacyService.java

+92 −0

Original line number	Diff line number	Diff line
		@@ -51,6 +51,7 @@ import android.graphics.drawable.Icon;
		import android.hardware.ISensorPrivacyListener;
		import android.hardware.ISensorPrivacyManager;
		import android.hardware.SensorPrivacyManager;
		import android.hardware.SensorPrivacyManagerInternal;
		import android.os.Binder;
		import android.os.Environment;
		import android.os.Handler;
		@@ -67,6 +68,7 @@ import android.service.SensorPrivacyServiceDumpProto;
		import android.service.SensorPrivacyUserProto;
		import android.text.Html;
		import android.util.ArrayMap;
		import android.util.ArraySet;
		import android.util.AtomicFile;
		import android.util.IndentingPrintWriter;
		import android.util.Log;
		@@ -80,6 +82,7 @@ import android.util.proto.ProtoOutputStream;

		import com.android.internal.R;
		import com.android.internal.annotations.GuardedBy;
		import com.android.internal.os.BackgroundThread;
		import com.android.internal.util.DumpUtils;
		import com.android.internal.util.FunctionalUtils;
		import com.android.internal.util.XmlUtils;
		@@ -137,6 +140,8 @@ public final class SensorPrivacyService extends SystemService {
		private final ActivityManager mActivityManager;
		private final ActivityTaskManager mActivityTaskManager;

		private SensorPrivacyManagerInternalImpl mSensorPrivacyManagerInternal;

		public SensorPrivacyService(Context context) {
		super(context);
		mUserManagerInternal = getLocalService(UserManagerInternal.class);
		@@ -148,6 +153,9 @@ public final class SensorPrivacyService extends SystemService {
		@Override
		public void onStart() {
		publishBinderService(Context.SENSOR_PRIVACY_SERVICE, mSensorPrivacyServiceImpl);
		mSensorPrivacyManagerInternal = new SensorPrivacyManagerInternalImpl();
		publishLocalService(SensorPrivacyManagerInternal.class,
		mSensorPrivacyManagerInternal);
		}

		class SensorPrivacyServiceImpl extends ISensorPrivacyManager.Stub implements
		@@ -1108,6 +1116,7 @@ public final class SensorPrivacyService extends SystemService {
		}

		public void handleSensorPrivacyChanged(int userId, int sensor, boolean enabled) {
		mSensorPrivacyManagerInternal.dispatch(userId, sensor, enabled);
		SparseArray<RemoteCallbackList<ISensorPrivacyListener>> listenersForUser =
		mIndividualSensorListeners.get(userId);
		if (listenersForUser == null) {
		@@ -1168,4 +1177,87 @@ public final class SensorPrivacyService extends SystemService {
		c.accept(userIds[i]);
		}
		}

		private class SensorPrivacyManagerInternalImpl extends SensorPrivacyManagerInternal {

		private ArrayMap<Integer, ArrayMap<Integer, ArraySet<OnSensorPrivacyChangedListener>>>
		mListeners = new ArrayMap<>();
		private ArrayMap<Integer, ArraySet<OnUserSensorPrivacyChangedListener>> mAllUserListeners =
		new ArrayMap<>();

		private final Object mLock = new Object();

		private void dispatch(int userId, int sensor, boolean enabled) {
		synchronized (mLock) {
		ArraySet<OnUserSensorPrivacyChangedListener> allUserSensorListeners =
		mAllUserListeners.get(sensor);
		if (allUserSensorListeners != null) {
		for (int i = 0; i < allUserSensorListeners.size(); i++) {
		OnUserSensorPrivacyChangedListener listener =
		allUserSensorListeners.valueAt(i);
		BackgroundThread.getHandler().post(() ->
		listener.onSensorPrivacyChanged(userId, enabled));
		}
		}

		ArrayMap<Integer, ArraySet<OnSensorPrivacyChangedListener>> userSensorListeners =
		mListeners.get(userId);
		if (userSensorListeners != null) {
		ArraySet<OnSensorPrivacyChangedListener> sensorListeners =
		userSensorListeners.get(sensor);
		if (sensorListeners != null) {
		for (int i = 0; i < sensorListeners.size(); i++) {
		OnSensorPrivacyChangedListener listener = sensorListeners.valueAt(i);
		BackgroundThread.getHandler().post(() ->
		listener.onSensorPrivacyChanged(enabled));
		}
		}
		}
		}
		}

		@Override
		public boolean isSensorPrivacyEnabled(int userId, int sensor) {
		return SensorPrivacyService.this
		.mSensorPrivacyServiceImpl.isIndividualSensorPrivacyEnabled(userId, sensor);
		}

		@Override
		public void addSensorPrivacyListener(int userId, int sensor,
		OnSensorPrivacyChangedListener listener) {
		synchronized (mLock) {
		ArrayMap<Integer, ArraySet<OnSensorPrivacyChangedListener>> userSensorListeners =
		mListeners.get(userId);
		if (userSensorListeners == null) {
		userSensorListeners = new ArrayMap<>();
		mListeners.put(userId, userSensorListeners);
		}

		ArraySet<OnSensorPrivacyChangedListener> sensorListeners =
		userSensorListeners.get(sensor);
		if (sensorListeners == null) {
		sensorListeners = new ArraySet<>();
		userSensorListeners.put(sensor, sensorListeners);
		}

		sensorListeners.add(listener);
		}
		}

		@Override
		public void addSensorPrivacyListenerForAllUsers(int sensor,
		OnUserSensorPrivacyChangedListener listener) {
		synchronized (mLock) {
		ArraySet<OnUserSensorPrivacyChangedListener> sensorListeners =
		mAllUserListeners.get(sensor);
		if (sensorListeners == null) {
		sensorListeners = new ArraySet<>();
		mAllUserListeners.put(sensor, sensorListeners);
		}

		sensorListeners.add(listener);
		}
		}
		}

		}