activityAttribution: Remove dead code (e0524ffd) · Commits · e / os / android_packages_modules_Bluetooth

android/app/jni/com_android_bluetooth_btservice_ActivityAttribution.cpp

+0 −131

Original line number	Diff line number	Diff line
		@@ -24,138 +24,10 @@
		#include "com_android_bluetooth.h"
		#include "hardware/bt_activity_attribution.h"

		using bluetooth::activity_attribution::ActivityAttributionCallbacks;
		using bluetooth::activity_attribution::ActivityAttributionInterface;

		namespace android {
		static jmethodID method_onWakeup;
		static jmethodID method_onActivityLogsReady;

		static ActivityAttributionInterface* sActivityAttributionInterface = nullptr;
		static std::shared_timed_mutex interface_mutex;

		static jobject mCallbacksObj = nullptr;
		static std::shared_timed_mutex callbacks_mutex;

		class ActivityAttributionCallbacksImpl : public ActivityAttributionCallbacks {
		public:
		~ActivityAttributionCallbacksImpl() = default;

		void OnWakeup(const Activity activity, const RawAddress& bd_addr) override {
		LOG(INFO) << __func__;

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) return;

		ScopedLocalRef<jbyteArray> addr(
		sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
		if (!addr.get()) {
		LOG(ERROR)
		<< "Failed to allocate jbyteArray for bd_addr of wakeup callback";
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
		(jbyte*)&bd_addr);
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onWakeup, (jint)activity,
		addr.get());
		}

		void OnActivityLogsReady(
		const std::vector<BtaaAggregationEntry> logs) override {
		LOG(INFO) << __func__;

		std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
		CallbackEnv sCallbackEnv(__func__);
		if (!sCallbackEnv.valid() \|\| mCallbacksObj == nullptr) return;

		jsize logs_size = logs.size() * sizeof(BtaaAggregationEntry);
		ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(),
		sCallbackEnv->NewByteArray(logs_size));
		if (!addr.get()) {
		LOG(ERROR) << "Failed to allocate jbyteArray for logs from activity "
		"logging callback";
		return;
		}

		sCallbackEnv->SetByteArrayRegion(addr.get(), 0, logs_size,
		(jbyte*)logs.data());
		sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onActivityLogsReady,
		addr.get());
		}
		};

		static ActivityAttributionCallbacksImpl sActivityAttributionCallbacks;

		static void classInitNative(JNIEnv* env, jclass clazz) {
		method_onWakeup = env->GetMethodID(clazz, "onWakeup", "(I[B)V");
		method_onActivityLogsReady =
		env->GetMethodID(clazz, "onActivityLogsReady", "([B)V");

		LOG(INFO) << __func__ << ": succeeds";
		}

		static void initNative(JNIEnv* env, jobject object) {
		std::unique_lock<std::shared_timed_mutex> interface_lock(interface_mutex);
		std::unique_lock<std::shared_timed_mutex> callbacks_lock(callbacks_mutex);
		const bt_interface_t* btInf = getBluetoothInterface();
		if (btInf == nullptr) {
		LOG(ERROR) << "Bluetooth module is not loaded";
		return;
		}

		if (sActivityAttributionInterface != nullptr) {
		LOG(INFO)
		<< "Cleaning up ActivityAttribution Interface before initializing...";
		sActivityAttributionInterface->Cleanup();
		sActivityAttributionInterface = nullptr;
		}

		if (mCallbacksObj != nullptr) {
		LOG(INFO) << "Cleaning up ActivityAttribution callback object";
		env->DeleteGlobalRef(mCallbacksObj);
		mCallbacksObj = nullptr;
		}

		if ((mCallbacksObj = env->NewGlobalRef(object)) == nullptr) {
		LOG(ERROR)
		<< "Failed to allocate Global Ref for ActivityAttribution Callbacks";
		return;
		}

		sActivityAttributionInterface =
		(ActivityAttributionInterface*)btInf->get_profile_interface(
		BT_ACTIVITY_ATTRIBUTION_ID);
		if (sActivityAttributionInterface == nullptr) {
		LOG(ERROR) << "Failed to get ActivityAttribution Interface";
		return;
		}

		sActivityAttributionInterface->RegisterCallbacks(
		&sActivityAttributionCallbacks);
		}

		static void cleanupNative(JNIEnv* env, jobject object) {
		std::unique_lock<std::shared_timed_mutex> interface_lock(interface_mutex);
		std::unique_lock<std::shared_timed_mutex> callbacks_lock(callbacks_mutex);

		const bt_interface_t* btInf = getBluetoothInterface();
		if (btInf == nullptr) {
		LOG(ERROR) << "Bluetooth module is not loaded";
		return;
		}

		if (sActivityAttributionInterface != nullptr) {
		sActivityAttributionInterface->Cleanup();
		sActivityAttributionInterface = nullptr;
		}

		if (mCallbacksObj != nullptr) {
		env->DeleteGlobalRef(mCallbacksObj);
		mCallbacksObj = nullptr;
		}
		}

		static void notifyActivityAttributionInfoNative(JNIEnv* env, jobject object,
		jint uid, jstring packageName,
		@@ -186,9 +58,6 @@ static void notifyActivityAttributionInfoNative(JNIEnv* env, jobject object,
		}

		static JNINativeMethod sMethods[] = {
		{"classInitNative", "()V", (void*)classInitNative},
		{"initNative", "()V", (void*)initNative},
		{"cleanupNative", "()V", (void*)cleanupNative},
		{"notifyActivityAttributionInfoNative",
		"(ILjava/lang/String;Ljava/lang/String;)V",
		(void*)notifyActivityAttributionInfoNative},

android/app/src/com/android/bluetooth/btservice/AdapterService.java

+0 −4

Original line number	Diff line number	Diff line
		@@ -1359,10 +1359,6 @@ public class AdapterService extends Service {
		mSdpManager = null;
		}

		if (mActivityAttributionService != null) {
		mActivityAttributionService.cleanup();
		}

		if (mNativeAvailable) {
		debugLog("cleanup() - Cleaning up adapter native");
		cleanupNative();

android/app/src/com/android/bluetooth/btservice/activityAttribution/ActivityAttributionNativeInterface.java

+1 −41

Original line number	Diff line number	Diff line
		@@ -21,26 +21,15 @@
		*/
		package com.android.bluetooth.btservice.activityattribution;

		import android.util.Log;

		import com.android.internal.annotations.GuardedBy;

		import java.util.Arrays;

		/** ActivityAttribution Native Interface to/from JNI. */
		public class ActivityAttributionNativeInterface {
		private static final boolean DBG = false;
		private static final String TAG = "ActivityAttributionNativeInterface";

		@GuardedBy("INSTANCE_LOCK")
		private static ActivityAttributionNativeInterface sInstance;

		private static final Object INSTANCE_LOCK = new Object();

		static {
		classInitNative();
		}

		/** Get singleton instance. */
		public static ActivityAttributionNativeInterface getInstance() {
		synchronized (INSTANCE_LOCK) {
		@@ -51,40 +40,11 @@ public class ActivityAttributionNativeInterface {
		}
		}

		/** Initializes the native interface. */
		public void init() {
		initNative();
		}

		/** Cleanup the native interface. */
		public void cleanup() {
		cleanupNative();
		}

		/** Notify the UID and package name of the app, and the address of associated active device */
		public void notifyActivityAttributionInfo(int uid, String packageName, String deviceAddress) {
		notifyActivityAttributionInfoNative(uid, packageName, deviceAddress);
		}

		// Callbacks from the native stack back into the Java framework.
		// All callbacks are routed via the Service which will disambiguate which
		// state machine the message should be routed to.

		private void onWakeup(int activity, byte[] address) {
		Log.i(TAG, "onWakeup() BTAA: " + activity);
		}

		private void onActivityLogsReady(byte[] logs) {
		Log.i(TAG, "onActivityLogsReady() BTAA: " + Arrays.toString(logs));
		}

		// Native methods that call into the JNI interface
		private static native void classInitNative();

		private native void initNative();

		private native void cleanupNative();

		private native void notifyActivityAttributionInfoNative(
		int uid, String packageName, String deviceAddress);
		}

android/app/src/com/android/bluetooth/btservice/activityAttribution/ActivityAttributionService.java

+4 −34

Original line number	Diff line number	Diff line
		@@ -16,46 +16,22 @@

		package com.android.bluetooth.btservice.activityattribution;

		import android.util.Log;
		import static java.util.Objects.requireNonNull;

		import java.util.Objects;
		import android.util.Log;

		/**
		* Service used for attributes wakeup, wakelock and Bluetooth traffic into per-app and per-device
		* based activities.
		*/
		public class ActivityAttributionService {
		private static final String TAG = ActivityAttributionService.class.getSimpleName()
		private static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
		private static final String TAG = ActivityAttributionService.class.getSimpleName();

		private final ActivityAttributionNativeInterface mActivityAttributionNativeInterface =
		Objects.requireNonNull(
		requireNonNull(
		ActivityAttributionNativeInterface.getInstance(),
		"ActivityAttributionNativeInterface cannot be null");

		private boolean mCleaned = false;

		/** Cleans up the Activity Attribution service. */
		public void cleanup() {
		debugLog("cleanup()");
		if (mCleaned) {
		Log.e(TAG, "cleanup already called");
		return;
		}

		mCleaned = true;

		// Cleanup native interface
		mActivityAttributionNativeInterface.cleanup();
		}

		/** Init JNI */
		public void initJni() {
		debugLog("initJni()");
		// Initialize native interface
		mActivityAttributionNativeInterface.init();
		}

		/** Notify the UID and package name of the app, and the address of associated active device */
		public void notifyActivityAttributionInfo(int uid, String packageName, String deviceAddress) {
		Log.d(
		@@ -67,10 +43,4 @@ public class ActivityAttributionService {
		mActivityAttributionNativeInterface.notifyActivityAttributionInfo(
		uid, packageName, deviceAddress);
		}

		private static void debugLog(String msg) {
		if (DBG) {
		Log.d(TAG, msg);
		}
		}
		}

android/app/tests/unit/src/com/android/bluetooth/btservice/activityAttribution/ActivityAttributionServiceTest.java

+0 −10

Original line number	Diff line number	Diff line
		@@ -19,7 +19,6 @@ package com.android.bluetooth.btservice.activityattribution;
		import android.os.Binder;
		import android.os.Process;

		import org.junit.After;
		import org.junit.Assume;
		import org.junit.Before;
		import org.junit.Test;
		@@ -28,7 +27,6 @@ import org.junit.runners.JUnit4;

		@RunWith(JUnit4.class)
		public final class ActivityAttributionServiceTest {
		private static final String TAG = "ActivityAttributionServiceTest";
		private ActivityAttributionService mActivityAttributionService;

		@Before
		@@ -37,14 +35,6 @@ public final class ActivityAttributionServiceTest {
		mActivityAttributionService = new ActivityAttributionService();
		}

		@After
		public void tearDown() {
		if (!isPrimaryUser()) {
		return;
		}
		mActivityAttributionService.cleanup();
		}

		private boolean isPrimaryUser() {
		return Binder.getCallingUid() == Process.BLUETOOTH_UID;
		}