Block access to sensors when Sensor Privacy Mode enabled (5e1f60ba) · Commits · e / os / platform_frameworks_native

libs/sensorprivacy/Android.bp

0 → 100644

+47 −0

Original line number	Diff line number	Diff line
		// Copyright 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.

		cc_library_shared {
		name: "libsensorprivacy",

		aidl: {
		export_aidl_headers: true,
		local_include_dirs: ["aidl"],
		},

		cflags: [
		"-Wall",
		"-Wextra",
		"-Werror",
		"-Wzero-as-null-pointer-constant",
		],

		srcs: [
		"aidl/android/hardware/ISensorPrivacyListener.aidl",
		"aidl/android/hardware/ISensorPrivacyManager.aidl",
		"SensorPrivacyManager.cpp",
		],

		shared_libs: [
		"libbinder",
		"libcutils",
		"libutils",
		"liblog",
		"libhardware",
		],

		export_include_dirs: ["include"],

		export_shared_lib_headers: ["libbinder"],
		}

libs/sensorprivacy/SensorPrivacyManager.cpp

0 → 100644

+88 −0

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

		#include <mutex>
		#include <unistd.h>

		#include <binder/Binder.h>
		#include <binder/IServiceManager.h>
		#include <sensorprivacy/SensorPrivacyManager.h>

		#include <utils/SystemClock.h>

		namespace android {

		SensorPrivacyManager::SensorPrivacyManager()
		{
		}

		sp<hardware::ISensorPrivacyManager> SensorPrivacyManager::getService()
		{
		std::lock_guard<Mutex> scoped_lock(mLock);
		int64_t startTime = 0;
		sp<hardware::ISensorPrivacyManager> service = mService;
		while (service == nullptr \|\| !IInterface::asBinder(service)->isBinderAlive()) {
		sp<IBinder> binder = defaultServiceManager()->checkService(String16("sensor_privacy"));
		if (binder == nullptr) {
		// Wait for the sensor privacy service to come back...
		if (startTime == 0) {
		startTime = uptimeMillis();
		ALOGI("Waiting for sensor privacy service");
		} else if ((uptimeMillis() - startTime) > 1000000) {
		ALOGW("Waiting too long for sensor privacy service, giving up");
		service = nullptr;
		break;
		}
		usleep(25000);
		} else {
		service = interface_cast<hardware::ISensorPrivacyManager>(binder);
		mService = service;
		}
		}
		return service;
		}

		void SensorPrivacyManager::addSensorPrivacyListener(
		const sp<hardware::ISensorPrivacyListener>& listener)
		{
		sp<hardware::ISensorPrivacyManager> service = getService();
		if (service != nullptr) {
		service->addSensorPrivacyListener(listener);
		}
		}

		void SensorPrivacyManager::removeSensorPrivacyListener(
		const sp<hardware::ISensorPrivacyListener>& listener)
		{
		sp<hardware::ISensorPrivacyManager> service = getService();
		if (service != nullptr) {
		service->removeSensorPrivacyListener(listener);
		}
		}

		bool SensorPrivacyManager::isSensorPrivacyEnabled()
		{
		sp<hardware::ISensorPrivacyManager> service = getService();
		if (service != nullptr) {
		bool result;
		service->isSensorPrivacyEnabled(&result);
		return result;
		}
		// if the SensorPrivacyManager is not available then assume sensor privacy is disabled
		return false;
		}

		}; // namespace android

libs/sensorprivacy/aidl/android/hardware/ISensorPrivacyListener.aidl

0 → 100644

+24 −0

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

		/**
		* @hide
		*/
		oneway interface ISensorPrivacyListener {
		void onSensorPrivacyChanged(boolean enabled);
		}

libs/sensorprivacy/aidl/android/hardware/ISensorPrivacyManager.aidl

0 → 100644

+30 −0

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

		/** @hide */
		interface ISensorPrivacyManager {
		void addSensorPrivacyListener(in ISensorPrivacyListener listener);

		void removeSensorPrivacyListener(in ISensorPrivacyListener listener);

		boolean isSensorPrivacyEnabled();

		void setSensorPrivacy(boolean enable);
		}

libs/sensorprivacy/include/sensorprivacy/SensorPrivacyManager.h

0 → 100644

+47 −0

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

		#ifndef ANDROID_SENSOR_PRIVACY_MANAGER_H
		#define ANDROID_SENSOR_PRIVACY_MANAGER_H

		#include "android/hardware/ISensorPrivacyListener.h"
		#include "android/hardware/ISensorPrivacyManager.h"

		#include <utils/threads.h>

		// ---------------------------------------------------------------------------
		namespace android {

		class SensorPrivacyManager
		{
		public:
		SensorPrivacyManager();

		void addSensorPrivacyListener(const sp<hardware::ISensorPrivacyListener>& listener);
		void removeSensorPrivacyListener(const sp<hardware::ISensorPrivacyListener>& listener);
		bool isSensorPrivacyEnabled();

		private:
		Mutex mLock;
		sp<hardware::ISensorPrivacyManager> mService;
		sp<hardware::ISensorPrivacyManager> getService();
		};


		}; // namespace android
		// ---------------------------------------------------------------------------

		#endif // ANDROID_SENSOR_PRIVACY_MANAGER_H