Merge changes Ida69a204,Iad4dbf36,I6749a539,Iab3b9763 (6e9964ef) · Commits · e / os / android_packages_modules_Bluetooth

btaa/Android.bp

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		// libbtaa static library for target
		// ========================================================
		cc_library_static {
		name: "libbtaa",
		defaults: ["fluoride_defaults"],
		include_dirs: [
		"packages/modules/Bluetooth/system",
		"packages/modules/Bluetooth/system/hci/include",
		"packages/modules/Bluetooth/system/stack/include",
		],
		local_include_dirs: [
		"include",
		],
		srcs: [
		"src/activity_attribution.cc",
		],
		static_libs: [
		"libbt-hci",
		],
		shared_libs: [
		"android.system.suspend.control-ndk",
		"libbinder_ndk",
		],
		apex_available: [
		"//apex_available:platform",
		"com.android.bluetooth.updatable",
		],
		}

btaa/include/activity_attribution.h

0 → 100644

+52 −0

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

		#pragma once

		#include <aidl/android/system/suspend/BnSuspendCallback.h>
		#include <aidl/android/system/suspend/BnWakelockCallback.h>
		#include <hardware/bt_activity_attribution.h>

		using aidl::android::system::suspend::BnSuspendCallback;
		using aidl::android::system::suspend::BnWakelockCallback;
		using Status = ::ndk::ScopedAStatus;

		namespace bluetooth {
		namespace activity_attribution {
		class ActivityAttribution {
		public:
		virtual ~ActivityAttribution() = default;

		static void CleanUp();
		static void Initialize(ActivityAttributionCallbacks* callbacks);
		};

		class WakelockCallback : public BnWakelockCallback {
		public:
		Status notifyAcquired(void) override;
		Status notifyReleased(void) override;
		};

		class WakeupCallback : public BnSuspendCallback {
		public:
		Status notifyWakeup(bool success,
		const std::vector<std::string>& wakeupReasons) override;
		};

		} // namespace activity_attribution
		} // namespace bluetooth

btaa/src/activity_attribution.cc

0 → 100644

+123 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright 2020 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 "activity_attribution.h"

		#include <aidl/android/system/suspend/ISuspendControlService.h>
		#include <android/binder_manager.h>
		#include <base/logging.h>

		#include "btsnoop_mem.h"

		using aidl::android::system::suspend::ISuspendCallback;
		using aidl::android::system::suspend::ISuspendControlService;
		using namespace ndk;

		namespace bluetooth {
		namespace activity_attribution {

		static const std::string kBtWakelockName("hal_bluetooth_lock");

		class ActivityAttributionImpl;
		static std::shared_ptr<ISuspendControlService> controlService;
		static std::unique_ptr<ActivityAttributionImpl> instance;

		class ActivityAttributionImpl : public ActivityAttribution {
		public:
		~ActivityAttributionImpl() override = default;
		ActivityAttributionImpl(ActivityAttributionCallbacks* callbacks);

		static void onHciCaptured(const uint16_t type, const uint8_t* data,
		const size_t length, const uint64_t timestamp_us);
		void onWakelockAcquired(void);
		void onWakelockReleased(void);
		void onWakeup(bool success, const std::vector<std::string>& wakeupReasons);

		private:
		[[maybe_unused]] ActivityAttributionCallbacks* mCallbacks;
		};

		ActivityAttributionImpl::ActivityAttributionImpl(
		ActivityAttributionCallbacks* callbacks)
		: mCallbacks(callbacks) {}

		void ActivityAttributionImpl::onHciCaptured(const uint16_t type,
		const uint8_t* data,
		const size_t length,
		const uint64_t timestamp_us) {}

		void ActivityAttributionImpl::onWakelockAcquired(void) {}

		void ActivityAttributionImpl::onWakelockReleased(void) {}

		void ActivityAttributionImpl::onWakeup(
		bool success, const std::vector<std::string>& wakeupReasons) {}

		Status WakelockCallback::notifyAcquired(void) {
		instance->onWakelockAcquired();
		return Status::ok();
		}

		Status WakelockCallback::notifyReleased(void) {
		instance->onWakelockReleased();
		return Status::ok();
		}

		Status WakeupCallback::notifyWakeup(
		bool success, const std::vector<std::string>& wakeupReasons) {
		instance->onWakeup(success, wakeupReasons);
		return Status::ok();
		}

		void ActivityAttribution::CleanUp() { instance.reset(); };

		void ActivityAttribution::Initialize(ActivityAttributionCallbacks* callbacks) {
		bool is_registered = false;

		if (instance) {
		LOG(ERROR) << __func__ << " Already initialized!";
		return;
		}
		instance.reset(new ActivityAttributionImpl(callbacks));

		activity_attribution_set_callback(instance->onHciCaptured);

		controlService = ISuspendControlService::fromBinder(
		SpAIBinder(AServiceManager_getService("suspend_control")));
		if (!controlService) {
		LOG(ERROR) << __func__ << " Fail to obtain suspend_control";
		return;
		}

		Status register_callback_status = controlService->registerCallback(
		SharedRefBase::make<WakeupCallback>(), &is_registered);
		if (!is_registered \|\| !register_callback_status.isOk()) {
		LOG(ERROR) << __func__ << " Fail to register wakeup callback";
		return;
		}

		register_callback_status = controlService->registerWakelockCallback(
		SharedRefBase::make<WakelockCallback>(), kBtWakelockName, &is_registered);
		if (!is_registered \|\| !register_callback_status.isOk()) {
		LOG(ERROR) << __func__ << " Fail to register wakelock callback";
		return;
		}
		}

		} // namespace activity_attribution
		} // namespace bluetooth

system/btif/Android.bp

+8 −6

Original line number	Diff line number	Diff line
		@@ -95,23 +95,25 @@ cc_library_static {
		"libmedia_headers",
		],
		shared_libs: [
		"android.hardware.bluetooth.a2dp@1.0",
		"android.hardware.bluetooth.audio@2.0",
		"android.system.suspend.control-ndk",
		"libaaudio",
		"libcrypto",
		"libcutils",
		"libfmq",
		"libhidlbase",
		"liblog",
		"libz",
		"libtinyxml2",
		"android.hardware.bluetooth.a2dp@1.0",
		"android.hardware.bluetooth.audio@2.0",
		"libhidlbase",
		"libutils",
		"libcrypto",
		"libz",
		],
		whole_static_libs: [
		"avrcp-target-service",
		"libaudio-a2dp-hw-utils",
		"lib-bt-packets",
		"libaudio-a2dp-hw-utils",
		"libbt-audio-hal-interface",
		"libbtaa",
		],
		cflags: [
		"-DBUILDCFG",

system/btif/src/btif_activity_attribution.cc

+5 −1

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@

		#include <hardware/bt_activity_attribution.h>

		#include "btaa/include/activity_attribution.h"
		#include "btif/include/btif_common.h"
		#include "stack/include/btu.h"

		@@ -37,6 +38,7 @@ class ActivityAttributionInterfaceImpl : public ActivityAttributionCallbacks,

		void Init(ActivityAttributionCallbacks* callbacks) override {
		this->callbacks = callbacks;
		ActivityAttribution::Initialize(this);
		}

		void OnWakeup(Activity activity, const RawAddress& address) override {
		@@ -46,7 +48,9 @@ class ActivityAttributionInterfaceImpl : public ActivityAttributionCallbacks,
		Unretained(callbacks), activity, address));
		}

		void Cleanup(void) override {}
		void Cleanup(void) override {
		do_in_main_thread(FROM_HERE, Bind(&ActivityAttribution::CleanUp));
		}

		private:
		ActivityAttributionCallbacks* callbacks;