Merge SPL-2020-06-05
Change-Id: I0c7733480be835bb9aea89bda3eb69a53057cb7d
diff --git a/Android.mk b/Android.mk
index 1f73091..bbc354d 100644
--- a/Android.mk
+++ b/Android.mk
@@ -12,12 +12,18 @@
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS := optional
-LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SRC_FILES := \
+ $(call all-java-files-under, src) \
+ $(call all-java-files-under, ../../../vendor/qcom/opensource/bluetooth_ext/packages_apps_bluetooth_ext/src) \
+ $(call all-java-files-under, ../../../vendor/qcom/opensource/commonsys/bluetooth_ext/packages_apps_bluetooth_ext/src)
+
LOCAL_PACKAGE_NAME := Bluetooth
LOCAL_PRIVATE_PLATFORM_APIS := true
LOCAL_CERTIFICATE := platform
LOCAL_USE_AAPT2 := true
LOCAL_JNI_SHARED_LIBRARIES := libbluetooth_jni
+
LOCAL_JAVA_LIBRARIES := javax.obex telephony-common services.net
LOCAL_STATIC_JAVA_LIBRARIES := \
com.android.vcard \
@@ -51,6 +57,9 @@
LOCAL_ANNOTATION_PROCESSOR_CLASSES := \
androidx.room.RoomProcessor
+LOCAL_STATIC_JAVA_LIBRARIES += com.android.emailcommon
+LOCAL_PROTOC_OPTIMIZE_TYPE := micro
+
LOCAL_REQUIRED_MODULES := libbluetooth
LOCAL_PROGUARD_ENABLED := disabled
include $(BUILD_PACKAGE)
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 6de6114..3049b8b 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -20,10 +20,12 @@
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
<uses-permission android:name="android.permission.ACCESS_BLUETOOTH_SHARE" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+ <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
<uses-permission android:name="android.permission.BLUETOOTH_PRIVILEGED" />
+ <uses-permission android:name="android.permission.LOCAL_MAC_ADDRESS" />
<uses-permission android:name="android.permission.BLUETOOTH_MAP" />
<uses-permission android:name="android.permission.DUMP" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
@@ -58,7 +60,6 @@
<uses-permission android:name="android.permission.SEND_SMS" />
<uses-permission android:name="android.permission.READ_SMS" />
<uses-permission android:name="android.permission.WRITE_SMS" />
- <uses-permission android:name="android.permission.READ_CONTACTS" />
<uses-permission android:name="android.permission.MEDIA_CONTENT_CONTROL" />
<uses-permission android:name="android.permission.UPDATE_APP_OPS_STATS" />
<uses-permission android:name="android.permission.MANAGE_APP_OPS_MODES" />
@@ -68,6 +69,16 @@
<uses-permission android:name="android.permission.MODIFY_AUDIO_ROUTING" />
<uses-permission android:name="android.permission.UPDATE_DEVICE_STATS" />
<uses-permission android:name="android.permission.PACKAGE_USAGE_STATS" />
+ <uses-permission android:name="com.android.email.permission.ACCESS_PROVIDER"/>
+ <uses-permission android:name="com.android.email.permission.READ_ATTACHMENT"/>
+ <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+ <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
+ <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
+ <uses-permission android:name="android.permission.INTERNET" />
+ <uses-permission android:name="android.permission.OVERRIDE_WIFI_CONFIG" />
+
+ <!-- Allows application to write to internal media storage -->
+ <uses-permission android:name="android.permission.WRITE_MEDIA_STORAGE" />
<uses-sdk android:minSdkVersion="14"/>
@@ -348,6 +359,14 @@
</service>
<service
android:process="@string/process"
+ android:name = ".ba.BATService"
+ android:enabled="@bool/profile_supported_ba">
+ <intent-filter>
+ <action android:name="android.bluetooth.IBluetoothBATransmitter" />
+ </intent-filter>
+ </service>
+ <service
+ android:process="@string/process"
android:name = ".hid.HidHostService"
android:enabled="@bool/profile_supported_hid_host">
<intent-filter>
diff --git a/jni/Android.bp b/jni/Android.bp
index 1262469..52f653a 100644
--- a/jni/Android.bp
+++ b/jni/Android.bp
@@ -8,6 +8,7 @@
"com_android_bluetooth_hfpclient.cpp",
"com_android_bluetooth_a2dp.cpp",
"com_android_bluetooth_a2dp_sink.cpp",
+ "com_android_bluetooth_avrcp.cpp",
"com_android_bluetooth_avrcp_controller.cpp",
"com_android_bluetooth_avrcp_target.cpp",
"com_android_bluetooth_hid_host.cpp",
@@ -23,6 +24,7 @@
include_dirs: [
"libnativehelper/include/nativehelper",
"system/bt/types",
+ "vendor/qcom/opensource/commonsys/bluetooth_ext/vhal/include",
],
shared_libs: [
"libandroid_runtime",
@@ -36,6 +38,7 @@
static_libs: [
"libbluetooth-types",
"libcutils",
+ "libbluetoothqti_jni",
],
cflags: [
"-Wall",
diff --git a/jni/com_android_bluetooth.h b/jni/com_android_bluetooth.h
index 2076779..f20f1f3 100644
--- a/jni/com_android_bluetooth.h
+++ b/jni/com_android_bluetooth.h
@@ -154,7 +154,17 @@
int register_com_android_bluetooth_sdp (JNIEnv* env);
+int register_com_android_bluetooth_btservice_vendor (JNIEnv* env);
+
+int register_com_android_bluetooth_btservice_vendor_socket(JNIEnv* env);
+
int register_com_android_bluetooth_hearing_aid(JNIEnv* env);
+
+int register_com_android_bluetooth_avrcp_ext(JNIEnv* env);
+
+int register_com_android_bluetooth_ba(JNIEnv* env);
+
+int register_com_android_bluetooth_hfp_vendorhfservice(JNIEnv* env);
}
#endif /* COM_ANDROID_BLUETOOTH_H */
diff --git a/jni/com_android_bluetooth_a2dp.cpp b/jni/com_android_bluetooth_a2dp.cpp
index af125bd..709d31d 100644
--- a/jni/com_android_bluetooth_a2dp.cpp
+++ b/jni/com_android_bluetooth_a2dp.cpp
@@ -260,7 +260,8 @@
static void initNative(JNIEnv* env, jobject object,
jint maxConnectedAudioDevices,
- jobjectArray codecConfigArray) {
+ jobjectArray codecConfigArray,
+ jobjectArray codecConfigOffload) {
std::unique_lock<std::shared_timed_mutex> interface_lock(interface_mutex);
std::unique_lock<std::shared_timed_mutex> callbacks_lock(callbacks_mutex);
@@ -306,8 +307,10 @@
std::vector<btav_a2dp_codec_config_t> codec_priorities =
prepareCodecPreferences(env, object, codecConfigArray);
+ std::vector<btav_a2dp_codec_config_t> offload_codec_supported =
+ prepareCodecPreferences(env, object, codecConfigOffload);
bt_status_t status = sBluetoothA2dpInterface->init(
- &sBluetoothA2dpCallbacks, maxConnectedAudioDevices, codec_priorities);
+ &sBluetoothA2dpCallbacks, maxConnectedAudioDevices, codec_priorities, offload_codec_supported);
if (status != BT_STATUS_SUCCESS) {
ALOGE("%s: Failed to initialize Bluetooth A2DP, status: %d", __func__,
status);
@@ -432,9 +435,6 @@
if (addr) {
bd_addr.FromOctets(reinterpret_cast<const uint8_t*>(addr));
}
- if (bd_addr == RawAddress::kEmpty) {
- return JNI_FALSE;
- }
bt_status_t status = sBluetoothA2dpInterface->set_active_device(bd_addr);
if (status != BT_STATUS_SUCCESS) {
ALOGE("%s: Failed A2DP set_active_device, status: %d", __func__, status);
@@ -475,7 +475,7 @@
static JNINativeMethod sMethods[] = {
{"classInitNative", "()V", (void*)classInitNative},
- {"initNative", "(I[Landroid/bluetooth/BluetoothCodecConfig;)V",
+ {"initNative", "(I[Landroid/bluetooth/BluetoothCodecConfig;[Landroid/bluetooth/BluetoothCodecConfig;)V",
(void*)initNative},
{"cleanupNative", "()V", (void*)cleanupNative},
{"connectA2dpNative", "([B)Z", (void*)connectA2dpNative},
diff --git a/jni/com_android_bluetooth_avrcp.cpp b/jni/com_android_bluetooth_avrcp.cpp
new file mode 100644
index 0000000..fc72517
--- /dev/null
+++ b/jni/com_android_bluetooth_avrcp.cpp
@@ -0,0 +1,1554 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+#define LOG_TAG "BluetoothAvrcpServiceJni"
+
+#define LOG_NDEBUG 0
+
+#include "android_runtime/AndroidRuntime.h"
+#include "com_android_bluetooth.h"
+#include "hardware/bt_rc.h"
+#include "utils/Log.h"
+
+#include <inttypes.h>
+#include <string.h>
+#include <mutex>
+#include <shared_mutex>
+
+namespace android {
+static jmethodID method_getRcFeatures;
+static jmethodID method_getPlayStatus;
+static jmethodID method_getElementAttr;
+static jmethodID method_registerNotification;
+static jmethodID method_volumeChangeCallback;
+static jmethodID method_handlePassthroughCmd;
+static jmethodID method_getFolderItemsCallback;
+static jmethodID method_setAddressedPlayerCallback;
+
+static jmethodID method_setBrowsedPlayerCallback;
+static jmethodID method_changePathCallback;
+static jmethodID method_searchCallback;
+static jmethodID method_playItemCallback;
+static jmethodID method_getItemAttrCallback;
+static jmethodID method_addToPlayListCallback;
+static jmethodID method_getTotalNumOfItemsCallback;
+
+static const btrc_interface_t* sBluetoothAvrcpInterface = NULL;
+static jobject mCallbacksObj = NULL;
+static std::shared_timed_mutex callbacks_mutex;
+
+/* Function declarations */
+static bool copy_item_attributes(JNIEnv* env, jobject object,
+ btrc_folder_items_t* pitem,
+ jint* p_attributesIds,
+ jobjectArray attributesArray, int item_idx,
+ int attribCopiedIndex);
+
+static bool copy_jstring(uint8_t* str, int maxBytes, jstring jstr, JNIEnv* env);
+
+static void cleanup_items(btrc_folder_items_t* p_items, int numItems);
+
+static void btavrcp_remote_features_callback(const RawAddress& bd_addr,
+ btrc_remote_features_t features) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Unable to allocate byte array for bd_addr");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getRcFeatures, addr.get(),
+ (jint)features);
+}
+
+/** Callback for play status request */
+static void btavrcp_get_play_status_callback(const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for get_play_status command");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getPlayStatus, addr.get());
+}
+
+static void btavrcp_get_element_attr_callback(uint8_t num_attr,
+ btrc_media_attr_t* p_attrs,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for get_element_attr command");
+ return;
+ }
+
+ ScopedLocalRef<jintArray> attrs(
+ sCallbackEnv.get(), (jintArray)sCallbackEnv->NewIntArray(num_attr));
+ if (!attrs.get()) {
+ ALOGE("Fail to new jintArray for attrs");
+ return;
+ }
+
+ sCallbackEnv->SetIntArrayRegion(attrs.get(), 0, num_attr, (jint*)p_attrs);
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getElementAttr, addr.get(),
+ (jbyte)num_attr, attrs.get());
+}
+
+static void btavrcp_register_notification_callback(btrc_event_id_t event_id,
+ uint32_t param,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for register_notification command");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_registerNotification,
+ addr.get(), (jint)event_id, (jint)param);
+}
+
+static void btavrcp_volume_change_callback(uint8_t volume, uint8_t ctype,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for volume_change command");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_volumeChangeCallback,
+ addr.get(), (jint)volume, (jint)ctype);
+}
+
+static void btavrcp_passthrough_command_callback(int id, int pressed,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for passthrough_command command");
+ return;
+ }
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_handlePassthroughCmd,
+ addr.get(), (jint)id, (jint)pressed);
+}
+
+static void btavrcp_set_addressed_player_callback(uint16_t player_id,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for set_addressed_player command");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_setAddressedPlayerCallback,
+ addr.get(), (jint)player_id);
+}
+
+static void btavrcp_set_browsed_player_callback(uint16_t player_id,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for set_browsed_player command");
+ return;
+ }
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_setBrowsedPlayerCallback,
+ addr.get(), (jint)player_id);
+}
+
+static void btavrcp_get_folder_items_callback(
+ uint8_t scope, uint32_t start_item, uint32_t end_item, uint8_t num_attr,
+ uint32_t* p_attr_ids, const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for get_folder_items command");
+ return;
+ }
+
+ uint32_t* puiAttr = (uint32_t*)p_attr_ids;
+ ScopedLocalRef<jintArray> attr_ids(sCallbackEnv.get(), NULL);
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+
+ /* check number of attributes requested by remote device */
+ if ((num_attr != BTRC_NUM_ATTR_ALL) && (num_attr != BTRC_NUM_ATTR_NONE)) {
+ /* allocate memory for attr_ids only if some attributes passed from below
+ * layer */
+ attr_ids.reset((jintArray)sCallbackEnv->NewIntArray(num_attr));
+ if (!attr_ids.get()) {
+ ALOGE("Fail to allocate new jintArray for attrs");
+ return;
+ }
+ sCallbackEnv->SetIntArrayRegion(attr_ids.get(), 0, num_attr,
+ (jint*)puiAttr);
+ }
+
+ sCallbackEnv->CallVoidMethod(
+ mCallbacksObj, method_getFolderItemsCallback, addr.get(), (jbyte)scope,
+ (jlong)start_item, (jlong)end_item, (jbyte)num_attr, attr_ids.get());
+}
+
+static void btavrcp_change_path_callback(uint8_t direction, uint8_t* folder_uid,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> attrs(sCallbackEnv.get(),
+ sCallbackEnv->NewByteArray(BTRC_UID_SIZE));
+ if (!attrs.get()) {
+ ALOGE("Fail to new jintArray for attrs");
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for change_path command");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->SetByteArrayRegion(
+ attrs.get(), 0, sizeof(uint8_t) * BTRC_UID_SIZE, (jbyte*)folder_uid);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_changePathCallback,
+ addr.get(), (jbyte)direction, attrs.get());
+}
+
+static void btavrcp_get_item_attr_callback(uint8_t scope, uint8_t* uid,
+ uint16_t uid_counter,
+ uint8_t num_attr,
+ btrc_media_attr_t* p_attrs,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> attr_uid(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(BTRC_UID_SIZE));
+ if (!attr_uid.get()) {
+ ALOGE("Fail to new jintArray for attr_uid");
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for get_item_attr command");
+ return;
+ }
+
+ ScopedLocalRef<jintArray> attrs(
+ sCallbackEnv.get(), (jintArray)sCallbackEnv->NewIntArray(num_attr));
+ if (!attrs.get()) {
+ ALOGE("Fail to new jintArray for attrs");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->SetIntArrayRegion(attrs.get(), 0, num_attr, (jint*)p_attrs);
+ sCallbackEnv->SetByteArrayRegion(
+ attr_uid.get(), 0, sizeof(uint8_t) * BTRC_UID_SIZE, (jbyte*)uid);
+
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getItemAttrCallback,
+ addr.get(), (jbyte)scope, attr_uid.get(),
+ (jint)uid_counter, (jbyte)num_attr, attrs.get());
+}
+
+static void btavrcp_play_item_callback(uint8_t scope, uint16_t uid_counter,
+ uint8_t* uid,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> attrs(sCallbackEnv.get(),
+ sCallbackEnv->NewByteArray(BTRC_UID_SIZE));
+ if (!attrs.get()) {
+ ALOGE("%s: Fail to new jByteArray attrs for play_item command", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for play_item command");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->SetByteArrayRegion(
+ attrs.get(), 0, sizeof(uint8_t) * BTRC_UID_SIZE, (jbyte*)uid);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_playItemCallback,
+ addr.get(), (jbyte)scope, (jint)uid_counter,
+ attrs.get());
+}
+
+static void btavrcp_get_total_num_items_callback(uint8_t scope,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for get_total_num_items command");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_getTotalNumOfItemsCallback,
+ addr.get(), (jbyte)scope);
+}
+
+static void btavrcp_search_callback(uint16_t charset_id, uint16_t str_len,
+ uint8_t* p_str, const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> attrs(sCallbackEnv.get(),
+ sCallbackEnv->NewByteArray(str_len));
+ if (!attrs.get()) {
+ ALOGE("Fail to new jintArray for attrs");
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for search command");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->SetByteArrayRegion(attrs.get(), 0, str_len * sizeof(uint8_t),
+ (jbyte*)p_str);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_searchCallback, addr.get(),
+ (jint)charset_id, attrs.get());
+}
+
+static void btavrcp_add_to_play_list_callback(uint8_t scope, uint8_t* uid,
+ uint16_t uid_counter,
+ const RawAddress& bd_addr) {
+ CallbackEnv sCallbackEnv(__func__);
+ std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("%s: mCallbacksObj is null", __func__);
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr for add_to_play_list command");
+ return;
+ }
+
+ ScopedLocalRef<jbyteArray> attrs(sCallbackEnv.get(),
+ sCallbackEnv->NewByteArray(BTRC_UID_SIZE));
+ if (!attrs.get()) {
+ ALOGE("Fail to new jByteArray for attrs");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr.address);
+ sCallbackEnv->SetByteArrayRegion(
+ attrs.get(), 0, sizeof(uint8_t) * BTRC_UID_SIZE, (jbyte*)uid);
+ sCallbackEnv->CallVoidMethod(mCallbacksObj, method_addToPlayListCallback,
+ addr.get(), (jbyte)scope, attrs.get(),
+ (jint)uid_counter);
+}
+
+static btrc_callbacks_t sBluetoothAvrcpCallbacks = {
+ sizeof(sBluetoothAvrcpCallbacks),
+ btavrcp_remote_features_callback,
+ btavrcp_get_play_status_callback,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ btavrcp_get_element_attr_callback,
+ btavrcp_register_notification_callback,
+ btavrcp_volume_change_callback,
+ btavrcp_passthrough_command_callback,
+ btavrcp_set_addressed_player_callback,
+ btavrcp_set_browsed_player_callback,
+ btavrcp_get_folder_items_callback,
+ btavrcp_change_path_callback,
+ btavrcp_get_item_attr_callback,
+ btavrcp_play_item_callback,
+ btavrcp_get_total_num_items_callback,
+ btavrcp_search_callback,
+ btavrcp_add_to_play_list_callback,
+};
+
+static void classInitNative(JNIEnv* env, jclass clazz) {
+ method_getRcFeatures =
+ env->GetMethodID(clazz, "getRcFeaturesRequestFromNative", "([BI)V");
+ method_getPlayStatus =
+ env->GetMethodID(clazz, "getPlayStatusRequestFromNative", "([B)V");
+
+ method_getElementAttr =
+ env->GetMethodID(clazz, "getElementAttrRequestFromNative", "([BB[I)V");
+
+ method_registerNotification = env->GetMethodID(
+ clazz, "registerNotificationRequestFromNative", "([BII)V");
+
+ method_volumeChangeCallback =
+ env->GetMethodID(clazz, "volumeChangeRequestFromNative", "([BII)V");
+
+ method_handlePassthroughCmd = env->GetMethodID(
+ clazz, "handlePassthroughCmdRequestFromNative", "([BII)V");
+
+ method_setAddressedPlayerCallback =
+ env->GetMethodID(clazz, "setAddressedPlayerRequestFromNative", "([BI)V");
+
+ method_setBrowsedPlayerCallback =
+ env->GetMethodID(clazz, "setBrowsedPlayerRequestFromNative", "([BI)V");
+
+ method_getFolderItemsCallback =
+ env->GetMethodID(clazz, "getFolderItemsRequestFromNative", "([BBJJB[I)V");
+
+ method_changePathCallback =
+ env->GetMethodID(clazz, "changePathRequestFromNative", "([BB[B)V");
+
+ method_getItemAttrCallback =
+ env->GetMethodID(clazz, "getItemAttrRequestFromNative", "([BB[BIB[I)V");
+
+ method_playItemCallback =
+ env->GetMethodID(clazz, "playItemRequestFromNative", "([BBI[B)V");
+
+ method_getTotalNumOfItemsCallback =
+ env->GetMethodID(clazz, "getTotalNumOfItemsRequestFromNative", "([BB)V");
+
+ method_searchCallback =
+ env->GetMethodID(clazz, "searchRequestFromNative", "([BI[B)V");
+
+ method_addToPlayListCallback =
+ env->GetMethodID(clazz, "addToPlayListRequestFromNative", "([BB[BI)V");
+
+ ALOGI("%s: succeeds", __func__);
+}
+
+static void initNative(JNIEnv* env, jobject object) {
+ std::unique_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ const bt_interface_t* btInf = getBluetoothInterface();
+ if (btInf == NULL) {
+ ALOGE("Bluetooth module is not loaded");
+ return;
+ }
+
+ if (sBluetoothAvrcpInterface != NULL) {
+ ALOGW("Cleaning up Avrcp Interface before initializing...");
+ sBluetoothAvrcpInterface->cleanup();
+ sBluetoothAvrcpInterface = NULL;
+ }
+
+ if (mCallbacksObj != NULL) {
+ ALOGW("Cleaning up Avrcp callback object");
+ env->DeleteGlobalRef(mCallbacksObj);
+ mCallbacksObj = NULL;
+ }
+
+ sBluetoothAvrcpInterface =
+ (btrc_interface_t*)btInf->get_profile_interface(BT_PROFILE_AV_RC_ID);
+ if (sBluetoothAvrcpInterface == NULL) {
+ ALOGE("Failed to get Bluetooth Avrcp Interface");
+ return;
+ }
+
+ bt_status_t status =
+ sBluetoothAvrcpInterface->init(&sBluetoothAvrcpCallbacks);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed to initialize Bluetooth Avrcp, status: %d", status);
+ sBluetoothAvrcpInterface = NULL;
+ return;
+ }
+
+ mCallbacksObj = env->NewGlobalRef(object);
+}
+
+static void cleanupNative(JNIEnv* env, jobject object) {
+ std::unique_lock<std::shared_timed_mutex> lock(callbacks_mutex);
+ const bt_interface_t* btInf = getBluetoothInterface();
+ if (btInf == NULL) {
+ ALOGE("Bluetooth module is not loaded");
+ return;
+ }
+
+ if (sBluetoothAvrcpInterface != NULL) {
+ sBluetoothAvrcpInterface->cleanup();
+ sBluetoothAvrcpInterface = NULL;
+ }
+
+ if (mCallbacksObj != NULL) {
+ env->DeleteGlobalRef(mCallbacksObj);
+ mCallbacksObj = NULL;
+ }
+}
+
+static jboolean getPlayStatusRspNative(JNIEnv* env, jobject object,
+ jbyteArray address, jint playStatus,
+ jint songLen, jint songPos) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+ RawAddress rawAddress;
+ rawAddress.FromOctets((uint8_t*)addr);
+
+ bt_status_t status = sBluetoothAvrcpInterface->get_play_status_rsp(
+ rawAddress, (btrc_play_status_t)playStatus, songLen, songPos);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed get_play_status_rsp, status: %d", status);
+ }
+ env->ReleaseByteArrayElements(address, addr, 0);
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean getElementAttrRspNative(JNIEnv* env, jobject object,
+ jbyteArray address, jbyte numAttr,
+ jintArray attrIds,
+ jobjectArray textArray) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ if (numAttr > BTRC_MAX_ELEM_ATTR_SIZE) {
+ ALOGE("get_element_attr_rsp: number of attributes exceed maximum");
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ btrc_element_attr_val_t* pAttrs = new btrc_element_attr_val_t[numAttr];
+ if (!pAttrs) {
+ ALOGE("get_element_attr_rsp: not have enough memeory");
+ env->ReleaseByteArrayElements(address, addr, 0);
+ return JNI_FALSE;
+ }
+
+ jint* attr = env->GetIntArrayElements(attrIds, NULL);
+ if (!attr) {
+ delete[] pAttrs;
+ jniThrowIOException(env, EINVAL);
+ env->ReleaseByteArrayElements(address, addr, 0);
+ return JNI_FALSE;
+ }
+
+ int attr_cnt;
+ for (attr_cnt = 0; attr_cnt < numAttr; ++attr_cnt) {
+ pAttrs[attr_cnt].attr_id = attr[attr_cnt];
+ ScopedLocalRef<jstring> text(
+ env, (jstring)env->GetObjectArrayElement(textArray, attr_cnt));
+
+ if (!copy_jstring(pAttrs[attr_cnt].text, BTRC_MAX_ATTR_STR_LEN, text.get(),
+ env)) {
+ break;
+ }
+ }
+
+ if (attr_cnt < numAttr) {
+ delete[] pAttrs;
+ env->ReleaseIntArrayElements(attrIds, attr, 0);
+ ALOGE("%s: Failed to copy attributes", __func__);
+ return JNI_FALSE;
+ }
+
+ RawAddress rawAddress;
+ rawAddress.FromOctets((uint8_t*)addr);
+ bt_status_t status = sBluetoothAvrcpInterface->get_element_attr_rsp(
+ rawAddress, numAttr, pAttrs);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed get_element_attr_rsp, status: %d", status);
+ }
+
+ delete[] pAttrs;
+ env->ReleaseIntArrayElements(attrIds, attr, 0);
+ env->ReleaseByteArrayElements(address, addr, 0);
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean getItemAttrRspNative(JNIEnv* env, jobject object,
+ jbyteArray address, jint rspStatus,
+ jbyte numAttr, jintArray attrIds,
+ jobjectArray textArray) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ if (numAttr > BTRC_MAX_ELEM_ATTR_SIZE) {
+ ALOGE("get_element_attr_rsp: number of attributes exceed maximum");
+ return JNI_FALSE;
+ }
+
+ btrc_element_attr_val_t* pAttrs = new btrc_element_attr_val_t[numAttr];
+ if (!pAttrs) {
+ ALOGE("%s: not have enough memory", __func__);
+ env->ReleaseByteArrayElements(address, addr, 0);
+ return JNI_FALSE;
+ }
+
+ jint* attr = NULL;
+ if (attrIds != NULL) {
+ attr = env->GetIntArrayElements(attrIds, NULL);
+ if (!attr) {
+ delete[] pAttrs;
+ jniThrowIOException(env, EINVAL);
+ env->ReleaseByteArrayElements(address, addr, 0);
+ return JNI_FALSE;
+ }
+
+ for (int attr_cnt = 0; attr_cnt < numAttr; ++attr_cnt) {
+ pAttrs[attr_cnt].attr_id = attr[attr_cnt];
+ ScopedLocalRef<jstring> text(
+ env, (jstring)env->GetObjectArrayElement(textArray, attr_cnt));
+
+ if (!copy_jstring(pAttrs[attr_cnt].text, BTRC_MAX_ATTR_STR_LEN, text.get(),
+ env)) {
+ rspStatus = BTRC_STS_INTERNAL_ERR;
+ ALOGE("%s: Failed to copy attributes", __func__);
+ break;
+ }
+ }
+ }
+ RawAddress rawAddress;
+ rawAddress.FromOctets((uint8_t*)addr);
+
+ bt_status_t status = sBluetoothAvrcpInterface->get_item_attr_rsp(
+ rawAddress, (btrc_status_t)rspStatus, numAttr, pAttrs);
+ if (status != BT_STATUS_SUCCESS)
+ ALOGE("Failed get_item_attr_rsp, status: %d", status);
+
+ if (pAttrs) delete[] pAttrs;
+ if (attr) env->ReleaseIntArrayElements(attrIds, attr, 0);
+ env->ReleaseByteArrayElements(address, addr, 0);
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean registerNotificationRspPlayStatusNative(JNIEnv* env,
+ jobject object,
+ jint type,
+ jint playStatus) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ btrc_register_notification_t param;
+ param.play_status = (btrc_play_status_t)playStatus;
+
+ bt_status_t status = sBluetoothAvrcpInterface->register_notification_rsp(
+ BTRC_EVT_PLAY_STATUS_CHANGED, (btrc_notification_type_t)type, ¶m);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed register_notification_rsp play status, status: %d", status);
+ }
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean registerNotificationRspTrackChangeNative(JNIEnv* env,
+ jobject object,
+ jint type,
+ jbyteArray track) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* trk = env->GetByteArrayElements(track, NULL);
+ if (!trk) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ btrc_register_notification_t param;
+ uint64_t uid = 0;
+ for (int uid_idx = 0; uid_idx < BTRC_UID_SIZE; ++uid_idx) {
+ param.track[uid_idx] = trk[uid_idx];
+ uid = uid + (trk[uid_idx] << (BTRC_UID_SIZE - 1 - uid_idx));
+ }
+
+ ALOGV("%s: Sending track change notification: %d -> %" PRIu64, __func__, type,
+ uid);
+
+ bt_status_t status = sBluetoothAvrcpInterface->register_notification_rsp(
+ BTRC_EVT_TRACK_CHANGE, (btrc_notification_type_t)type, ¶m);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed register_notification_rsp track change, status: %d", status);
+ }
+
+ env->ReleaseByteArrayElements(track, trk, 0);
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean registerNotificationRspPlayPosNative(JNIEnv* env,
+ jobject object, jint type,
+ jint playPos) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ btrc_register_notification_t param;
+ param.song_pos = (uint32_t)playPos;
+
+ bt_status_t status = sBluetoothAvrcpInterface->register_notification_rsp(
+ BTRC_EVT_PLAY_POS_CHANGED, (btrc_notification_type_t)type, ¶m);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed register_notification_rsp play position, status: %d", status);
+ }
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean registerNotificationRspNowPlayingChangedNative(JNIEnv* env,
+ jobject object,
+ jint type) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ btrc_register_notification_t param;
+ bt_status_t status = sBluetoothAvrcpInterface->register_notification_rsp(
+ BTRC_EVT_NOW_PLAYING_CONTENT_CHANGED, (btrc_notification_type_t)type,
+ ¶m);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed register_notification_rsp, nowPlaying Content status: %d",
+ status);
+ }
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean registerNotificationRspUIDsChangedNative(JNIEnv* env,
+ jobject object,
+ jint type,
+ jint uidCounter) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ btrc_register_notification_t param;
+ param.uids_changed.uid_counter = (uint16_t)uidCounter;
+
+ bt_status_t status = sBluetoothAvrcpInterface->register_notification_rsp(
+ BTRC_EVT_UIDS_CHANGED, (btrc_notification_type_t)type, ¶m);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed register_notification_rsp, uids changed status: %d", status);
+ }
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean registerNotificationRspAddrPlayerChangedNative(
+ JNIEnv* env, jobject object, jint type, jint playerId, jint uidCounter) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ btrc_register_notification_t param;
+ param.addr_player_changed.player_id = (uint16_t)playerId;
+ param.addr_player_changed.uid_counter = (uint16_t)uidCounter;
+
+ bt_status_t status = sBluetoothAvrcpInterface->register_notification_rsp(
+ BTRC_EVT_ADDR_PLAYER_CHANGE, (btrc_notification_type_t)type, ¶m);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed register_notification_rsp address player changed status: %d",
+ status);
+ }
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean registerNotificationRspAvalPlayerChangedNative(JNIEnv* env,
+ jobject object,
+ jint type) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ btrc_register_notification_t param;
+ bt_status_t status = sBluetoothAvrcpInterface->register_notification_rsp(
+ BTRC_EVT_AVAL_PLAYER_CHANGE, (btrc_notification_type_t)type, ¶m);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE(
+ "Failed register_notification_rsp available player changed status, "
+ "status: %d",
+ status);
+ }
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean setVolumeNative(JNIEnv* env, jobject object, jint volume) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ bt_status_t status = sBluetoothAvrcpInterface->set_volume((uint8_t)volume);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed set_volume, status: %d", status);
+ }
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+/* native response for scope as Media player */
+static jboolean mediaPlayerListRspNative(
+ JNIEnv* env, jobject object, jbyteArray address, jint rspStatus,
+ jint uidCounter, jbyte itemType, jint numItems, jintArray playerIds,
+ jbyteArray playerTypes, jintArray playerSubtypes,
+ jbyteArray playStatusValues, jshortArray featureBitmask,
+ jobjectArray textArray) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ jbyte *p_playerTypes = NULL, *p_PlayStatusValues = NULL;
+ jshort* p_FeatBitMaskValues = NULL;
+ jint *p_playerIds = NULL, *p_playerSubTypes = NULL;
+ btrc_folder_items_t* p_items = NULL;
+ if (rspStatus == BTRC_STS_NO_ERROR) {
+ /* allocate memory */
+ p_playerIds = env->GetIntArrayElements(playerIds, NULL);
+ p_playerTypes = env->GetByteArrayElements(playerTypes, NULL);
+ p_playerSubTypes = env->GetIntArrayElements(playerSubtypes, NULL);
+ p_PlayStatusValues = env->GetByteArrayElements(playStatusValues, NULL);
+ p_FeatBitMaskValues = env->GetShortArrayElements(featureBitmask, NULL);
+ p_items = new btrc_folder_items_t[numItems];
+ /* deallocate memory and return if allocation failed */
+ if (!p_playerIds || !p_playerTypes || !p_playerSubTypes ||
+ !p_PlayStatusValues || !p_FeatBitMaskValues || !p_items) {
+ if (p_playerIds) env->ReleaseIntArrayElements(playerIds, p_playerIds, 0);
+ if (p_playerTypes)
+ env->ReleaseByteArrayElements(playerTypes, p_playerTypes, 0);
+ if (p_playerSubTypes)
+ env->ReleaseIntArrayElements(playerSubtypes, p_playerSubTypes, 0);
+ if (p_PlayStatusValues)
+ env->ReleaseByteArrayElements(playStatusValues, p_PlayStatusValues, 0);
+ if (p_FeatBitMaskValues)
+ env->ReleaseShortArrayElements(featureBitmask, p_FeatBitMaskValues, 0);
+ if (p_items) delete[] p_items;
+
+ jniThrowIOException(env, EINVAL);
+ ALOGE("%s: not have enough memory", __func__);
+ return JNI_FALSE;
+ }
+
+ p_items->item_type = (uint8_t)itemType;
+
+ /* copy list of media players along with other parameters */
+ int itemIdx;
+ for (itemIdx = 0; itemIdx < numItems; ++itemIdx) {
+ p_items[itemIdx].player.player_id = p_playerIds[itemIdx];
+ p_items[itemIdx].player.major_type = p_playerTypes[itemIdx];
+ p_items[itemIdx].player.sub_type = p_playerSubTypes[itemIdx];
+ p_items[itemIdx].player.play_status = p_PlayStatusValues[itemIdx];
+ p_items[itemIdx].player.charset_id = BTRC_CHARSET_ID_UTF8;
+
+ ScopedLocalRef<jstring> text(
+ env, (jstring)env->GetObjectArrayElement(textArray, itemIdx));
+ /* copy player name */
+ if (!copy_jstring(p_items[itemIdx].player.name, BTRC_MAX_ATTR_STR_LEN,
+ text.get(), env))
+ break;
+
+ /* Feature bit mask is 128-bit value each */
+ for (int InnCnt = 0; InnCnt < 16; InnCnt++) {
+ p_items[itemIdx].player.features[InnCnt] =
+ (uint8_t)p_FeatBitMaskValues[(itemIdx * 16) + InnCnt];
+ }
+ }
+
+ /* failed to copy list of media players */
+ if (itemIdx < numItems) {
+ rspStatus = BTRC_STS_INTERNAL_ERR;
+ ALOGE("%s: Failed to copy Media player attributes", __func__);
+ }
+ }
+
+ RawAddress* btAddr = (RawAddress*)addr;
+ bt_status_t status = sBluetoothAvrcpInterface->get_folder_items_list_rsp(
+ *btAddr, (btrc_status_t)rspStatus, uidCounter, numItems, p_items);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed get_folder_items_list_rsp, status: %d", status);
+ }
+
+ /* release allocated memory */
+ if (p_items) delete[] p_items;
+ if (p_playerTypes)
+ env->ReleaseByteArrayElements(playerTypes, p_playerTypes, 0);
+ if (p_playerSubTypes)
+ env->ReleaseIntArrayElements(playerSubtypes, p_playerSubTypes, 0);
+ if (p_PlayStatusValues)
+ env->ReleaseByteArrayElements(playStatusValues, p_PlayStatusValues, 0);
+ if (p_FeatBitMaskValues) {
+ env->ReleaseShortArrayElements(featureBitmask, p_FeatBitMaskValues, 0);
+ }
+ env->ReleaseByteArrayElements(address, addr, 0);
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean getFolderItemsRspNative(
+ JNIEnv* env, jobject object, jbyteArray address, jint rspStatus,
+ jshort uidCounter, jbyte scope, jint numItems, jbyteArray folderType,
+ jbyteArray playable, jbyteArray itemType, jbyteArray itemUidArray,
+ jobjectArray displayNameArray, jintArray numAttrs, jintArray attributesIds,
+ jobjectArray attributesArray) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ jbyte *p_playable = NULL, *p_item_uid = NULL;
+ jbyte* p_item_types = NULL; /* Folder or Media Item */
+ jint* p_attributesIds = NULL;
+ jbyte* p_folder_types =
+ NULL; /* Folder properties like Album/Genre/Artists etc */
+ jint* p_num_attrs = NULL;
+ btrc_folder_items_t* p_items = NULL;
+ /* none of the parameters should be null when no error */
+ if (rspStatus == BTRC_STS_NO_ERROR) {
+ /* allocate memory to each rsp item */
+ if (folderType != NULL)
+ p_folder_types = env->GetByteArrayElements(folderType, NULL);
+ if (playable != NULL)
+ p_playable = env->GetByteArrayElements(playable, NULL);
+ if (itemType != NULL)
+ p_item_types = env->GetByteArrayElements(itemType, NULL);
+ if (NULL != numAttrs)
+ p_num_attrs = env->GetIntArrayElements(numAttrs, NULL);
+ if (NULL != attributesIds)
+ p_attributesIds = env->GetIntArrayElements(attributesIds, NULL);
+ if (itemUidArray != NULL)
+ p_item_uid = (jbyte*)env->GetByteArrayElements(itemUidArray, NULL);
+
+ p_items = new btrc_folder_items_t[numItems];
+
+ /* if memory alloc failed, release memory */
+ if (p_items && p_folder_types && p_playable && p_item_types && p_item_uid &&
+ /* attributes can be null if remote requests 0 attributes */
+ ((numAttrs != NULL && p_num_attrs) || (!numAttrs && !p_num_attrs)) &&
+ ((attributesIds != NULL && p_attributesIds) ||
+ (!attributesIds && !p_attributesIds))) {
+ memset(p_items, 0, sizeof(btrc_folder_items_t) * numItems);
+ if (scope == BTRC_SCOPE_FILE_SYSTEM || scope == BTRC_SCOPE_SEARCH ||
+ scope == BTRC_SCOPE_NOW_PLAYING) {
+ int attribCopiedIndex = 0;
+ for (int item_idx = 0; item_idx < numItems; item_idx++) {
+ if (BTRC_ITEM_FOLDER == p_item_types[item_idx]) {
+ btrc_folder_items_t* pitem = &p_items[item_idx];
+
+ memcpy(pitem->folder.uid, p_item_uid + item_idx * BTRC_UID_SIZE,
+ BTRC_UID_SIZE);
+ pitem->item_type = (uint8_t)BTRC_ITEM_FOLDER;
+ pitem->folder.charset_id = BTRC_CHARSET_ID_UTF8;
+ pitem->folder.type = p_folder_types[item_idx];
+ pitem->folder.playable = p_playable[item_idx];
+
+ ScopedLocalRef<jstring> text(
+ env, (jstring)env->GetObjectArrayElement(displayNameArray,
+ item_idx));
+ if (!copy_jstring(pitem->folder.name, BTRC_MAX_ATTR_STR_LEN,
+ text.get(), env)) {
+ rspStatus = BTRC_STS_INTERNAL_ERR;
+ ALOGE("%s: failed to copy display name of folder item", __func__);
+ break;
+ }
+ } else if (BTRC_ITEM_MEDIA == p_item_types[item_idx]) {
+ btrc_folder_items_t* pitem = &p_items[item_idx];
+ memcpy(pitem->media.uid, p_item_uid + item_idx * BTRC_UID_SIZE,
+ BTRC_UID_SIZE);
+
+ pitem->item_type = (uint8_t)BTRC_ITEM_MEDIA;
+ pitem->media.charset_id = BTRC_CHARSET_ID_UTF8;
+ pitem->media.type = BTRC_MEDIA_TYPE_AUDIO;
+ pitem->media.num_attrs =
+ (p_num_attrs != NULL) ? p_num_attrs[item_idx] : 0;
+
+ ScopedLocalRef<jstring> text(
+ env, (jstring)env->GetObjectArrayElement(displayNameArray,
+ item_idx));
+ if (!copy_jstring(pitem->media.name, BTRC_MAX_ATTR_STR_LEN,
+ text.get(), env)) {
+ rspStatus = BTRC_STS_INTERNAL_ERR;
+ ALOGE("%s: failed to copy display name of media item", __func__);
+ break;
+ }
+
+ /* copy item attributes */
+ if (!copy_item_attributes(env, object, pitem, p_attributesIds,
+ attributesArray, item_idx,
+ attribCopiedIndex)) {
+ ALOGE("%s: error in copying attributes of item = %s", __func__,
+ pitem->media.name);
+ rspStatus = BTRC_STS_INTERNAL_ERR;
+ break;
+ }
+ attribCopiedIndex += pitem->media.num_attrs;
+ }
+ }
+ }
+ } else {
+ rspStatus = BTRC_STS_INTERNAL_ERR;
+ ALOGE("%s: unable to allocate memory", __func__);
+ }
+ }
+
+ RawAddress* btAddr = (RawAddress*)addr;
+ bt_status_t status = sBluetoothAvrcpInterface->get_folder_items_list_rsp(
+ *btAddr, (btrc_status_t)rspStatus, uidCounter, numItems, p_items);
+ if (status != BT_STATUS_SUCCESS)
+ ALOGE("Failed get_folder_items_list_rsp, status: %d", status);
+
+ /* Release allocated memory for all attributes in each media item */
+ if (p_items) cleanup_items(p_items, numItems);
+
+ /* Release allocated memory */
+ if (p_folder_types)
+ env->ReleaseByteArrayElements(folderType, p_folder_types, 0);
+ if (p_playable) env->ReleaseByteArrayElements(playable, p_playable, 0);
+ if (p_item_types) env->ReleaseByteArrayElements(itemType, p_item_types, 0);
+ if (p_num_attrs) env->ReleaseIntArrayElements(numAttrs, p_num_attrs, 0);
+ if (p_attributesIds)
+ env->ReleaseIntArrayElements(attributesIds, p_attributesIds, 0);
+ if (p_item_uid) env->ReleaseByteArrayElements(itemUidArray, p_item_uid, 0);
+ if (p_items) delete[] p_items;
+ env->ReleaseByteArrayElements(address, addr, 0);
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean setAddressedPlayerRspNative(JNIEnv* env, jobject object,
+ jbyteArray address,
+ jint rspStatus) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ RawAddress* btAddr = (RawAddress*)addr;
+ bt_status_t status = sBluetoothAvrcpInterface->set_addressed_player_rsp(
+ *btAddr, (btrc_status_t)rspStatus);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed set_addressed_player_rsp, status: %d", status);
+ }
+ env->ReleaseByteArrayElements(address, addr, 0);
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean setBrowsedPlayerRspNative(JNIEnv* env, jobject object,
+ jbyteArray address, jint rspStatus,
+ jbyte depth, jint numItems,
+ jobjectArray textArray) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ btrc_br_folder_name_t* p_folders = NULL;
+ if (rspStatus == BTRC_STS_NO_ERROR) {
+ if (depth > 0) {
+ p_folders = new btrc_br_folder_name_t[depth];
+
+ if (!p_folders ) {
+ jniThrowIOException(env, EINVAL);
+ ALOGE("%s: not have enough memeory", __func__);
+ return JNI_FALSE;
+ }
+ for (int folder_idx = 0; folder_idx < depth; folder_idx++) {
+ /* copy folder names */
+ ScopedLocalRef<jstring> text(
+ env, (jstring)env->GetObjectArrayElement(textArray, folder_idx));
+
+ if (!copy_jstring(p_folders[folder_idx].p_str, BTRC_MAX_ATTR_STR_LEN,
+ text.get(), env)) {
+ rspStatus = BTRC_STS_INTERNAL_ERR;
+ delete[] p_folders;
+ env->ReleaseByteArrayElements(address, addr, 0);
+ ALOGE("%s: Failed to copy folder name", __func__);
+ return JNI_FALSE;
+ }
+
+ p_folders[folder_idx].str_len =
+ strlen((char*)p_folders[folder_idx].p_str);
+ }
+ }
+ }
+
+ uint8_t folder_depth =
+ depth; /* folder_depth is 0 if current folder is root */
+ uint16_t charset_id = BTRC_CHARSET_ID_UTF8;
+ RawAddress* btAddr = (RawAddress*)addr;
+ bt_status_t status = sBluetoothAvrcpInterface->set_browsed_player_rsp(
+ *btAddr, (btrc_status_t)rspStatus, numItems, charset_id, folder_depth,
+ p_folders);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("%s: Failed set_browsed_player_rsp, status: %d", __func__, status);
+ }
+
+ if (depth > 0) {
+ delete[] p_folders;
+ }
+
+ env->ReleaseByteArrayElements(address, addr, 0);
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean changePathRspNative(JNIEnv* env, jobject object,
+ jbyteArray address, jint rspStatus,
+ jint numItems) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ uint32_t nItems = (uint32_t)numItems;
+ RawAddress* btAddr = (RawAddress*)addr;
+ bt_status_t status = sBluetoothAvrcpInterface->change_path_rsp(
+ *btAddr, (btrc_status_t)rspStatus, (uint32_t)nItems);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed change_path_rsp, status: %d", status);
+ }
+ env->ReleaseByteArrayElements(address, addr, 0);
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean searchRspNative(JNIEnv* env, jobject object, jbyteArray address,
+ jint rspStatus, jint uidCounter,
+ jint numItems) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ uint32_t nItems = (uint32_t)numItems;
+ RawAddress* btAddr = (RawAddress*)addr;
+ bt_status_t status = sBluetoothAvrcpInterface->search_rsp(
+ *btAddr, (btrc_status_t)rspStatus, (uint32_t)uidCounter,
+ (uint32_t)nItems);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed search_rsp, status: %d", status);
+ }
+
+ env->ReleaseByteArrayElements(address, addr, 0);
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean playItemRspNative(JNIEnv* env, jobject object,
+ jbyteArray address, jint rspStatus) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ RawAddress* btAddr = (RawAddress*)addr;
+ bt_status_t status = sBluetoothAvrcpInterface->play_item_rsp(
+ *btAddr, (btrc_status_t)rspStatus);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed play_item_rsp, status: %d", status);
+ }
+ env->ReleaseByteArrayElements(address, addr, 0);
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean getTotalNumOfItemsRspNative(JNIEnv* env, jobject object,
+ jbyteArray address, jint rspStatus,
+ jint uidCounter, jint numItems) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ uint32_t nItems = (uint32_t)numItems;
+ RawAddress* btAddr = (RawAddress*)addr;
+ bt_status_t status = sBluetoothAvrcpInterface->get_total_num_of_items_rsp(
+ *btAddr, (btrc_status_t)rspStatus, (uint32_t)uidCounter,
+ (uint32_t)nItems);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed get_total_num_of_items_rsp, status: %d", status);
+ }
+ env->ReleaseByteArrayElements(address, addr, 0);
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static jboolean addToNowPlayingRspNative(JNIEnv* env, jobject object,
+ jbyteArray address, jint rspStatus) {
+ if (!sBluetoothAvrcpInterface) {
+ ALOGE("%s: sBluetoothAvrcpInterface is null", __func__);
+ return JNI_FALSE;
+ }
+
+ jbyte* addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return JNI_FALSE;
+ }
+
+ RawAddress* btAddr = (RawAddress*)addr;
+ bt_status_t status = sBluetoothAvrcpInterface->add_to_now_playing_rsp(
+ *btAddr, (btrc_status_t)rspStatus);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed add_to_now_playing_rsp, status: %d", status);
+ }
+ env->ReleaseByteArrayElements(address, addr, 0);
+
+ return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
+}
+
+static JNINativeMethod sMethods[] = {
+ {"classInitNative", "()V", (void*)classInitNative},
+ {"initNative", "()V", (void*)initNative},
+ {"cleanupNative", "()V", (void*)cleanupNative},
+ {"getPlayStatusRspNative", "([BIII)Z", (void*)getPlayStatusRspNative},
+ {"getElementAttrRspNative", "([BB[I[Ljava/lang/String;)Z",
+ (void*)getElementAttrRspNative},
+ {"registerNotificationRspPlayStatusNative", "(II)Z",
+ (void*)registerNotificationRspPlayStatusNative},
+ {"registerNotificationRspTrackChangeNative", "(I[B)Z",
+ (void*)registerNotificationRspTrackChangeNative},
+ {"registerNotificationRspPlayPosNative", "(II)Z",
+ (void*)registerNotificationRspPlayPosNative},
+ {"setVolumeNative", "(I)Z", (void*)setVolumeNative},
+
+ {"setAddressedPlayerRspNative", "([BI)Z",
+ (void*)setAddressedPlayerRspNative},
+
+ {"setBrowsedPlayerRspNative", "([BIBI[Ljava/lang/String;)Z",
+ (void*)setBrowsedPlayerRspNative},
+
+ {"mediaPlayerListRspNative", "([BIIBI[I[B[I[B[S[Ljava/lang/String;)Z",
+ (void*)mediaPlayerListRspNative},
+
+ {"getFolderItemsRspNative",
+ "([BISBI[B[B[B[B[Ljava/lang/String;[I[I[Ljava/lang/String;)Z",
+ (void*)getFolderItemsRspNative},
+
+ {"changePathRspNative", "([BII)Z", (void*)changePathRspNative},
+
+ {"getItemAttrRspNative", "([BIB[I[Ljava/lang/String;)Z",
+ (void*)getItemAttrRspNative},
+
+ {"playItemRspNative", "([BI)Z", (void*)playItemRspNative},
+
+ {"getTotalNumOfItemsRspNative", "([BIII)Z",
+ (void*)getTotalNumOfItemsRspNative},
+
+ {"searchRspNative", "([BIII)Z", (void*)searchRspNative},
+
+ {"addToNowPlayingRspNative", "([BI)Z", (void*)addToNowPlayingRspNative},
+
+ {"registerNotificationRspAddrPlayerChangedNative", "(III)Z",
+ (void*)registerNotificationRspAddrPlayerChangedNative},
+
+ {"registerNotificationRspAvalPlayerChangedNative", "(I)Z",
+ (void*)registerNotificationRspAvalPlayerChangedNative},
+
+ {"registerNotificationRspUIDsChangedNative", "(II)Z",
+ (void*)registerNotificationRspUIDsChangedNative},
+
+ {"registerNotificationRspNowPlayingChangedNative", "(I)Z",
+ (void*)registerNotificationRspNowPlayingChangedNative}};
+
+int register_com_android_bluetooth_avrcp(JNIEnv* env) {
+ return jniRegisterNativeMethods(env, "com/android/bluetooth/avrcp/Avrcp",
+ sMethods, NELEM(sMethods));
+}
+
+/* Helper function to copy attributes of item.
+ * Assumes that all items in response have same number of attributes
+ *
+ * returns true on succes, false otherwise.
+*/
+static bool copy_item_attributes(JNIEnv* env, jobject object,
+ btrc_folder_items_t* pitem,
+ jint* p_attributesIds,
+ jobjectArray attributesArray, int item_idx,
+ int attribCopiedIndex) {
+ bool success = true;
+
+ /* copy attributes of the item */
+ if (0 < pitem->media.num_attrs) {
+ int num_attrs = pitem->media.num_attrs;
+ ALOGI("%s num_attr = %d", __func__, num_attrs);
+ pitem->media.p_attrs = new btrc_element_attr_val_t[num_attrs];
+ if (!pitem->media.p_attrs) {
+ return false;
+ }
+
+ for (int tempAtrCount = 0; tempAtrCount < pitem->media.num_attrs;
+ ++tempAtrCount) {
+ pitem->media.p_attrs[tempAtrCount].attr_id =
+ p_attributesIds[attribCopiedIndex + tempAtrCount];
+
+ ScopedLocalRef<jstring> text(
+ env, (jstring)env->GetObjectArrayElement(
+ attributesArray, attribCopiedIndex + tempAtrCount));
+
+ if (!copy_jstring(pitem->media.p_attrs[tempAtrCount].text,
+ BTRC_MAX_ATTR_STR_LEN, text.get(), env)) {
+ success = false;
+ ALOGE("%s: failed to copy attributes", __func__);
+ break;
+ }
+ }
+ }
+ return success;
+}
+
+/* Helper function to copy String data from java to native
+ *
+ * returns true on succes, false otherwise
+ */
+static bool copy_jstring(uint8_t* str, int maxBytes, jstring jstr,
+ JNIEnv* env) {
+ if (str == NULL || jstr == NULL || env == NULL) return false;
+
+ memset(str, 0, maxBytes);
+ const char* p_str = env->GetStringUTFChars(jstr, NULL);
+ size_t len = strnlen(p_str, maxBytes - 1);
+ memcpy(str, p_str, len);
+
+ env->ReleaseStringUTFChars(jstr, p_str);
+ return true;
+}
+
+/* Helper function to cleanup items */
+static void cleanup_items(btrc_folder_items_t* p_items, int numItems) {
+ for (int item_idx = 0; item_idx < numItems; item_idx++) {
+ /* release memory for attributes in case item is media item */
+ if ((BTRC_ITEM_MEDIA == p_items[item_idx].item_type) &&
+ p_items[item_idx].media.p_attrs != NULL)
+ delete[] p_items[item_idx].media.p_attrs;
+ }
+}
+}
diff --git a/jni/com_android_bluetooth_avrcp_controller.cpp b/jni/com_android_bluetooth_avrcp_controller.cpp
index 2d9e87b..d16a04f 100644
--- a/jni/com_android_bluetooth_avrcp_controller.cpp
+++ b/jni/com_android_bluetooth_avrcp_controller.cpp
@@ -21,6 +21,7 @@
#include "android_runtime/AndroidRuntime.h"
#include "com_android_bluetooth.h"
#include "hardware/bt_rc.h"
+#include "hardware/bt_vendor_rc.h"
#include "utils/Log.h"
#include <string.h>
@@ -36,6 +37,7 @@
static jmethodID method_handleSetAbsVolume;
static jmethodID method_handleRegisterNotificationAbsVol;
static jmethodID method_handletrackchanged;
+static jmethodID method_handleElementAttrupdate;
static jmethodID method_handleplaypositionchanged;
static jmethodID method_handleplaystatuschanged;
static jmethodID method_handleGetFolderItemsRsp;
@@ -54,6 +56,7 @@
static jclass class_AvrcpPlayer;
static const btrc_ctrl_interface_t* sBluetoothAvrcpInterface = NULL;
+static const btrc_vendor_ctrl_interface_t* sBluetoothAvrcpVendorInterface = NULL;
static jobject sCallbacksObj = NULL;
static std::shared_timed_mutex sCallbacks_mutex;
@@ -141,7 +144,7 @@
sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
(jbyte*)&bd_addr.address);
sCallbackEnv->CallVoidMethod(sCallbacksObj, method_getRcFeatures, addr.get(),
- (jint)features);
+ (jint)features, (jint) 0);
}
static void btavrcp_setplayerapplicationsetting_rsp_callback(
@@ -168,6 +171,86 @@
addr.get(), (jint)accepted);
}
+static void btavrcp_get_vendor_rcfeatures_callback(RawAddress* bd_addr, int features,
+ uint16_t cover_art_psm) {
+ ALOGV("%s", __func__);
+ CallbackEnv sCallbackEnv(__func__);
+ if (!sCallbackEnv.valid()) return;
+
+ ScopedLocalRef<jbyteArray> addr(
+ sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
+ if (!addr.get()) {
+ ALOGE("Fail to new jbyteArray bd addr ");
+ return;
+ }
+
+ sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
+ (jbyte*)bd_addr);
+ sCallbackEnv->CallVoidMethod(sCallbacksObj, method_getRcFeatures, addr.get(),
+ (jint)features, (jint) cover_art_psm);
+}
+
+static void btavrcp_vendor_get_mediaelementattribute_rsp_callback(RawAddress *bd_addr,
+ uint8_t num_attr, btrc_element_attr_val_t *p_attrs) {
+ /*
+ * byteArray will be formatted like this: id,len,string
+ * Assuming text feild to be null terminated.
+ */
+ jbyteArray addr;
+ jintArray attribIds;
+ jobjectArray stringArray;
+ jstring str;
+ jclass strclazz;
+ jint i;
+ ALOGV("%s", __func__);
+ CallbackEnv sCallbackEnv(__func__);
+ if (!sCallbackEnv.valid()) return;
+
+ addr = sCallbackEnv->NewByteArray(sizeof(RawAddress));
+ if (!addr) {
+ ALOGE("Fail to get new array ");
+ return;
+ }
+ attribIds = sCallbackEnv->NewIntArray(num_attr);
+ if(!attribIds) {
+ ALOGE(" failed to set new array for attribIds");
+ sCallbackEnv->DeleteLocalRef(addr);
+ return;
+ }
+ sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(RawAddress), (jbyte *) bd_addr);
+
+ strclazz = sCallbackEnv->FindClass("java/lang/String");
+ stringArray = sCallbackEnv->NewObjectArray((jint)num_attr, strclazz, 0);
+ if(!stringArray) {
+ ALOGE(" failed to get String array");
+ sCallbackEnv->DeleteLocalRef(addr);
+ sCallbackEnv->DeleteLocalRef(attribIds);
+ return;
+ }
+ for(i = 0; i < num_attr; i++)
+ {
+ str = sCallbackEnv->NewStringUTF((char*)(p_attrs[i].text));
+ if(!str) {
+ ALOGE(" Unable to get str ");
+ sCallbackEnv->DeleteLocalRef(addr);
+ sCallbackEnv->DeleteLocalRef(attribIds);
+ sCallbackEnv->DeleteLocalRef(stringArray);
+ return;
+ }
+ sCallbackEnv->SetIntArrayRegion(attribIds, i, 1, (jint*)&(p_attrs[i].attr_id));
+ sCallbackEnv->SetObjectArrayElement(stringArray, i,str);
+ sCallbackEnv->DeleteLocalRef(str);
+ }
+
+ sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleElementAttrupdate, addr,
+ (jbyte)(num_attr), attribIds, stringArray);
+ sCallbackEnv->DeleteLocalRef(addr);
+ sCallbackEnv->DeleteLocalRef(attribIds);
+ /* TODO check do we need to delete str seperately or not */
+ sCallbackEnv->DeleteLocalRef(stringArray);
+ sCallbackEnv->DeleteLocalRef(strclazz);
+}
+
static void btavrcp_playerapplicationsetting_callback(
const RawAddress& bd_addr, uint8_t num_attr,
btrc_player_app_attr_t* app_attrs, uint8_t num_ext_attr,
@@ -741,6 +824,12 @@
btavrcp_addressed_player_changed_callback,
btavrcp_now_playing_content_changed_callback};
+static btrc_vendor_ctrl_callbacks_t sBluetoothAvrcpVendorCallbacks = {
+ sizeof(sBluetoothAvrcpVendorCallbacks),
+ btavrcp_get_vendor_rcfeatures_callback,
+ btavrcp_vendor_get_mediaelementattribute_rsp_callback,
+};
+
static void classInitNative(JNIEnv* env, jclass clazz) {
method_handlePassthroughRsp =
env->GetMethodID(clazz, "handlePassthroughRsp", "(II[B)V");
@@ -751,7 +840,7 @@
method_onConnectionStateChanged =
env->GetMethodID(clazz, "onConnectionStateChanged", "(ZZ[B)V");
- method_getRcFeatures = env->GetMethodID(clazz, "getRcFeatures", "([BI)V");
+ method_getRcFeatures = env->GetMethodID(clazz, "getRcFeatures", "([BII)V");
method_setplayerappsettingrsp =
env->GetMethodID(clazz, "setPlayerAppSettingRsp", "([BB)V");
@@ -771,6 +860,9 @@
method_handletrackchanged =
env->GetMethodID(clazz, "onTrackChanged", "([BB[I[Ljava/lang/String;)V");
+ method_handleElementAttrupdate =
+ env->GetMethodID(clazz, "onElementAttributeUpdate", "([BB[I[Ljava/lang/String;)V");
+
method_handleplaypositionchanged =
env->GetMethodID(clazz, "onPlayPositionChanged", "([BII)V");
@@ -826,6 +918,12 @@
return;
}
+ if (sBluetoothAvrcpVendorInterface != NULL) {
+ ALOGW("Cleaning up Avrcp Vendor Interface before initializing...");
+ sBluetoothAvrcpVendorInterface->cleanup_vendor();
+ sBluetoothAvrcpVendorInterface = NULL;
+ }
+
if (sBluetoothAvrcpInterface != NULL) {
ALOGW("Cleaning up Avrcp Interface before initializing...");
sBluetoothAvrcpInterface->cleanup();
@@ -855,6 +953,28 @@
return;
}
+ sBluetoothAvrcpVendorInterface =
+ (btrc_vendor_ctrl_interface_t*)btInf->get_profile_interface(
+ BT_PROFILE_AV_RC_VENDOR_CTRL_ID);
+ if (sBluetoothAvrcpVendorInterface == NULL) {
+ ALOGE("Failed to get Bluetooth Avrcp Vendor Controller Interface");
+ sBluetoothAvrcpInterface->cleanup();
+ sBluetoothAvrcpInterface = NULL;
+ return;
+ }
+
+ status =
+ sBluetoothAvrcpVendorInterface->init_vendor(&sBluetoothAvrcpVendorCallbacks);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed to initialize Bluetooth Avrcp Vendor Controller, status: %d",
+ status);
+ sBluetoothAvrcpVendorInterface = NULL;
+ sBluetoothAvrcpInterface->cleanup();
+ sBluetoothAvrcpInterface = NULL;
+ return;
+ }
+
+
sCallbacksObj = env->NewGlobalRef(object);
}
@@ -867,6 +987,11 @@
return;
}
+ if (sBluetoothAvrcpVendorInterface != NULL) {
+ sBluetoothAvrcpVendorInterface->cleanup_vendor();
+ sBluetoothAvrcpVendorInterface = NULL;
+ }
+
if (sBluetoothAvrcpInterface != NULL) {
sBluetoothAvrcpInterface->cleanup();
sBluetoothAvrcpInterface = NULL;
@@ -1206,6 +1331,49 @@
env->ReleaseByteArrayElements(address, addr, 0);
}
+/* This api is used to fetch metadata for currently playing track
+ * num_attribs: number of attributes to be fetched. 0 corresponds to fetch all
+ * attributes
+ * attrib_ids: list of attributes we want to fetch. NULL corresponds to fetch
+ * all attributes.
+ */
+ static void getElementAttributesNative(JNIEnv *env, jobject object, jbyteArray address,
+ jbyte num_attribs, jbyteArray attrib_ids) {
+ if (!sBluetoothAvrcpVendorInterface) return;
+ bt_status_t status;
+ jbyte *addr;
+ uint32_t *pAttrs = NULL;
+ jbyte *attr;
+ int i;
+
+ if (!sBluetoothAvrcpInterface) return;
+ addr = env->GetByteArrayElements(address, NULL);
+ if (!addr) {
+ jniThrowIOException(env, EINVAL);
+ return;
+ }
+ if (num_attribs == 0) {
+ // we have to fetch all element attributes
+ sBluetoothAvrcpVendorInterface->get_media_element_attributes_vendor((RawAddress *)addr,
+ (uint8_t)num_attribs, NULL);
+ env->ReleaseByteArrayElements(address, addr, 0);
+ return;
+ }
+ pAttrs = new uint32_t[num_attribs];
+ attr = env->GetByteArrayElements(attrib_ids, NULL);
+ for (i = 0; i < num_attribs; ++i) {
+ pAttrs[i] = (uint32_t)attr[i];
+ }
+ status = sBluetoothAvrcpVendorInterface->get_media_element_attributes_vendor(
+ (RawAddress *)addr, (uint8_t)num_attribs, pAttrs);
+ if (status != BT_STATUS_SUCCESS) {
+ ALOGE("Failed sending getElementAttributesNative command, status: %d", status);
+ }
+ delete[] pAttrs;
+ env->ReleaseByteArrayElements(address, addr, 0);
+ env->ReleaseByteArrayElements(attrib_ids, attr, 0);
+ }
+
static JNINativeMethod sMethods[] = {
{"classInitNative", "()V", (void*)classInitNative},
{"initNative", "()V", (void*)initNative},
@@ -1227,6 +1395,7 @@
{"playItemNative", "([BBJI)V", (void*)playItemNative},
{"setBrowsedPlayerNative", "([BI)V", (void*)setBrowsedPlayerNative},
{"setAddressedPlayerNative", "([BI)V", (void*)setAddressedPlayerNative},
+ {"getElementAttributesNative", "([BB[B)V",(void *) getElementAttributesNative},
};
int register_com_android_bluetooth_avrcp_controller(JNIEnv* env) {
diff --git a/jni/com_android_bluetooth_btservice_AdapterService.cpp b/jni/com_android_bluetooth_btservice_AdapterService.cpp
index 06914e1..5c9597f 100644
--- a/jni/com_android_bluetooth_btservice_AdapterService.cpp
+++ b/jni/com_android_bluetooth_btservice_AdapterService.cpp
@@ -68,12 +68,12 @@
jmethodID constructor;
} android_bluetooth_UidTraffic;
-static const bt_interface_t* sBluetoothInterface = NULL;
-static const btsock_interface_t* sBluetoothSocketInterface = NULL;
-static JNIEnv* callbackEnv = NULL;
+static const bt_interface_t *sBluetoothInterface = NULL;
+static const btsock_interface_t *sBluetoothSocketInterface = NULL;
+static JNIEnv *callbackEnv = NULL;
-static jobject sJniAdapterServiceObj;
-static jobject sJniCallbacksObj;
+static jobject sJniAdapterServiceObj = NULL;
+static jobject sJniCallbacksObj = NULL;
static jfieldID sJniCallbacksField;
namespace {
@@ -508,10 +508,12 @@
jint status_;
};
+#ifdef ENABLE_JAVA_WAKE_LOCKS
static bool set_wake_alarm_callout(uint64_t delay_millis, bool should_wake,
alarm_cb cb, void* data) {
JNIThreadAttacher attacher;
JNIEnv* env = attacher.getEnv();
+ jboolean ret = JNI_FALSE;
if (env == nullptr) {
ALOGE("%s: Unable to get JNI Env", __func__);
@@ -522,10 +524,15 @@
sAlarmCallbackData = data;
jboolean jshould_wake = should_wake ? JNI_TRUE : JNI_FALSE;
- jboolean ret =
- env->CallBooleanMethod(sJniAdapterServiceObj, method_setWakeAlarm,
+ if (sJniAdapterServiceObj) {
+ ret = env->CallBooleanMethod(sJniAdapterServiceObj, method_setWakeAlarm,
(jlong)delay_millis, jshould_wake);
+ } else {
+ ALOGE("%s JNI ERROR : JNI reference already cleaned : set_wake_alarm_callout", __func__);
+ }
+
if (!ret) {
+ ALOGE("%s setWakeAlarm failed:ret= %d ", __func__, ret);
sAlarmCallback = NULL;
sAlarmCallbackData = NULL;
}
@@ -546,9 +553,13 @@
{
ScopedLocalRef<jstring> lock_name_jni(env, env->NewStringUTF(lock_name));
if (lock_name_jni.get()) {
- bool acquired = env->CallBooleanMethod(
- sJniAdapterServiceObj, method_acquireWakeLock, lock_name_jni.get());
- if (!acquired) ret = BT_STATUS_WAKELOCK_ERROR;
+ if (sJniAdapterServiceObj) {
+ bool acquired = env->CallBooleanMethod(
+ sJniAdapterServiceObj, method_acquireWakeLock, lock_name_jni.get());
+ if (!acquired) ret = BT_STATUS_WAKELOCK_ERROR;
+ } else {
+ ALOGE("%s JNI ERROR : JNI reference already cleaned : acquire_wake_lock_callout", __func__);
+ }
} else {
ALOGE("%s unable to allocate string: %s", __func__, lock_name);
ret = BT_STATUS_NOMEM;
@@ -571,9 +582,13 @@
{
ScopedLocalRef<jstring> lock_name_jni(env, env->NewStringUTF(lock_name));
if (lock_name_jni.get()) {
- bool released = env->CallBooleanMethod(
- sJniAdapterServiceObj, method_releaseWakeLock, lock_name_jni.get());
- if (!released) ret = BT_STATUS_WAKELOCK_ERROR;
+ if (sJniAdapterServiceObj) {
+ bool released = env->CallBooleanMethod(
+ sJniAdapterServiceObj, method_releaseWakeLock, lock_name_jni.get());
+ if (!released) ret = BT_STATUS_WAKELOCK_ERROR;
+ } else {
+ ALOGE("%s JNI ERROR : JNI reference already cleaned : release_wake_lock_callout", __func__);
+ }
} else {
ALOGE("%s unable to allocate string: %s", __func__, lock_name);
ret = BT_STATUS_NOMEM;
@@ -582,7 +597,7 @@
return ret;
}
-
+#endif
// Called by Java code when alarm is fired. A wake lock is held by the caller
// over the duration of this callback.
static void alarmFiredNative(JNIEnv* env, jobject obj) {
@@ -592,11 +607,12 @@
ALOGE("%s() - Alarm fired with callback not set!", __func__);
}
}
-
+#ifdef ENABLE_JAVA_WAKE_LOCKS
static bt_os_callouts_t sBluetoothOsCallouts = {
sizeof(sBluetoothOsCallouts), set_wake_alarm_callout,
acquire_wake_lock_callout, release_wake_lock_callout,
};
+#endif
#define PROPERTY_BT_LIBRARY_NAME "ro.bluetooth.library_name"
#define DEFAULT_BT_LIBRARY_NAME "libbluetooth.so"
@@ -701,11 +717,14 @@
int ret = sBluetoothInterface->init(&sBluetoothCallbacks,
isGuest == JNI_TRUE ? 1 : 0,
isNiapMode == JNI_TRUE ? 1 : 0);
- if (ret != BT_STATUS_SUCCESS) {
+ if (ret != BT_STATUS_SUCCESS && ret != BT_STATUS_DONE) {
ALOGE("Error while setting the callbacks: %d\n", ret);
sBluetoothInterface = NULL;
return JNI_FALSE;
}
+
+ /*disable these os_callout settings, so that native wake_lock will be enabled*/
+#ifdef ENABLE_JAVA_WAKE_LOCKS
ret = sBluetoothInterface->set_os_callouts(&sBluetoothOsCallouts);
if (ret != BT_STATUS_SUCCESS) {
ALOGE("Error while setting Bluetooth callouts: %d\n", ret);
@@ -713,6 +732,7 @@
sBluetoothInterface = NULL;
return JNI_FALSE;
}
+#endif
sBluetoothSocketInterface =
(btsock_interface_t*)sBluetoothInterface->get_profile_interface(
@@ -1162,6 +1182,11 @@
const char** args = nullptr;
if (numArgs > 0) args = new const char*[numArgs];
+ if (!args || !argObjs) {
+ ALOGE("%s: not have enough memeory", __func__);
+ return;
+ }
+
for (int i = 0; i < numArgs; i++) {
argObjs[i] = (jstring)env->GetObjectArrayElement(argArray, i);
args[i] = env->GetStringUTFChars(argObjs[i], NULL);
@@ -1285,17 +1310,17 @@
/*
* JNI Initialization
*/
-jint JNI_OnLoad(JavaVM* jvm, void* reserved) {
- JNIEnv* e;
- int status;
+jint JNI_OnLoad(JavaVM *jvm, void *reserved) {
+ JNIEnv *e;
+ int status;
- ALOGV("Bluetooth Adapter Service : loading JNI\n");
+ ALOGV("Bluetooth Adapter Service : loading JNI\n");
- // Check JNI version
- if (jvm->GetEnv((void**)&e, JNI_VERSION_1_6)) {
- ALOGE("JNI version mismatch error");
- return JNI_ERR;
- }
+ // Check JNI version
+ if (jvm->GetEnv((void **)&e, JNI_VERSION_1_6)) {
+ ALOGE("JNI version mismatch error");
+ return JNI_ERR;
+ }
status = android::register_com_android_bluetooth_btservice_AdapterService(e);
if (status < 0) {
@@ -1309,6 +1334,12 @@
return JNI_ERR;
}
+ status = android::register_com_android_bluetooth_hfp_vendorhfservice(e);
+ if (status < 0) {
+ ALOGE("jni vendor hfp service registration failure, status: %d", status);
+ return JNI_ERR;
+ }
+
status = android::register_com_android_bluetooth_hfpclient(e);
if (status < 0) {
ALOGE("jni hfp client registration failure, status: %d", status);
@@ -1321,12 +1352,24 @@
return JNI_ERR;
}
+ status = android::register_com_android_bluetooth_ba(e);
+ if (status < 0) {
+ ALOGE("jni BA Transmitter registration failure: %d", status);
+ return JNI_ERR;
+ }
+
status = android::register_com_android_bluetooth_a2dp_sink(e);
if (status < 0) {
ALOGE("jni a2dp sink registration failure: %d", status);
return JNI_ERR;
}
+ status = android::register_com_android_bluetooth_avrcp(e);
+ if (status < 0) {
+ ALOGE("jni avrcp target registration failure: %d", status);
+ return JNI_ERR;
+ }
+
status = android::register_com_android_bluetooth_avrcp_target(e);
if (status < 0) {
ALOGE("jni new avrcp target registration failure: %d", status);
@@ -1368,11 +1411,29 @@
return JNI_ERR;
}
+ status = android::register_com_android_bluetooth_btservice_vendor(e);
+ if (status < 0) {
+ ALOGE("jni vendor registration failure: %d", status);
+ return JNI_ERR;
+ }
+
+ status = android::register_com_android_bluetooth_btservice_vendor_socket(e);
+ if (status < 0) {
+ ALOGE("jni vendor socket registration failure: %d", status);
+ return JNI_ERR;
+ }
+
status = android::register_com_android_bluetooth_hearing_aid(e);
if (status < 0) {
ALOGE("jni hearing aid registration failure: %d", status);
return JNI_ERR;
}
+ status = android::register_com_android_bluetooth_avrcp_ext(e);
+ if (status < 0) {
+ ALOGE("jni avrcp_ext registration failure: %d", status);
+ return JNI_ERR;
+ }
+
return JNI_VERSION_1_6;
}
diff --git a/jni/com_android_bluetooth_gatt.cpp b/jni/com_android_bluetooth_gatt.cpp
index 4521515..29793bf 100644
--- a/jni/com_android_bluetooth_gatt.cpp
+++ b/jni/com_android_bluetooth_gatt.cpp
@@ -201,6 +201,10 @@
void btgattc_register_app_cb(int status, int clientIf, const Uuid& app_uuid) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientRegistered, status,
clientIf, UUID_PARAMS(app_uuid));
}
@@ -213,6 +217,10 @@
std::vector<uint8_t> adv_data) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), bda));
@@ -231,6 +239,10 @@
const RawAddress& bda) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -242,6 +254,10 @@
const RawAddress& bda) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -252,6 +268,10 @@
void btgattc_search_complete_cb(int conn_id, int status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onSearchCompleted, conn_id,
status);
@@ -261,6 +281,10 @@
int status, uint16_t handle) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onRegisterForNotifications,
conn_id, status, registered, handle);
@@ -269,6 +293,10 @@
void btgattc_notify_cb(int conn_id, const btgatt_notify_params_t& p_data) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(
sCallbackEnv.get(), bdaddr2newjstr(sCallbackEnv.get(), &p_data.bda));
@@ -286,6 +314,10 @@
btgatt_read_params_t* p_data) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(), NULL);
if (status == 0) { // Success
@@ -305,6 +337,10 @@
void btgattc_write_characteristic_cb(int conn_id, int status, uint16_t handle) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onWriteCharacteristic,
conn_id, status, handle);
@@ -313,6 +349,10 @@
void btgattc_execute_write_cb(int conn_id, int status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExecuteCompleted,
conn_id, status);
@@ -322,6 +362,10 @@
const btgatt_read_params_t& p_data) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(), NULL);
if (p_data.value.len != 0) {
@@ -339,6 +383,10 @@
void btgattc_write_descriptor_cb(int conn_id, int status, uint16_t handle) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onWriteDescriptor, conn_id,
status, handle);
@@ -348,6 +396,10 @@
int status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -359,6 +411,10 @@
void btgattc_configure_mtu_cb(int conn_id, int status, int mtu) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConfigureMTU, conn_id,
status, mtu);
}
@@ -366,6 +422,10 @@
void btgattc_congestion_cb(int conn_id, bool congested) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientCongestion,
conn_id, congested);
}
@@ -374,6 +434,10 @@
int num_records, std::vector<uint8_t> data) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(),
sCallbackEnv->NewByteArray(data.size()));
sCallbackEnv->SetByteArrayRegion(jb.get(), 0, data.size(),
@@ -386,6 +450,10 @@
void btgattc_batchscan_threshold_cb(int client_if) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj,
method_onBatchScanThresholdCrossed, client_if);
}
@@ -393,6 +461,10 @@
void btgattc_track_adv_event_cb(btgatt_track_adv_info_t* p_adv_track_info) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(
sCallbackEnv.get(),
@@ -496,6 +568,10 @@
int count) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
jclass arrayListclazz = sCallbackEnv->FindClass("java/util/ArrayList");
ScopedLocalRef<jobject> array(
@@ -515,6 +591,10 @@
uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientPhyUpdate, conn_id,
tx_phy, rx_phy, status);
@@ -524,6 +604,10 @@
uint16_t timeout, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientConnUpdate,
conn_id, interval, latency, timeout, status);
@@ -564,6 +648,10 @@
void btgatts_register_app_cb(int status, int server_if, const Uuid& uuid) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerRegistered, status,
server_if, UUID_PARAMS(uuid));
}
@@ -572,6 +660,10 @@
const RawAddress& bda) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -583,6 +675,10 @@
std::vector<btgatt_db_element_t> service) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
jclass arrayListclazz = sCallbackEnv->FindClass("java/util/ArrayList");
ScopedLocalRef<jobject> array(
@@ -601,6 +697,10 @@
void btgatts_service_stopped_cb(int status, int server_if, int srvc_handle) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceStopped, status,
server_if, srvc_handle);
}
@@ -608,6 +708,10 @@
void btgatts_service_deleted_cb(int status, int server_if, int srvc_handle) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServiceDeleted, status,
server_if, srvc_handle);
}
@@ -618,6 +722,10 @@
bool is_long) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -631,6 +739,10 @@
int offset, bool is_long) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -646,6 +758,10 @@
std::vector<uint8_t> value) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -667,6 +783,10 @@
std::vector<uint8_t> value) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -685,6 +805,10 @@
const RawAddress& bda, int exec_write) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -695,6 +819,10 @@
void btgatts_response_confirmation_cb(int status, int handle) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onResponseSendCompleted,
status, handle);
}
@@ -702,6 +830,10 @@
void btgatts_indication_sent_cb(int conn_id, int status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNotificationSent,
conn_id, status);
}
@@ -709,6 +841,10 @@
void btgatts_congestion_cb(int conn_id, bool congested) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerCongestion,
conn_id, congested);
}
@@ -716,6 +852,10 @@
void btgatts_mtu_changed_cb(int conn_id, int mtu) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerMtuChanged,
conn_id, mtu);
}
@@ -724,6 +864,10 @@
uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerPhyUpdate, conn_id,
tx_phy, rx_phy, status);
@@ -733,6 +877,10 @@
uint16_t timeout, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onServerConnUpdate,
conn_id, interval, latency, timeout, status);
@@ -959,6 +1107,10 @@
uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScannerRegistered,
status, scannerId, UUID_PARAMS(app_uuid));
}
@@ -1014,6 +1166,10 @@
uint8_t rx_phy, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -1161,16 +1317,33 @@
void set_scan_params_cmpl_cb(int client_if, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScanParamSetupCompleted,
status, client_if);
}
static void gattSetScanParametersNative(JNIEnv* env, jobject object,
- jint client_if, jint scan_interval_unit,
- jint scan_window_unit) {
+ jint client_if, jint scan_phy,
+ jintArray scan_interval_unit,
+ jintArray scan_window_unit) {
+ std::vector<uint32_t> scan_interval = {0,0};
+ std::vector<uint32_t> scan_window = {0,0};
if (!sGattIf) return;
+
+ int scan_int_cnt = env->GetArrayLength(scan_interval_unit);
+ if(scan_int_cnt > 0) {
+ env->GetIntArrayRegion(scan_interval_unit, 0, scan_int_cnt, (jint *)&scan_interval[0]);
+ }
+
+ int scan_window_cnt = env->GetArrayLength(scan_window_unit);
+ if(scan_window_cnt > 0) {
+ env->GetIntArrayRegion(scan_window_unit, 0, scan_window_cnt, (jint *)&scan_window[0]);
+ }
sGattIf->scanner->SetScanParameters(
- scan_interval_unit, scan_window_unit,
+ scan_phy, scan_interval, scan_window,
base::Bind(&set_scan_params_cmpl_cb, client_if));
}
@@ -1178,6 +1351,10 @@
uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj,
method_onScanFilterParamsConfigured, action,
status, client_if, avbl_space);
@@ -1257,6 +1434,10 @@
uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScanFilterConfig, action,
status, client_if, filt_type, avbl_space);
}
@@ -1296,6 +1477,9 @@
jfieldID companyMaskFid = env->GetFieldID(entryClazz, "company_mask", "I");
jfieldID dataFid = env->GetFieldID(entryClazz, "data", "[B");
jfieldID dataMaskFid = env->GetFieldID(entryClazz, "data_mask", "[B");
+ jfieldID orgFid = env->GetFieldID(entryClazz, "org_id", "I");
+ jfieldID TDSFlagsFid = env->GetFieldID(entryClazz, "tds_flags", "I");
+ jfieldID TDSFlagsMaskFid = env->GetFieldID(entryClazz, "tds_flags_mask", "I");
for (int i = 0; i < numFilters; ++i) {
ApcfCommand curr;
@@ -1365,6 +1549,10 @@
env->ReleaseByteArrayElements(data_mask.get(), data_array, JNI_ABORT);
}
}
+ curr.org_id = env->GetIntField(current.get(), orgFid);
+ curr.tds_flags = env->GetIntField(current.get(), TDSFlagsFid);
+ curr.tds_flags_mask = env->GetIntField(current.get(), TDSFlagsMaskFid);
+
native_filters.push_back(curr);
}
@@ -1382,6 +1570,10 @@
void scan_enable_cb(uint8_t client_if, uint8_t action, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onScanFilterEnableDisabled,
action, status, client_if);
}
@@ -1414,6 +1606,10 @@
void batchscan_cfg_storage_cb(uint8_t client_if, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(
mCallbacksObj, method_onBatchScanStorageConfigured, status, client_if);
}
@@ -1431,6 +1627,10 @@
void batchscan_enable_cb(uint8_t client_if, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onBatchScanStartStopped,
0 /* unused */, status, client_if);
}
@@ -1505,6 +1705,10 @@
uint8_t rx_phy, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mCallbacksObj) {
+ ALOGE("mCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> address(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &bda));
@@ -1782,6 +1986,10 @@
int8_t tx_power, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mAdvertiseCallbacksObj) {
+ ALOGE("mAdvertiseCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
method_onAdvertisingSetStarted, reg_id,
advertiser_id, tx_power, status);
@@ -1791,6 +1999,10 @@
uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mAdvertiseCallbacksObj) {
+ ALOGE("mAdvertiseCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
method_onAdvertisingEnabled, advertiser_id,
false, status);
@@ -1842,6 +2054,10 @@
RawAddress address) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mAdvertiseCallbacksObj) {
+ ALOGE("mAdvertiseCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jstring> addr(sCallbackEnv.get(),
bdaddr2newjstr(sCallbackEnv.get(), &address));
@@ -1860,6 +2076,10 @@
uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mAdvertiseCallbacksObj) {
+ ALOGE("mAdvertiseCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj, method, advertiser_id,
status);
}
@@ -1867,6 +2087,10 @@
static void enableSetCb(uint8_t advertiser_id, bool enable, uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mAdvertiseCallbacksObj) {
+ ALOGE("mAdvertiseCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
method_onAdvertisingEnabled, advertiser_id,
enable, status);
@@ -1906,6 +2130,10 @@
uint8_t status, int8_t tx_power) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mAdvertiseCallbacksObj) {
+ ALOGE("mAdvertiseCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
method_onAdvertisingParametersUpdated,
advertiser_id, tx_power, status);
@@ -1950,6 +2178,10 @@
uint8_t status) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mAdvertiseCallbacksObj) {
+ ALOGE("mAdvertiseCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mAdvertiseCallbacksObj,
method_onPeriodicAdvertisingEnabled,
advertiser_id, enable, status);
@@ -1994,6 +2226,10 @@
uint8_t phy, uint16_t interval) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mPeriodicScanCallbacksObj) {
+ ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncStarted,
reg_id, sync_handle, sid, address_type, address,
@@ -2004,6 +2240,10 @@
uint8_t data_status, std::vector<uint8_t> data) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mPeriodicScanCallbacksObj) {
+ ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");
+ return;
+ }
ScopedLocalRef<jbyteArray> jb(sCallbackEnv.get(),
sCallbackEnv->NewByteArray(data.size()));
@@ -2018,6 +2258,10 @@
static void onSyncLost(uint16_t sync_handle) {
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
+ if (!mPeriodicScanCallbacksObj) {
+ ALOGE("mPeriodicScanCallbacksObj is NULL. Return.");
+ return;
+ }
sCallbackEnv->CallVoidMethod(mPeriodicScanCallbacksObj, method_onSyncLost,
sync_handle);
@@ -2129,7 +2373,7 @@
(void*)gattClientScanFilterClearNative},
{"gattClientScanFilterEnableNative", "(IZ)V",
(void*)gattClientScanFilterEnableNative},
- {"gattSetScanParametersNative", "(III)V",
+ {"gattSetScanParametersNative", "(II[I[I)V",
(void*)gattSetScanParametersNative},
};
diff --git a/jni/com_android_bluetooth_hfp.cpp b/jni/com_android_bluetooth_hfp.cpp
index 16bf961..c3a8ddc 100644
--- a/jni/com_android_bluetooth_hfp.cpp
+++ b/jni/com_android_bluetooth_hfp.cpp
@@ -183,7 +183,7 @@
}
char null_str[] = "";
- if (!sCallbackEnv.isValidUtf(number)) {
+ if (number != nullptr && !sCallbackEnv.isValidUtf(number)) {
android_errorWriteLog(0x534e4554, "109838537");
ALOGE("%s: number is not a valid UTF string.", __func__);
number = null_str;
diff --git a/jni/com_android_bluetooth_hid_host.cpp b/jni/com_android_bluetooth_hid_host.cpp
index 7838ff6..b8f4d65 100644
--- a/jni/com_android_bluetooth_hid_host.cpp
+++ b/jni/com_android_bluetooth_hid_host.cpp
@@ -24,7 +24,7 @@
#include "utils/Log.h"
#include <string.h>
-
+#include <shared_mutex>
namespace android {
static jmethodID method_onConnectStateChanged;
@@ -36,6 +36,7 @@
static const bthh_interface_t* sBluetoothHidInterface = NULL;
static jobject mCallbacksObj = NULL;
+static std::shared_timed_mutex mCallbacks_mutex;
static jbyteArray marshall_bda(RawAddress* bd_addr) {
CallbackEnv sCallbackEnv(__func__);
@@ -53,6 +54,7 @@
static void connection_state_callback(RawAddress* bd_addr,
bthh_connection_state_t state) {
+ std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
if (!mCallbacksObj) {
@@ -72,6 +74,7 @@
static void get_protocol_mode_callback(RawAddress* bd_addr,
bthh_status_t hh_status,
bthh_protocol_mode_t mode) {
+ std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
if (!mCallbacksObj) {
@@ -95,6 +98,7 @@
static void get_report_callback(RawAddress* bd_addr, bthh_status_t hh_status,
uint8_t* rpt_data, int rpt_size) {
+ std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
if (!mCallbacksObj) {
@@ -126,6 +130,7 @@
static void virtual_unplug_callback(RawAddress* bd_addr,
bthh_status_t hh_status) {
ALOGV("call to virtual_unplug_callback");
+ std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
if (!mCallbacksObj) {
@@ -142,6 +147,7 @@
}
static void handshake_callback(RawAddress* bd_addr, bthh_status_t hh_status) {
+ std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
if (!mCallbacksObj) {
@@ -160,6 +166,7 @@
static void get_idle_time_callback(RawAddress* bd_addr, bthh_status_t hh_status,
int idle_time) {
+ std::shared_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
CallbackEnv sCallbackEnv(__func__);
if (!sCallbackEnv.valid()) return;
@@ -198,6 +205,7 @@
}
static void initializeNative(JNIEnv* env, jobject object) {
+ std::unique_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
const bt_interface_t* btInf = getBluetoothInterface();
if (btInf == NULL) {
ALOGE("Bluetooth module is not loaded");
@@ -234,6 +242,7 @@
}
static void cleanupNative(JNIEnv* env, jobject object) {
+ std::unique_lock<std::shared_timed_mutex> lock(mCallbacks_mutex);
const bt_interface_t* btInf = getBluetoothInterface();
if (btInf == NULL) {
diff --git a/res/values-pt-rPT/strings_pbap.xml b/res/values-pt-rPT/strings_pbap.xml
index e0d59cd..49f9855 100644
--- a/res/values-pt-rPT/strings_pbap.xml
+++ b/res/values-pt-rPT/strings_pbap.xml
@@ -13,4 +13,9 @@
<string name="localPhoneName" msgid="2349001318925409159">"O meu nome"</string>
<string name="defaultnumber" msgid="8520116145890867338">"000000"</string>
<string name="pbap_notification_group" msgid="8487669554703627168">"Partilha de contactos por Bluetooth"</string>
+ <string name="remote_pbap_version_change">Alteração remota da versão do perfil da lista telefônica</string>
+ <string name="phonebook_advance_feature_support">Recurso Avançado da Lista Telefônica Suportado</string>
+ <string name="remote_phonebook_feature_downgrade">Downgrade do Recurso da Lista Telefônica Remota</string>
+ <string name="repair_for_adv_phonebook_feature">Re-par para Recurso Avançado Agenda</string>
+ <string name="repair_for_phonebook_access_version_comp">Re-par para compatibilidade de versão de acesso à lista telefônica</string>
</resources>
diff --git a/res/values-pt/strings_pbap.xml b/res/values-pt/strings_pbap.xml
index 46ed715..b9a78ad 100644
--- a/res/values-pt/strings_pbap.xml
+++ b/res/values-pt/strings_pbap.xml
@@ -13,4 +13,9 @@
<string name="localPhoneName" msgid="2349001318925409159">"Meu nome"</string>
<string name="defaultnumber" msgid="8520116145890867338">"000000"</string>
<string name="pbap_notification_group" msgid="8487669554703627168">"Compartilhamento de contato via Bluetooth"</string>
+ <string name="remote_pbap_version_change">Alteração remota da versão do perfil da lista telefônica</string>
+ <string name="phonebook_advance_feature_support">Recurso Avançado da Lista Telefônica Suportado</string>
+ <string name="remote_phonebook_feature_downgrade">Downgrade do Recurso da Lista Telefônica Remota</string>
+ <string name="repair_for_adv_phonebook_feature">Re-par para Recurso Avançado Agenda</string>
+ <string name="repair_for_phonebook_access_version_comp">Re-par para compatibilidade de versão de acesso à lista telefônica</string>
</resources>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index a5f6d2d..9a3a1d3 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -135,4 +135,8 @@
<string name="a2dp_sink_mbs_label" msgid="7566075853395412558">"蓝牙音频"</string>
<string name="bluetooth_opp_file_limit_exceeded" msgid="8894450394309084519">"无法传输 4GB 以上的文件"</string>
<string name="bluetooth_connect_action" msgid="4009848433321657090">"连接到蓝牙"</string>
+ <!-- Bluetooth AVRCP Browsing Dialog-->
+ <string name="bluetooth_rc_feat_title">"蓝牙音频浏览"</string>
+ <string name="bluetooth_rc_feat_content">"对端支持该先进功能"</string>
+ <string name="bluetooth_rc_feat_subtext">"重新配对对端设备使其支持该功能"</string>
</resources>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index c8ece01..343da0b 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -135,4 +135,7 @@
<string name="a2dp_sink_mbs_label" msgid="7566075853395412558">"藍牙音訊"</string>
<string name="bluetooth_opp_file_limit_exceeded" msgid="8894450394309084519">"無法轉移大於 4GB 的檔案"</string>
<string name="bluetooth_connect_action" msgid="4009848433321657090">"使用藍牙連線"</string>
+ <string name="bluetooth_rc_feat_title">"藍芽音頻瀏覽"</string>
+ <string name="bluetooth_rc_feat_content">"對端支持該先進功能"</string>
+ <string name="bluetooth_rc_feat_subtext">"重新配對對端設備使其支持該功能"</string>
</resources>
diff --git a/res/values/config.xml b/res/values/config.xml
index 711993e..7236b2f 100644
--- a/res/values/config.xml
+++ b/res/values/config.xml
@@ -26,11 +26,12 @@
<bool name="pbap_use_profile_for_owner_vcard">true</bool>
<bool name="profile_supported_map">true</bool>
<bool name="profile_supported_avrcp_target">true</bool>
- <bool name="profile_supported_avrcp_controller">false</bool>
- <bool name="profile_supported_sap">false</bool>
+ <bool name="profile_supported_avrcp_controller">true</bool>
+ <bool name="profile_supported_sap">true</bool>
<bool name="profile_supported_pbapclient">false</bool>
<bool name="profile_supported_mapmce">false</bool>
<bool name="profile_supported_hid_device">true</bool>
+ <bool name="profile_supported_ba">false</bool>
<!-- If true, we will require location to be enabled on the device to
fire Bluetooth LE scan result callbacks in addition to having one
@@ -91,9 +92,17 @@
value should be unique. -->
<integer name="a2dp_source_codec_priority_sbc">1001</integer>
<integer name="a2dp_source_codec_priority_aac">2001</integer>
- <integer name="a2dp_source_codec_priority_aptx">3001</integer>
- <integer name="a2dp_source_codec_priority_aptx_hd">4001</integer>
- <integer name="a2dp_source_codec_priority_ldac">5001</integer>
+ <integer name="a2dp_source_codec_priority_ldac">3001</integer>
+ <integer name="a2dp_source_codec_priority_aptx">4001</integer>
+ <integer name="a2dp_source_codec_priority_aptx_hd">5001</integer>
+ <integer name="a2dp_source_codec_priority_aptx_adaptive">6001</integer>
+ <integer name="a2dp_source_codec_priority_aptx_tws">7001</integer>
+ <!-- max priority is used to dynamically increase the priority
+ of codecs(mainly Aptx Adaptive) to highest value based
+ on config
+ Value of a2dp_source_codec_priority_max should be set to
+ 1000 + priority of codec with highest priority-->
+ <integer name="a2dp_source_codec_priority_max">8001</integer>
<!-- Package that is responsible for user interaction on pairing request,
success or cancel.
@@ -108,4 +117,16 @@
<!-- Flag whether or not to keep polling AG with CLCC for call information every 2 seconds -->
<bool name="hfp_clcc_poll_during_call">true</bool>
+ <!-- Reload supported Bluetooth Profiles while BLE is turning ON -->
+ <bool name="reload_supported_profiles_when_enabled">true</bool>
+ <!-- For AVRCP cover art configuration If there is no update from UI
+ these default values would be used to fetch cover art.
+ height and width are to be mentioned in pixels
+ maxsize is to be mentioned in bytes -->
+ <string name="avrcp_cover_art_default_mimetype">JPEG</string>
+ <string name="avrcp_cover_art_default_image_type">image</string>
+ <integer name="avrcp_cover_art_default_height">500</integer>
+ <integer name="avrcp_cover_art_default_width">500</integer>
+ <integer name="avrcp_cover_art_default_maxsize">200000</integer>
+
</resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 0204f98..cb608a7 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -245,9 +245,20 @@
<string name="bluetooth_map_settings_app_icon">Application Icon</string>
<string name="bluetooth_map_settings_title">Bluetooth Message Sharing Settings</string>
<string name="bluetooth_map_settings_no_account_slots_left">Cannot select account. 0 slots left</string>
+ <!-- MAP version upgrade / down grade -->
+ <string name="bluetooth_map_remote_advance_feature_support">Message access Advance Feature Supported</string>
+ <string name="bluetooth_map_remote_message_access_feature_downgrade">Remote Message access Feature Downgrade</string>
+ <string name="bluetooth_map_repair_for_adv_message_access_feature">Re-pair for Advance Message access Feature</string>
+ <string name="bluetooth_map_repair_for_message_access_version_comp">Re-pair for Message access Version Compatibility</string>
<string name="bluetooth_connected">Bluetooth audio connected</string>
<string name="bluetooth_disconnected">Bluetooth audio disconnected"</string>
<string name="a2dp_sink_mbs_label">Bluetooth Audio</string>
<string name="bluetooth_opp_file_limit_exceeded">Files bigger than 4GB cannot be transferred</string>
<string name="bluetooth_connect_action">Connect to Bluetooth</string>
+ <!-- Bluetooth AVRCP Browsing Dialog and Notification-->
+ <string name="avrcp_notification_name">BT ADVANCE FEATURE AVRCP</string>
+ <string name="bluetooth_advanced_feat_description">Bluetooth Advanced Browsing Feature</string>
+ <string name="bluetooth_rc_feat_title">Bluetooth Media Browsing</string>
+ <string name="bluetooth_rc_feat_content">Peer supports advanced feature</string>
+ <string name="bluetooth_rc_feat_subtext">Re-pair from peer to enable it</string>
</resources>
diff --git a/res/values/strings_pbap.xml b/res/values/strings_pbap.xml
index bb2586c..abe0686 100644
--- a/res/values/strings_pbap.xml
+++ b/res/values/strings_pbap.xml
@@ -14,4 +14,9 @@
<string name="localPhoneName">My name</string>
<string name="defaultnumber">000000</string>
<string name="pbap_notification_group">Bluetooth Contact share</string>
+ <string name="remote_pbap_version_change">Remote Phonebook Profile Version Change</string>
+ <string name="phonebook_advance_feature_support">Phonebook Advance Feature Supported</string>
+ <string name="remote_phonebook_feature_downgrade">Remote Phonebook Feature Downgrade</string>
+ <string name="repair_for_adv_phonebook_feature">Re-pair for Advance Phonebook Feature</string>
+ <string name="repair_for_phonebook_access_version_comp">Re-pair for Phonebook Access Version Compatibility</string>
</resources>
diff --git a/src/com/android/bluetooth/ObexServerSockets.java b/src/com/android/bluetooth/ObexServerSockets.java
index 789f12f..4991038 100644
--- a/src/com/android/bluetooth/ObexServerSockets.java
+++ b/src/com/android/bluetooth/ObexServerSockets.java
@@ -81,19 +81,33 @@
}
/**
- * Creates an Insecure RFCOMM {@link BluetoothServerSocket} and a L2CAP
- * {@link BluetoothServerSocket}
+ * Creates a fixed Insecure RFCOMM {@link BluetoothServerSocket} and a L2CAP
+ * {@link BluetoothServerSocket}
* @param validator a reference to the {@link IObexConnectionHandler} object to call
* to validate an incoming connection.
+ * @param rfcommChannel is a fixed RFCOMM channnel to allocate
+ * @param l2capPsm is a fixed L2CAP PSM to allocate
* @return a reference to a {@link ObexServerSockets} object instance.
* @throws IOException if it occurs while creating the {@link BluetoothServerSocket}s.
*/
- public static ObexServerSockets createInsecure(IObexConnectionHandler validator) {
- return create(validator, BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP,
- BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP, false);
+ public static ObexServerSockets createInsecureWithFixedChannels(IObexConnectionHandler
+ validator, int rfcommChannel, int l2capPsm) {
+ return create(validator, rfcommChannel, l2capPsm , false);
}
-
private static final int CREATE_RETRY_TIME = 10;
+ /**
+ * Creates an RFCOMM {@link BluetoothServerSocket} and a L2CAP {@link BluetoothServerSocket}
+ * @param validator a reference to the {@link IObexConnectionHandler} object to call
+ * to validate an incoming connection.
+ * @param rfcommChannel fixed rfcomm channel number to listen on
+ * @param l2capPsm fixed l2cap psm to listen on
+ * @return a reference to a {@link ObexServerSockets} object instance.
+ * @throws IOException if it occurs while creating the {@link BluetoothServerSocket}s.
+ */
+ public static ObexServerSockets createWithFixedChannels(IObexConnectionHandler validator,
+ int rfcommChannel, int l2capPsm) {
+ return create(validator, rfcommChannel, l2capPsm, true);
+ }
/**
* Creates an RFCOMM {@link BluetoothServerSocket} and a L2CAP {@link BluetoothServerSocket}
@@ -126,14 +140,14 @@
for (int i = 0; i < CREATE_RETRY_TIME; i++) {
initSocketOK = true;
try {
- if (rfcommSocket == null) {
+ if (rfcommSocket == null && rfcommChannel != -1) {
if (isSecure) {
rfcommSocket = bt.listenUsingRfcommOn(rfcommChannel);
} else {
rfcommSocket = bt.listenUsingInsecureRfcommOn(rfcommChannel);
}
}
- if (l2capSocket == null) {
+ if (l2capSocket == null && l2capPsm != -1) {
if (isSecure) {
l2capSocket = bt.listenUsingL2capOn(l2capPsm);
} else {
@@ -143,6 +157,10 @@
} catch (IOException e) {
Log.e(STAG, "Error create ServerSockets ", e);
initSocketOK = false;
+ } catch (SecurityException e) {
+ Log.e(STAG, "Error create ServerSockets ", e);
+ initSocketOK = false;
+ break;
}
if (!initSocketOK) {
// Need to break out of this loop if BT is being turned off.
@@ -205,12 +223,15 @@
if (D) {
Log.d(mTag, "startAccept()");
}
+ if (mRfcommSocket != null) {
+ mRfcommThread = new SocketAcceptThread(mRfcommSocket);
+ mRfcommThread.start();
+ }
- mRfcommThread = new SocketAcceptThread(mRfcommSocket);
- mRfcommThread.start();
-
- mL2capThread = new SocketAcceptThread(mL2capSocket);
- mL2capThread.start();
+ if (mL2capSocket != null) {
+ mL2capThread = new SocketAcceptThread(mL2capSocket);
+ mL2capThread.start();
+ }
}
/**
@@ -221,7 +242,10 @@
*/
private synchronized boolean onConnect(BluetoothDevice device, BluetoothSocket conSocket) {
if (D) {
- Log.d(mTag, "onConnect() socket: " + conSocket);
+ Log.d(mTag, "onConnect() socket: " + conSocket + " mConHandler " + mConHandler);
+ }
+ if (mConHandler == null) {
+ return false;
}
return mConHandler.onConnect(device, conSocket);
}
@@ -232,7 +256,8 @@
private synchronized void onAcceptFailed() {
shutdown(false);
BluetoothAdapter mAdapter = BluetoothAdapter.getDefaultAdapter();
- if ((mAdapter != null) && (mAdapter.getState() == BluetoothAdapter.STATE_ON)) {
+ if ((mAdapter != null) && (mAdapter.getState() == BluetoothAdapter.STATE_ON)
+ && mConHandler != null) {
Log.d(mTag, "onAcceptFailed() calling shutdown...");
mConHandler.onAcceptFailed();
}
diff --git a/src/com/android/bluetooth/Utils.java b/src/com/android/bluetooth/Utils.java
index bf68b35..2052483 100644
--- a/src/com/android/bluetooth/Utils.java
+++ b/src/com/android/bluetooth/Utils.java
@@ -67,6 +67,7 @@
}
public static byte[] getByteAddress(BluetoothDevice device) {
+ if (device == null) return new byte[BD_ADDR_LEN];
return getBytesFromAddress(device.getAddress());
}
@@ -401,10 +402,6 @@
== PackageManager.PERMISSION_GRANTED;
}
- public static boolean isLegacyForegroundApp(Context context, String pkgName) {
- return !isMApp(context, pkgName) && isForegroundApp(context, pkgName);
- }
-
private static boolean isMApp(Context context, String pkgName) {
try {
return context.getPackageManager().getApplicationInfo(pkgName, 0).targetSdkVersion
@@ -424,16 +421,6 @@
}
return true;
}
- /**
- * Return true if the specified package name is a foreground app.
- *
- * @param pkgName application package name.
- */
- private static boolean isForegroundApp(Context context, String pkgName) {
- ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
- List<ActivityManager.RunningTaskInfo> tasks = am.getRunningTasks(1);
- return !tasks.isEmpty() && pkgName.equals(tasks.get(0).topActivity.getPackageName());
- }
private static boolean isAppOppAllowed(AppOpsManager appOps, int op, String callingPackage) {
return appOps.noteOp(op, Binder.getCallingUid(), callingPackage)
diff --git a/src/com/android/bluetooth/a2dp/A2dpCodecConfig.java b/src/com/android/bluetooth/a2dp/A2dpCodecConfig.java
index 8127e76..f6d42ea 100644
--- a/src/com/android/bluetooth/a2dp/A2dpCodecConfig.java
+++ b/src/com/android/bluetooth/a2dp/A2dpCodecConfig.java
@@ -22,9 +22,10 @@
import android.content.Context;
import android.content.res.Resources;
import android.content.res.Resources.NotFoundException;
+import android.os.SystemProperties;
import android.util.Log;
-
import com.android.bluetooth.R;
+import com.android.bluetooth.btservice.AdapterService;
import java.util.Arrays;
import java.util.Objects;
@@ -43,8 +44,10 @@
private int mA2dpSourceCodecPriorityAac = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
private int mA2dpSourceCodecPriorityAptx = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
private int mA2dpSourceCodecPriorityAptxHd = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
+ private int mA2dpSourceCodecPriorityAptxAdaptive = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
private int mA2dpSourceCodecPriorityLdac = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
-
+ private int mA2dpSourceCodecPriorityAptxTwsp = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
+ private int assigned_codec_length = 0;
A2dpCodecConfig(Context context, A2dpNativeInterface a2dpNativeInterface) {
mContext = context;
mA2dpNativeInterface = a2dpNativeInterface;
@@ -105,7 +108,7 @@
}
// Set the mandatory codec's priority to default, and remove the rest
- for (int i = 0; i < codecConfigArray.length; i++) {
+ for (int i = 0; i < assigned_codec_length; i++) {
BluetoothCodecConfig codecConfig = codecConfigArray[i];
if (!codecConfig.isMandatoryCodec()) {
codecConfigArray[i] = null;
@@ -126,7 +129,7 @@
return;
}
// Set the mandatory codec's priority to highest, and remove the rest
- for (int i = 0; i < codecConfigArray.length; i++) {
+ for (int i = 0; i < assigned_codec_length; i++) {
BluetoothCodecConfig codecConfig = codecConfigArray[i];
if (codecConfig.isMandatoryCodec()) {
codecConfig.setCodecPriority(BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST);
@@ -160,6 +163,8 @@
}
int value;
+ AdapterService mAdapterService = AdapterService.getAdapterService();
+ String a2dp_offload_cap = mAdapterService.getA2apOffloadCapability();
try {
value = resources.getInteger(R.integer.a2dp_source_codec_priority_sbc);
} catch (NotFoundException e) {
@@ -168,6 +173,10 @@
if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value
< BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {
mA2dpSourceCodecPrioritySbc = value;
+ if (a2dp_offload_cap != null && !a2dp_offload_cap.isEmpty() &&
+ !a2dp_offload_cap.contains("sbc")) {
+ mA2dpSourceCodecPrioritySbc = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
+ }
}
try {
@@ -178,6 +187,10 @@
if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value
< BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {
mA2dpSourceCodecPriorityAac = value;
+ if (a2dp_offload_cap != null && !a2dp_offload_cap.isEmpty() &&
+ !a2dp_offload_cap.contains("aac")) {
+ mA2dpSourceCodecPriorityAac = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
+ }
}
try {
@@ -188,62 +201,146 @@
if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value
< BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {
mA2dpSourceCodecPriorityAptx = value;
+ if (a2dp_offload_cap != null && !a2dp_offload_cap.isEmpty() &&
+ !a2dp_offload_cap.contains("aptx")) {
+ mA2dpSourceCodecPriorityAptx = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
+ }
+ }
+ if(mAdapterService.isSplitA2DPSourceAPTXADAPTIVE()) {
+ try {
+ value = resources.getInteger(R.integer.a2dp_source_codec_priority_aptx_adaptive);
+ } catch (NotFoundException e) {
+ value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
+ }
+ if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value
+ < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {
+ if (a2dp_offload_cap != null && !a2dp_offload_cap.isEmpty()) {
+ if(a2dp_offload_cap.contains("aptxadaptiver2")) {
+ int aptxaa_r2_priority;
+ try {
+ aptxaa_r2_priority = resources.getInteger(R.integer.a2dp_source_codec_priority_max);
+ } catch (NotFoundException e) {
+ aptxaa_r2_priority = value;
+ }
+ value = aptxaa_r2_priority;
+ } else if(!a2dp_offload_cap.contains("aptxadaptive")) {
+ value = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
+ Log.w(TAG, "Disable Aptx Adaptive. Entry not present in offload property");
+ }
+ }
+ mA2dpSourceCodecPriorityAptxAdaptive = value;
+ Log.i(TAG, "Aptx Adaptive priority: " + mA2dpSourceCodecPriorityAptxAdaptive);
+ }
+ } else {
+ mA2dpSourceCodecPriorityAptxAdaptive = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
}
- try {
- value = resources.getInteger(R.integer.a2dp_source_codec_priority_aptx_hd);
- } catch (NotFoundException e) {
- value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
- }
- if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value
- < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {
- mA2dpSourceCodecPriorityAptxHd = value;
+ if(mAdapterService.isSplitA2DPSourceAPTXHD()) {
+ try {
+ value = resources.getInteger(R.integer.a2dp_source_codec_priority_aptx_hd);
+ } catch (NotFoundException e) {
+ value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
+ }
+ if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value
+ < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {
+ mA2dpSourceCodecPriorityAptxHd = value;
+ if (a2dp_offload_cap != null && !a2dp_offload_cap.isEmpty() &&
+ !a2dp_offload_cap.contains("aptxhd")) {
+ mA2dpSourceCodecPriorityAptxHd = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
+ }
+ }
+ } else {
+ mA2dpSourceCodecPriorityAptxHd = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
}
- try {
- value = resources.getInteger(R.integer.a2dp_source_codec_priority_ldac);
- } catch (NotFoundException e) {
- value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
+
+ if(mAdapterService.isSplitA2DPSourceLDAC()) {
+ try {
+ value = resources.getInteger(R.integer.a2dp_source_codec_priority_ldac);
+ } catch (NotFoundException e) {
+ value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
+ }
+ if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value
+ < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {
+ mA2dpSourceCodecPriorityLdac = value;
+ if (a2dp_offload_cap != null && !a2dp_offload_cap.isEmpty() &&
+ !a2dp_offload_cap.contains("ldac")) {
+ mA2dpSourceCodecPriorityLdac = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
+ }
+ }
+ } else {
+ mA2dpSourceCodecPriorityLdac = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
}
- if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value
- < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {
- mA2dpSourceCodecPriorityLdac = value;
+ if (mAdapterService.isVendorIntfEnabled()) {
+ try {
+ value = resources.getInteger(R.integer.a2dp_source_codec_priority_aptx_tws);
+ } catch (NotFoundException e) {
+ value = BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT;
+ }
+ if ((value >= BluetoothCodecConfig.CODEC_PRIORITY_DISABLED) && (value
+ < BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST)) {
+ mA2dpSourceCodecPriorityAptxTwsp = value;
+ if (a2dp_offload_cap != null && !a2dp_offload_cap.isEmpty() &&
+ !a2dp_offload_cap.contains("aptxtws")) {
+ mA2dpSourceCodecPriorityAptxTwsp = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
+ }
+ }
+ } else {
+ mA2dpSourceCodecPriorityAptxTwsp = BluetoothCodecConfig.CODEC_PRIORITY_DISABLED;
}
BluetoothCodecConfig codecConfig;
- BluetoothCodecConfig[] codecConfigArray =
+ BluetoothCodecConfig[] codecConfigArray;
+ int codecCount = 0;
+ codecConfigArray =
new BluetoothCodecConfig[BluetoothCodecConfig.SOURCE_CODEC_TYPE_MAX];
+
codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_SBC,
mA2dpSourceCodecPrioritySbc, BluetoothCodecConfig.SAMPLE_RATE_NONE,
BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig
.CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,
0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);
- codecConfigArray[0] = codecConfig;
+ codecConfigArray[codecCount++] = codecConfig;
codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_AAC,
mA2dpSourceCodecPriorityAac, BluetoothCodecConfig.SAMPLE_RATE_NONE,
BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig
.CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,
0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);
- codecConfigArray[1] = codecConfig;
+ codecConfigArray[codecCount++] = codecConfig;
codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX,
mA2dpSourceCodecPriorityAptx, BluetoothCodecConfig.SAMPLE_RATE_NONE,
BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig
.CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,
0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);
- codecConfigArray[2] = codecConfig;
+ codecConfigArray[codecCount++] = codecConfig;
codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_HD,
mA2dpSourceCodecPriorityAptxHd, BluetoothCodecConfig.SAMPLE_RATE_NONE,
BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig
.CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,
0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);
- codecConfigArray[3] = codecConfig;
+ codecConfigArray[codecCount++] = codecConfig;
codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC,
mA2dpSourceCodecPriorityLdac, BluetoothCodecConfig.SAMPLE_RATE_NONE,
BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig
.CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,
0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);
- codecConfigArray[4] = codecConfig;
+ codecConfigArray[codecCount++] = codecConfig;
+ if (mAdapterService.isVendorIntfEnabled()) {
+ codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_TWSP,
+ mA2dpSourceCodecPriorityAptxTwsp, BluetoothCodecConfig.SAMPLE_RATE_NONE,
+ BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig
+ .CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,
+ 0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);
+ codecConfigArray[codecCount++] = codecConfig;
+ }
+ codecConfig = new BluetoothCodecConfig(BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_ADAPTIVE,
+ mA2dpSourceCodecPriorityAptxAdaptive, BluetoothCodecConfig.SAMPLE_RATE_NONE,
+ BluetoothCodecConfig.BITS_PER_SAMPLE_NONE, BluetoothCodecConfig
+ .CHANNEL_MODE_NONE, 0 /* codecSpecific1 */,
+ 0 /* codecSpecific2 */, 0 /* codecSpecific3 */, 0 /* codecSpecific4 */);
+ codecConfigArray[codecCount++] = codecConfig;
+ assigned_codec_length = codecCount;
return codecConfigArray;
}
}
diff --git a/src/com/android/bluetooth/a2dp/A2dpNativeInterface.java b/src/com/android/bluetooth/a2dp/A2dpNativeInterface.java
index cbdc28a..2c5c713 100644
--- a/src/com/android/bluetooth/a2dp/A2dpNativeInterface.java
+++ b/src/com/android/bluetooth/a2dp/A2dpNativeInterface.java
@@ -26,6 +26,7 @@
import android.bluetooth.BluetoothCodecStatus;
import android.bluetooth.BluetoothDevice;
import android.util.Log;
+import java.util.List;
import com.android.bluetooth.Utils;
import com.android.internal.annotations.GuardedBy;
@@ -75,8 +76,9 @@
* @param codecConfigPriorities an array with the codec configuration
* priorities to configure.
*/
- public void init(int maxConnectedAudioDevices, BluetoothCodecConfig[] codecConfigPriorities) {
- initNative(maxConnectedAudioDevices, codecConfigPriorities);
+ public void init(int maxConnectedAudioDevices, BluetoothCodecConfig[] codecConfigPriorities,
+ BluetoothCodecConfig[] codecConfigOffload) {
+ initNative(maxConnectedAudioDevices, codecConfigPriorities, codecConfigOffload);
}
/**
@@ -205,7 +207,8 @@
// Native methods that call into the JNI interface
private static native void classInitNative();
private native void initNative(int maxConnectedAudioDevices,
- BluetoothCodecConfig[] codecConfigPriorities);
+ BluetoothCodecConfig[] codecConfigPriorities,
+ BluetoothCodecConfig[] codecConfigOffload);
private native void cleanupNative();
private native boolean connectA2dpNative(byte[] address);
private native boolean disconnectA2dpNative(byte[] address);
diff --git a/src/com/android/bluetooth/a2dp/A2dpService.java b/src/com/android/bluetooth/a2dp/A2dpService.java
old mode 100644
new mode 100755
index cebf767..38ba2d6
--- a/src/com/android/bluetooth/a2dp/A2dpService.java
+++ b/src/com/android/bluetooth/a2dp/A2dpService.java
@@ -23,6 +23,7 @@
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothUuid;
import android.bluetooth.IBluetoothA2dp;
+import com.android.bluetooth.a2dpsink.A2dpSinkService;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
@@ -32,12 +33,22 @@
import android.util.Log;
import android.util.StatsLog;
+import android.os.Handler;
+import android.os.Message;
+import android.os.SystemClock;
+import android.os.SystemProperties;
+
import com.android.bluetooth.BluetoothMetricsProto;
import com.android.bluetooth.Utils;
+import com.android.bluetooth.avrcp.Avrcp;
+import com.android.bluetooth.avrcp.Avrcp_ext;
+import com.android.bluetooth.avrcp.AvrcpTargetService;
import com.android.bluetooth.btservice.AdapterService;
import com.android.bluetooth.btservice.MetricsLogger;
import com.android.bluetooth.btservice.ProfileService;
import com.android.bluetooth.btservice.ServiceFactory;
+import com.android.bluetooth.ba.BATService;
+import com.android.bluetooth.gatt.GattService;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
@@ -46,6 +57,7 @@
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* Provides Bluetooth A2DP profile, as a service in the Bluetooth application.
@@ -54,11 +66,25 @@
public class A2dpService extends ProfileService {
private static final boolean DBG = true;
private static final String TAG = "A2dpService";
+ private static final String A2DP_CONCURRENCY_SUPPORTED_PROPERTY =
+ "persist.vendor.service.bt.a2dp_concurrency";
private static A2dpService sA2dpService;
+ private static A2dpSinkService sA2dpSinkService;
+ private static boolean mA2dpSrcSnkConcurrency;
+ private static boolean a2dpMulticast = false;
private AdapterService mAdapterService;
private HandlerThread mStateMachinesThread;
+ private Avrcp mAvrcp;
+ private Avrcp_ext mAvrcp_ext;
+ private final Object mBtA2dpLock = new Object();
+ private final Object mBtTwsLock = new Object();
+ private final Object mBtAvrcpLock = new Object();
+ private final Object mActiveDeviceLock = new Object();
+ private final Object mVariableLock = new Object();
+ private final ReentrantReadWriteLock mA2dpNativeInterfaceLock = new ReentrantReadWriteLock();
+ private final Object mAudioManagerLock = new Object();
@VisibleForTesting
A2dpNativeInterface mA2dpNativeInterface;
@@ -71,16 +97,68 @@
private BluetoothDevice mActiveDevice;
private final ConcurrentMap<BluetoothDevice, A2dpStateMachine> mStateMachines =
new ConcurrentHashMap<>();
+ private static final int[] CONNECTING_CONNECTED_STATES = {
+ BluetoothProfile.STATE_CONNECTING, BluetoothProfile.STATE_CONNECTED
+ };
// Upper limit of all A2DP devices: Bonded or Connected
private static final int MAX_A2DP_STATE_MACHINES = 50;
// Upper limit of all A2DP devices that are Connected or Connecting
private int mMaxConnectedAudioDevices = 1;
+ private int mSetMaxConnectedAudioDevices = 1;
// A2DP Offload Enabled in platform
boolean mA2dpOffloadEnabled = false;
-
+ private boolean disconnectExisting = false;
+ private int EVENT_TYPE_NONE = 0;
+ private int mA2dpStackEvent = EVENT_TYPE_NONE;
private BroadcastReceiver mBondStateChangedReceiver;
private BroadcastReceiver mConnectionStateChangedReceiver;
+ private boolean mIsTwsPlusEnabled = false;
+ private boolean mIsTwsPlusMonoSupported = false;
+ private String mTwsPlusChannelMode = "dual-mono";
+ private BluetoothDevice mDummyDevice = null;
+ private static final int max_tws_connection = 2;
+ private static final int min_tws_connection = 1;
+
+ private static final int APTX_HQ = 0x1000;
+ private static final int APTX_LL = 0x2000;
+ private static final int APTX_ULL = 0x6000;
+ private static final long APTX_MODE_MASK = 0x7000;
+ private static final long APTX_SCAN_FILTER_MASK = 0x8000;
+
+ private static final int SET_EBMONO_CFG = 1;
+ private static final int SET_EBDUALMONO_CFG = 2;
+ private static final int MonoCfg_Timeout = 3000;
+ private static final int DualMonoCfg_Timeout = 3000;
+
+ private Handler mHandler = new Handler() {
+ @Override
+ public void handleMessage(Message msg)
+ {
+ synchronized(mBtTwsLock) {
+ switch (msg.what) {
+ case SET_EBMONO_CFG:
+ Log.d(TAG, "setparameters to Mono");
+ synchronized (mAudioManagerLock) {
+ if(mAudioManager != null)
+ mAudioManager.setParameters("TwsChannelConfig=mono");
+ }
+ mTwsPlusChannelMode = "mono";
+ break;
+ case SET_EBDUALMONO_CFG:
+ Log.d(TAG, "setparameters to Dual-Mono");
+ synchronized (mAudioManagerLock) {
+ if(mAudioManager != null)
+ mAudioManager.setParameters("TwsChannelConfig=dual-mono");
+ }
+ mTwsPlusChannelMode = "dual-mono";
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ };
@Override
protected IProfileServiceBinder initBinder() {
@@ -96,42 +174,104 @@
protected boolean start() {
Log.i(TAG, "start()");
if (sA2dpService != null) {
- throw new IllegalStateException("start() called twice");
+ Log.w(TAG, "A2dpService is already running");
+ return true;
}
// Step 1: Get AdapterService, A2dpNativeInterface, AudioManager.
// None of them can be null.
- mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(),
+ synchronized (mVariableLock) {
+ mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(),
"AdapterService cannot be null when A2dpService starts");
- mA2dpNativeInterface = Objects.requireNonNull(A2dpNativeInterface.getInstance(),
+ }
+ try {
+ mA2dpNativeInterfaceLock.writeLock().lock();
+ mA2dpNativeInterface = Objects.requireNonNull(A2dpNativeInterface.getInstance(),
"A2dpNativeInterface cannot be null when A2dpService starts");
- mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
- Objects.requireNonNull(mAudioManager,
+ } finally {
+ mA2dpNativeInterfaceLock.writeLock().unlock();
+ }
+ BluetoothCodecConfig[] OffloadCodecConfig;
+
+ synchronized (mAudioManagerLock) {
+ mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
+ Objects.requireNonNull(mAudioManager,
"AudioManager cannot be null when A2dpService starts");
-
- // Step 2: Get maximum number of connected audio devices
- mMaxConnectedAudioDevices = mAdapterService.getMaxConnectedAudioDevices();
- Log.i(TAG, "Max connected audio devices set to " + mMaxConnectedAudioDevices);
-
- // Step 3: Start handler thread for state machines
- mStateMachines.clear();
- mStateMachinesThread = new HandlerThread("A2dpService.StateMachines");
- mStateMachinesThread.start();
-
- // Step 4: Setup codec config
- mA2dpCodecConfig = new A2dpCodecConfig(this, mA2dpNativeInterface);
-
- // Step 5: Initialize native interface
- mA2dpNativeInterface.init(mMaxConnectedAudioDevices,
- mA2dpCodecConfig.codecConfigPriorities());
-
- // Step 6: Check if A2DP is in offload mode
- mA2dpOffloadEnabled = mAdapterService.isA2dpOffloadEnabled();
- if (DBG) {
- Log.d(TAG, "A2DP offload flag set to " + mA2dpOffloadEnabled);
}
- // Step 7: Setup broadcast receivers
+ synchronized (mVariableLock) {
+ // Step 2: Get maximum number of connected audio devices
+ mMaxConnectedAudioDevices = mAdapterService.getMaxConnectedAudioDevices();
+ mSetMaxConnectedAudioDevices = mMaxConnectedAudioDevices;
+ Log.i(TAG, "Max connected audio devices set to " + mMaxConnectedAudioDevices);
+ if (mAdapterService != null && mAdapterService.isVendorIntfEnabled()) {
+ String twsPlusEnabled = SystemProperties.get("persist.vendor.btstack.enable.twsplus");
+ if (!twsPlusEnabled.isEmpty() && "true".equals(twsPlusEnabled)) {
+ mIsTwsPlusEnabled = true;
+ }
+ Log.i(TAG, "mMaxConnectedAudioDevices: " + mMaxConnectedAudioDevices);
+ String twsShoEnabled = SystemProperties.get("persist.vendor.btstack.enable.twsplussho");
+ if (!twsShoEnabled.isEmpty() && "true".equals(twsShoEnabled) &&
+ (mIsTwsPlusEnabled == true) && mMaxConnectedAudioDevices <= 2) {
+ mMaxConnectedAudioDevices = 3;
+ Log.i(TAG, "TWS+ SHO enabled mMaxConnectedAudioDevices changed to: " + mMaxConnectedAudioDevices);
+ } else if (mIsTwsPlusEnabled && mMaxConnectedAudioDevices < 2) {
+ mMaxConnectedAudioDevices = 2;
+ Log.i(TAG, "TWS+ enabled mMaxConnectedAudioDevices changed to: " + mMaxConnectedAudioDevices);
+ }
+ mSetMaxConnectedAudioDevices = mMaxConnectedAudioDevices;
+ String twsPlusMonoEnabled = SystemProperties.get("persist.vendor.btstack.twsplus.monosupport");
+ if (!twsPlusMonoEnabled.isEmpty() && "true".equals(twsPlusMonoEnabled)) {
+ mIsTwsPlusMonoSupported = true;
+ }
+ String TwsPlusChannelMode = SystemProperties.get("persist.vendor.btstack.twsplus.defaultchannelmode");
+ if (!TwsPlusChannelMode.isEmpty() && "mono".equals(TwsPlusChannelMode)) {
+ mTwsPlusChannelMode = "mono";
+ }
+ Log.d(TAG, "Default TwsPlus ChannelMode: " + mTwsPlusChannelMode);
+ }
+
+ // Step 3: Setup AVRCP
+ if(mAdapterService != null && mAdapterService.isVendorIntfEnabled())
+ mAvrcp_ext = Avrcp_ext.make(this, this, mMaxConnectedAudioDevices);
+ else
+ mAvrcp = Avrcp.make(this);
+
+ // Step 4: Start handler thread for state machines
+ mStateMachines.clear();
+ mStateMachinesThread = new HandlerThread("A2dpService.StateMachines");
+ mStateMachinesThread.start();
+
+ // Step 5: Setup codec config
+ mA2dpCodecConfig = new A2dpCodecConfig(this, mA2dpNativeInterface);
+ }
+
+ synchronized (mAudioManagerLock) {
+ // Step 6: Initialize native interface
+ List<BluetoothCodecConfig> mCodecConfigOffload;
+ mCodecConfigOffload = mAudioManager.getHwOffloadEncodingFormatsSupportedForA2DP();
+ OffloadCodecConfig = new BluetoothCodecConfig[mCodecConfigOffload.size()];
+ OffloadCodecConfig = mCodecConfigOffload.toArray(OffloadCodecConfig);
+ }
+
+ try {
+ mA2dpNativeInterfaceLock.writeLock().lock();
+ if (mA2dpNativeInterface != null)
+ mA2dpNativeInterface.init(mMaxConnectedAudioDevices,
+ mA2dpCodecConfig.codecConfigPriorities(),OffloadCodecConfig);
+ } finally {
+ mA2dpNativeInterfaceLock.writeLock().unlock();
+ }
+
+ synchronized (mVariableLock) {
+ // Step 7: Check if A2DP is in offload mode
+ mA2dpOffloadEnabled = mAdapterService.isA2dpOffloadEnabled();
+ if (DBG) {
+ Log.d(TAG, "A2DP offload flag set to " + mA2dpOffloadEnabled);
+ }
+ }
+
+ // Step 8: Setup broadcast receivers
IntentFilter filter = new IntentFilter();
filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
mBondStateChangedReceiver = new BondStateChangedReceiver();
@@ -141,12 +281,21 @@
mConnectionStateChangedReceiver = new ConnectionStateChangedReceiver();
registerReceiver(mConnectionStateChangedReceiver, filter);
- // Step 8: Mark service as started
+ // Step 9: Mark service as started
setA2dpService(this);
- // Step 9: Clear active device
+ // Step 10: Clear active device
setActiveDevice(null);
+ // Step 11: Check if A2DP is in concurrency mode
+ mA2dpSrcSnkConcurrency = SystemProperties.getBoolean(A2DP_CONCURRENCY_SUPPORTED_PROPERTY, false);
+ if (DBG) {
+ Log.d(TAG, "A2DP concurrency mode set to " + mA2dpSrcSnkConcurrency);
+ }
+ a2dpMulticast = SystemProperties.getBoolean("persist.vendor.service.bt.a2dp_multicast_enable", false);
+ if (DBG) {
+ Log.d(TAG, "A2DP Multicast flag set to " + a2dpMulticast);
+ }
return true;
}
@@ -160,7 +309,6 @@
// Step 9: Clear active device and stop playing audio
removeActiveDevice(true);
-
// Step 8: Mark service as stopped
setA2dpService(null);
@@ -169,16 +317,20 @@
mConnectionStateChangedReceiver = null;
unregisterReceiver(mBondStateChangedReceiver);
mBondStateChangedReceiver = null;
-
// Step 6: Cleanup native interface
- mA2dpNativeInterface.cleanup();
- mA2dpNativeInterface = null;
+ try {
+ mA2dpNativeInterfaceLock.writeLock().lock();
+ if (mA2dpNativeInterface != null)
+ mA2dpNativeInterface.cleanup();
+ } finally {
+ mA2dpNativeInterfaceLock.writeLock().unlock();
+ }
// Step 5: Clear codec config
mA2dpCodecConfig = null;
// Step 4: Destroy state machines and stop handler thread
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
for (A2dpStateMachine sm : mStateMachines.values()) {
sm.doQuit();
sm.cleanup();
@@ -188,13 +340,46 @@
mStateMachinesThread.quitSafely();
mStateMachinesThread = null;
- // Step 2: Reset maximum number of connected audio devices
- mMaxConnectedAudioDevices = 1;
+ // Step 3: Cleanup AVRCP
+ synchronized (mBtAvrcpLock) {
+ if(mAvrcp_ext != null) {
+ mAvrcp_ext.doQuit();
+ mAvrcp_ext.cleanup();
+ Avrcp_ext.clearAvrcpInstance();
+ mAvrcp_ext = null;
+ } else if(mAvrcp != null) {
+ mAvrcp.doQuit();
+ mAvrcp.cleanup();
+ mAvrcp = null;
+ }
+ }
- // Step 1: Clear AdapterService, A2dpNativeInterface, AudioManager
- mAudioManager = null;
- mA2dpNativeInterface = null;
- mAdapterService = null;
+ // Step 2: Reset maximum number of connected audio devices
+ synchronized (mVariableLock) {
+ if (mAdapterService != null && mAdapterService.isVendorIntfEnabled()) {
+ if (mIsTwsPlusEnabled) {
+ mMaxConnectedAudioDevices = 2;
+ } else {
+ mMaxConnectedAudioDevices = 1;
+ }
+ } else {
+ mMaxConnectedAudioDevices = 1;
+ }
+ mSetMaxConnectedAudioDevices = 1;
+ // Step 1: Clear AdapterService, A2dpNativeInterface, AudioManager
+ mAdapterService = null;
+ }
+
+ synchronized (mAudioManagerLock) {
+ mAudioManager = null;
+ }
+
+ try {
+ mA2dpNativeInterfaceLock.writeLock().lock();
+ mA2dpNativeInterface = null;
+ } finally {
+ mA2dpNativeInterfaceLock.writeLock().unlock();
+ }
return true;
}
@@ -233,13 +418,17 @@
Log.e(TAG, "Cannot connect to " + device + " : PRIORITY_OFF");
return false;
}
- if (!BluetoothUuid.isUuidPresent(mAdapterService.getRemoteUuids(device),
- BluetoothUuid.AudioSink)) {
- Log.e(TAG, "Cannot connect to " + device + " : Remote does not have A2DP Sink UUID");
- return false;
+ synchronized (mVariableLock) {
+ if (mAdapterService == null)
+ return false;
+ if (!BluetoothUuid.isUuidPresent(mAdapterService.getRemoteUuids(device),
+ BluetoothUuid.AudioSink)) {
+ Log.e(TAG, "Cannot connect to " + device + " : Remote does not have A2DP Sink UUID");
+ return false;
+ }
}
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
if (!connectionAllowedCheckMaxDevices(device)) {
// when mMaxConnectedAudioDevices is one, disconnect current device first.
if (mMaxConnectedAudioDevices == 1) {
@@ -259,23 +448,42 @@
return false;
}
}
+ if (disconnectExisting) {
+ disconnectExisting = false;
+ //Log.e(TAG,"Disconnect existing connections");
+ List <BluetoothDevice> connectingConnectedDevices =
+ getDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES);
+ Log.e(TAG,"Disconnect existing connections = " + connectingConnectedDevices.size());
+ for (BluetoothDevice connectingConnectedDevice : connectingConnectedDevices) {
+ Log.d(TAG,"calling disconnect to " + connectingConnectedDevice);
+ disconnect(connectingConnectedDevice);
+ }
+ }
A2dpStateMachine smConnect = getOrCreateStateMachine(device);
if (smConnect == null) {
Log.e(TAG, "Cannot connect to " + device + " : no state machine");
return false;
}
+ if (mA2dpSrcSnkConcurrency) {
+ sA2dpSinkService = A2dpSinkService.getA2dpSinkService();
+ List<BluetoothDevice> srcDevs = sA2dpSinkService.getConnectedDevices();
+ for ( BluetoothDevice src : srcDevs ) {
+ Log.d(TAG, "calling sink disconnect to " + src);
+ sA2dpSinkService.disconnect(src);
+ }
+ }
smConnect.sendMessage(A2dpStateMachine.CONNECT);
return true;
}
}
- boolean disconnect(BluetoothDevice device) {
+ public boolean disconnect(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission");
if (DBG) {
Log.d(TAG, "disconnect(): " + device);
}
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
A2dpStateMachine sm = mStateMachines.get(device);
if (sm == null) {
Log.e(TAG, "Ignored disconnect request for " + device + " : no state machine");
@@ -288,7 +496,7 @@
public List<BluetoothDevice> getConnectedDevices() {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
List<BluetoothDevice> devices = new ArrayList<>();
for (A2dpStateMachine sm : mStateMachines.values()) {
if (sm.isConnected()) {
@@ -298,7 +506,65 @@
return devices;
}
}
-
+ private boolean isConnectionAllowed(BluetoothDevice device, int tws_connected,
+ int num_connected) {
+ if (!mIsTwsPlusEnabled && mAdapterService.isTwsPlusDevice(device)) {
+ Log.d(TAG, "No TWSPLUS connections as It is not Enabled");
+ return false;
+ }
+ if (num_connected == 0) return true;
+ Log.d(TAG,"isConnectionAllowed");
+ List <BluetoothDevice> connectingConnectedDevices =
+ getDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES);
+ BluetoothDevice mConnDev = null;
+ if (mMaxConnectedAudioDevices > 2 && tws_connected > 0) {
+ for (BluetoothDevice connectingConnectedDevice : connectingConnectedDevices) {
+ if (mAdapterService.isTwsPlusDevice(connectingConnectedDevice)) {
+ mConnDev = connectingConnectedDevice;
+ break;
+ }
+ }
+ } else if (!connectingConnectedDevices.isEmpty()) {
+ mConnDev = connectingConnectedDevices.get(0);
+ }
+ if (mA2dpStackEvent == A2dpStackEvent.CONNECTION_STATE_CONNECTING ||
+ mA2dpStackEvent == A2dpStackEvent.CONNECTION_STATE_CONNECTED) {
+ //Handle incoming connection
+ if (!mAdapterService.isTwsPlusDevice(device) &&
+ ((mMaxConnectedAudioDevices - max_tws_connection) - (num_connected - tws_connected)) < 1) {
+ Log.d(TAG,"isConnectionAllowed: incoming connection not allowed");
+ mA2dpStackEvent = EVENT_TYPE_NONE;
+ return false;
+ }
+ }
+ if (mAdapterService.isTwsPlusDevice(device)) {
+ if (tws_connected == max_tws_connection) {
+ Log.d(TAG,"isConnectionAllowed:TWS+ pair connected, disallow other TWS+ connection");
+ return false;
+ }
+ if ((tws_connected > 0 && (mMaxConnectedAudioDevices - num_connected) >= min_tws_connection) ||
+ (tws_connected == 0 && (mMaxConnectedAudioDevices - num_connected) >= max_tws_connection)){
+ if ((tws_connected == 0) || (tws_connected == min_tws_connection && mConnDev != null &&
+ mAdapterService.getTwsPlusPeerAddress(mConnDev).equals(device.getAddress()))) {
+ Log.d(TAG,"isConnectionAllowed: Allow TWS+ connection");
+ return true;
+ }
+ } else {
+ Log.d(TAG,"isConnectionAllowed: Too many connections, TWS+ connection not allowed");
+ return false;
+ }
+ } else {
+ if ((tws_connected == max_tws_connection && (mMaxConnectedAudioDevices - num_connected) >= 1) ||
+ (tws_connected == min_tws_connection && (mMaxConnectedAudioDevices - num_connected) >= 2)) {
+ Log.d(TAG,"isConnectionAllowed: Allow legacy connection");
+ return true;
+ } else {
+ Log.d(TAG,"isConnectionAllowed: Too many connections, legacy connection not allowed");
+ return false;
+ }
+ }
+ return false;
+ }
/**
* Check whether can connect to a peer device.
* The check considers the maximum number of connected peers.
@@ -308,15 +574,20 @@
*/
private boolean connectionAllowedCheckMaxDevices(BluetoothDevice device) {
int connected = 0;
+ int tws_device = 0;
// Count devices that are in the process of connecting or already connected
- synchronized (mStateMachines) {
- for (A2dpStateMachine sm : mStateMachines.values()) {
+ synchronized (mBtA2dpLock) {
+ for (A2dpStateMachine sm : mStateMachines.values()) {
switch (sm.getConnectionState()) {
case BluetoothProfile.STATE_CONNECTING:
case BluetoothProfile.STATE_CONNECTED:
if (Objects.equals(device, sm.getDevice())) {
return true; // Already connected or accounted for
}
+ synchronized (mVariableLock) {
+ if (mAdapterService != null && mAdapterService.isTwsPlusDevice(sm.getDevice()))
+ tws_device++;
+ }
connected++;
break;
default:
@@ -324,7 +595,22 @@
}
}
}
- return (connected < mMaxConnectedAudioDevices);
+ Log.d(TAG,"connectionAllowedCheckMaxDevices connected = " + connected +
+ "tws connected = " + tws_device);
+ synchronized (mVariableLock) {
+ if (mAdapterService != null && mAdapterService.isVendorIntfEnabled() &&
+ ((tws_device > 0) || mAdapterService.isTwsPlusDevice(device) ||
+ ((tws_device > 0) && connected == mMaxConnectedAudioDevices &&
+ !mAdapterService.isTwsPlusDevice(device)))) {
+ return isConnectionAllowed(device, tws_device, connected);
+ }
+ }
+ if (mSetMaxConnectedAudioDevices == 1 &&
+ connected == mSetMaxConnectedAudioDevices) {
+ disconnectExisting = true;
+ return true;
+ }
+ return (connected < mSetMaxConnectedAudioDevices);
}
/**
@@ -340,9 +626,13 @@
public boolean okToConnect(BluetoothDevice device, boolean isOutgoingRequest) {
Log.i(TAG, "okToConnect: device " + device + " isOutgoingRequest: " + isOutgoingRequest);
// Check if this is an incoming connection in Quiet mode.
- if (mAdapterService.isQuietModeEnabled() && !isOutgoingRequest) {
- Log.e(TAG, "okToConnect: cannot connect to " + device + " : quiet mode enabled");
- return false;
+ synchronized (mVariableLock) {
+ if (mAdapterService == null)
+ return false;
+ if (mAdapterService.isQuietModeEnabled() && !isOutgoingRequest) {
+ Log.e(TAG, "okToConnect: cannot connect to " + device + " : quiet mode enabled");
+ return false;
+ }
}
// Check if too many devices
if (!connectionAllowedCheckMaxDevices(device)) {
@@ -350,6 +640,7 @@
+ " : too many connected devices");
return false;
}
+
// Check priority and accept or reject the connection.
int priority = getPriority(device);
int bondState = mAdapterService.getBondState(device);
@@ -374,20 +665,28 @@
if (states == null) {
return devices;
}
- final BluetoothDevice[] bondedDevices = mAdapterService.getBondedDevices();
+ BluetoothDevice [] bondedDevices = null;
+ synchronized (mVariableLock) {
+ if (mAdapterService != null)
+ bondedDevices = mAdapterService.getBondedDevices();
+ }
if (bondedDevices == null) {
return devices;
}
synchronized (mStateMachines) {
for (BluetoothDevice device : bondedDevices) {
- if (!BluetoothUuid.isUuidPresent(mAdapterService.getRemoteUuids(device),
+ synchronized (mVariableLock) {
+ if (mAdapterService != null && !BluetoothUuid.isUuidPresent(mAdapterService.getRemoteUuids(device),
BluetoothUuid.AudioSink)) {
- continue;
+ continue;
+ }
}
int connectionState = BluetoothProfile.STATE_DISCONNECTED;
- A2dpStateMachine sm = mStateMachines.get(device);
- if (sm != null) {
- connectionState = sm.getConnectionState();
+ synchronized (mBtA2dpLock) {
+ A2dpStateMachine sm = mStateMachines.get(device);
+ if (sm != null) {
+ connectionState = sm.getConnectionState();
+ }
}
for (int state : states) {
if (connectionState == state) {
@@ -408,7 +707,7 @@
@VisibleForTesting
List<BluetoothDevice> getDevices() {
List<BluetoothDevice> devices = new ArrayList<>();
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
for (A2dpStateMachine sm : mStateMachines.values()) {
devices.add(sm.getDevice());
}
@@ -418,7 +717,7 @@
public int getConnectionState(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
A2dpStateMachine sm = mStateMachines.get(device);
if (sm == null) {
return BluetoothProfile.STATE_DISCONNECTED;
@@ -428,18 +727,27 @@
}
private void storeActiveDeviceVolume() {
+ BluetoothDevice activeDevice;
+ synchronized (mStateMachines) {
+ activeDevice = mActiveDevice;
+ }
// Make sure volume has been stored before been removed from active.
- if (mFactory.getAvrcpTargetService() != null && mActiveDevice != null) {
- mFactory.getAvrcpTargetService().storeVolumeForDevice(mActiveDevice);
+ if (mFactory.getAvrcpTargetService() != null && activeDevice != null) {
+ mFactory.getAvrcpTargetService().storeVolumeForDevice(activeDevice);
+ }
+ synchronized (mBtAvrcpLock) {
+ if (activeDevice != null && mAvrcp_ext != null) {
+ mAvrcp_ext.storeVolumeForDevice(activeDevice);
+ }
}
}
private void removeActiveDevice(boolean forceStopPlayingAudio) {
BluetoothDevice previousActiveDevice = mActiveDevice;
- synchronized (mStateMachines) {
- // Make sure volume has been store before device been remove from active.
- storeActiveDeviceVolume();
+ // Make sure volume has been store before device been remove from active.
+ storeActiveDeviceVolume();
+ synchronized (mBtA2dpLock) {
// This needs to happen before we inform the audio manager that the device
// disconnected. Please see comment in updateAndBroadcastActiveDevice() for why.
updateAndBroadcastActiveDevice(null);
@@ -457,14 +765,29 @@
&& (getConnectionState(previousActiveDevice)
== BluetoothProfile.STATE_CONNECTED);
Log.i(TAG, "removeActiveDevice: suppressNoisyIntent=" + suppressNoisyIntent);
- mAudioManager.setBluetoothA2dpDeviceConnectionStateSuppressNoisyIntent(
- previousActiveDevice, BluetoothProfile.STATE_DISCONNECTED,
- BluetoothProfile.A2DP, suppressNoisyIntent, -1);
- // Make sure the Active device in native layer is set to null and audio is off
- if (!mA2dpNativeInterface.setActiveDevice(null)) {
- Log.w(TAG, "setActiveDevice(null): Cannot remove active device in native "
+
+ boolean isBAActive = false;
+ BATService mBatService = BATService.getBATService();
+ isBAActive = (mBatService != null) && (mBatService.isBATActive());
+ Log.d(TAG," removeActiveDevice: BA active " + isBAActive);
+ // If BA streaming is ongoing, we don't want to pause music player
+ synchronized (mAudioManagerLock) {
+ if(!isBAActive && mAudioManager != null) {
+ mAudioManager.handleBluetoothA2dpActiveDeviceChange(
+ previousActiveDevice, BluetoothProfile.STATE_DISCONNECTED,
+ BluetoothProfile.A2DP, suppressNoisyIntent, -1);
+ }
+ }
+ }
+ // Make sure the Active device in native layer is set to null and audio is off
+ try {
+ mA2dpNativeInterfaceLock.readLock().lock();
+ if (mA2dpNativeInterface != null && !mA2dpNativeInterface.setActiveDevice(null)) {
+ Log.w(TAG, "setActiveDevice(null): Cannot remove active device in native "
+ "layer");
}
+ } finally {
+ mA2dpNativeInterfaceLock.readLock().unlock();
}
}
@@ -486,10 +809,18 @@
// Set the device as the active device if currently no active device.
setActiveDevice(device);
}
- if (!mA2dpNativeInterface.setSilenceDevice(device, silence)) {
- Log.e(TAG, "Cannot set " + device + " silence mode " + silence + " in native layer");
- return false;
+
+ try {
+ mA2dpNativeInterfaceLock.readLock().lock();
+ if (mA2dpNativeInterface != null &&
+ !mA2dpNativeInterface.setSilenceDevice(device, silence)) {
+ Log.e(TAG, "Cannot set " + device + " silence mode " + silence + " in native layer");
+ return false;
+ }
+ } finally {
+ mA2dpNativeInterfaceLock.readLock().unlock();
}
+
return true;
}
@@ -517,19 +848,51 @@
*/
public boolean setActiveDevice(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission");
- synchronized (mStateMachines) {
- BluetoothDevice previousActiveDevice = mActiveDevice;
- if (DBG) {
- Log.d(TAG, "setActiveDevice(" + device + "): previous is " + previousActiveDevice);
- }
- if (device == null) {
- // Remove active device and continue playing audio only if necessary.
- removeActiveDevice(false);
+ synchronized (mBtA2dpLock) {
+ if(Objects.equals(device, mActiveDevice)) {
+ Log.e(TAG, "setActiveDevice(" + device + "): already set to active ");
return true;
}
+ }
- BluetoothCodecStatus codecStatus = null;
+ boolean playReq = device != null &&
+ mActiveDevice != null && isA2dpPlaying(mActiveDevice);
+ if(mAvrcp_ext != null) {
+ return mAvrcp_ext.startSHO(device, playReq);
+ }
+
+ return false;
+ }
+
+ public boolean startSHO(BluetoothDevice device) {
+ synchronized (mActiveDeviceLock) {
+ return setActiveDeviceInternal(device);
+ }
+ }
+
+ private boolean setActiveDeviceInternal(BluetoothDevice device) {
+ BluetoothCodecStatus codecStatus = null;
+ BluetoothDevice previousActiveDevice = mActiveDevice;
+ boolean isBAActive = false;
+ boolean tws_switch = false;
+ Log.w(TAG, "setActiveDevice(" + device + "): previous is " + previousActiveDevice);
+
+ if (device == null) {
+ // Remove active device and continue playing audio only if necessary.
+ synchronized(mBtAvrcpLock) {
+ if(mAvrcp_ext != null)
+ mAvrcp_ext.setActiveDevice(device);
+ }
+ removeActiveDevice(false);
+ return true;
+ }
+
+ synchronized (mBtA2dpLock) {
+ BATService mBatService = BATService.getBATService();
+ isBAActive = (mBatService != null) && (mBatService.isBATActive());
+ Log.d(TAG," setActiveDevice: BA active " + isBAActive);
+
A2dpStateMachine sm = mStateMachines.get(device);
if (sm == null) {
Log.e(TAG, "setActiveDevice(" + device + "): Cannot set as active: "
@@ -541,64 +904,119 @@
+ "device is not connected");
return false;
}
- if (!mA2dpNativeInterface.setActiveDevice(device)) {
- Log.e(TAG, "setActiveDevice(" + device + "): Cannot set as active in native layer");
- return false;
+
+ synchronized (mVariableLock) {
+ if (mAdapterService != null && previousActiveDevice != null &&
+ (mAdapterService.isTwsPlusDevice(device) &&
+ mAdapterService.isTwsPlusDevice(previousActiveDevice))) {
+ if(getConnectionState(previousActiveDevice) == BluetoothProfile.STATE_CONNECTED) {
+ Log.d(TAG,"Ignore setActiveDevice request for pair-earbud of active earbud");
+ return false;
+ }
+ Log.d(TAG,"TWS+ active device disconnected, setting its pair-earbud as active");
+ tws_switch = true;
+ }
}
+
codecStatus = sm.getCodecStatus();
- boolean deviceChanged = !Objects.equals(device, mActiveDevice);
- if (deviceChanged) {
- // Switch from one A2DP to another A2DP device
- if (DBG) {
- Log.d(TAG, "Switch A2DP devices to " + device + " from " + mActiveDevice);
+ // Switch from one A2DP to another A2DP device
+ if (DBG) {
+ Log.d(TAG, "Switch A2DP devices to " + device + " from " + mActiveDevice);
+ }
+ storeActiveDeviceVolume();
+
+ if(previousActiveDevice != null && !tws_switch && isA2dpPlaying(previousActiveDevice)) {
+ synchronized (mAudioManagerLock) {
+ if (mAudioManager != null && !mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)) {
+ mAudioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC,
+ AudioManager.ADJUST_MUTE,
+ mAudioManager.FLAG_BLUETOOTH_ABS_VOLUME);
+ }
}
- storeActiveDeviceVolume();
}
// This needs to happen before we inform the audio manager that the device
// disconnected. Please see comment in updateAndBroadcastActiveDevice() for why.
- updateAndBroadcastActiveDevice(device);
- if (deviceChanged) {
- // Send an intent with the active device codec config
- if (codecStatus != null) {
- broadcastCodecConfig(mActiveDevice, codecStatus);
- }
- // Make sure the Audio Manager knows the previous Active device is disconnected,
- // and the new Active device is connected.
- // Also, mute and unmute the output during the switch to avoid audio glitches.
- boolean wasMuted = false;
- if (previousActiveDevice != null) {
- if (!mAudioManager.isStreamMute(AudioManager.STREAM_MUSIC)) {
- mAudioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC,
- AudioManager.ADJUST_MUTE, AudioManager.FLAG_BLUETOOTH_ABS_VOLUME);
- wasMuted = true;
- }
- mAudioManager.setBluetoothA2dpDeviceConnectionStateSuppressNoisyIntent(
- previousActiveDevice, BluetoothProfile.STATE_DISCONNECTED,
- BluetoothProfile.A2DP, true, -1);
- }
+ Log.w(TAG, "setActiveDevice coming out of mutex lock");
+ }
- int rememberedVolume = -1;
- if (mFactory.getAvrcpTargetService() != null) {
- rememberedVolume = mFactory.getAvrcpTargetService()
- .getRememberedVolumeForDevice(mActiveDevice);
- }
+ try {
+ mA2dpNativeInterfaceLock.readLock().lock();
+ if (mA2dpNativeInterface != null && !mA2dpNativeInterface.setActiveDevice(device)) {
+ Log.e(TAG, "setActiveDevice(" + device + "): Cannot set as active in native layer");
+ return false;
+ }
- mAudioManager.setBluetoothA2dpDeviceConnectionStateSuppressNoisyIntent(
+ } finally {
+ mA2dpNativeInterfaceLock.readLock().unlock();
+ }
+
+
+ updateAndBroadcastActiveDevice(device);
+ Log.d(TAG, "setActiveDevice(" + device + "): completed");
+
+ synchronized (mBtAvrcpLock) {
+ if (mAvrcp_ext != null)
+ mAvrcp_ext.setActiveDevice(device);
+ }
+ // Send an intent with the active device codec config
+ if (codecStatus != null) {
+ broadcastCodecConfig(mActiveDevice, codecStatus);
+ }
+ int rememberedVolume = -1;
+ synchronized (mVariableLock) {
+ if (mFactory.getAvrcpTargetService() != null) {
+ rememberedVolume = mFactory.getAvrcpTargetService()
+ .getRememberedVolumeForDevice(mActiveDevice);
+ } else if (mAdapterService != null && mAdapterService.isVendorIntfEnabled()) {
+ rememberedVolume = mAvrcp_ext.getVolume(device);
+ Log.d(TAG,"volume = " + rememberedVolume);
+ }
+ }
+
+ // Make sure the Audio Manager knows the previous Active device is disconnected,
+ // and the new Active device is connected.
+ synchronized (mAudioManagerLock) {
+ if (!isBAActive && mAudioManager != null) {
+ // Make sure the Audio Manager knows the previous
+ // Active device is disconnected, and the new Active
+ // device is connected.
+ // Also, provide information about codec used by
+ // new active device so that Audio Service
+ // can reset accordingly the audio feeding parameters
+ // in the Audio HAL to the Bluetooth stack.
+ mAudioManager.handleBluetoothA2dpActiveDeviceChange(
mActiveDevice, BluetoothProfile.STATE_CONNECTED, BluetoothProfile.A2DP,
- true, rememberedVolume);
+ true, rememberedVolume);
+ }
+ }
- // Inform the Audio Service about the codec configuration
- // change, so the Audio Service can reset accordingly the audio
- // feeding parameters in the Audio HAL to the Bluetooth stack.
- mAudioManager.handleBluetoothA2dpDeviceConfigChange(mActiveDevice);
- if (wasMuted) {
- mAudioManager.adjustStreamVolume(AudioManager.STREAM_MUSIC,
- AudioManager.ADJUST_UNMUTE, AudioManager.FLAG_BLUETOOTH_ABS_VOLUME);
+ // Inform the Audio Service about the codec configuration
+ // change, so the Audio Service can reset accordingly the audio
+ // feeding parameters in the Audio HAL to the Bluetooth stack.
+
+ // Split A2dp will be enabled by default
+ boolean isSplitA2dpEnabled = true;
+ synchronized (mVariableLock) {
+ AdapterService adapterService = AdapterService.getAdapterService();
+
+ if (adapterService != null){
+ isSplitA2dpEnabled = adapterService.isSplitA2dpEnabled();
+ Log.v(TAG,"isSplitA2dpEnabled: " + isSplitA2dpEnabled);
+ } else {
+ Log.e(TAG,"adapterService is null");
+ }
+ }
+ // Don't update the absVolume flags when disconnect one device in multicast mode
+ synchronized (mBtAvrcpLock) {
+ if (!a2dpMulticast || previousActiveDevice == null) {
+ if (mAvrcp_ext != null && !tws_switch) {
+ mAvrcp_ext.setAbsVolumeFlag(device);
}
}
}
+ tws_switch = false;
return true;
}
@@ -609,13 +1027,13 @@
*/
public BluetoothDevice getActiveDevice() {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
return mActiveDevice;
}
}
private boolean isActiveDevice(BluetoothDevice device) {
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
return (device != null) && Objects.equals(device, mActiveDevice);
}
}
@@ -625,23 +1043,33 @@
if (DBG) {
Log.d(TAG, "Saved priority " + device + " = " + priority);
}
- mAdapterService.getDatabase()
+
+ synchronized (mVariableLock) {
+ if(mAdapterService != null)
+ mAdapterService.getDatabase()
.setProfilePriority(device, BluetoothProfile.A2DP, priority);
+ }
return true;
}
public int getPriority(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
- return mAdapterService.getDatabase()
- .getProfilePriority(device, BluetoothProfile.A2DP);
+ synchronized (mVariableLock) {
+ if(mAdapterService != null)
+ return mAdapterService.getDatabase()
+ .getProfilePriority(device, BluetoothProfile.A2DP);
+ }
+ return BluetoothProfile.PRIORITY_UNDEFINED;
}
+ /* Absolute volume implementation */
public boolean isAvrcpAbsoluteVolumeSupported() {
- // TODO (apanicke): Add a hook here for the AvrcpTargetService.
- return false;
+ synchronized(mBtAvrcpLock) {
+ if (mAvrcp_ext != null) return mAvrcp_ext.isAbsoluteVolumeSupported();
+ return (mAvrcp != null) && mAvrcp.isAbsoluteVolumeSupported();
+ }
}
-
public void setAvrcpAbsoluteVolume(int volume) {
// TODO (apanicke): Instead of using A2DP as a middleman for volume changes, add a binder
// service to the new AVRCP Profile and have the audio manager use that instead.
@@ -649,14 +1077,68 @@
mFactory.getAvrcpTargetService().sendVolumeChanged(volume);
return;
}
+
+ synchronized(mBtAvrcpLock) {
+ if (mAvrcp_ext != null) {
+ mAvrcp_ext.setAbsoluteVolume(volume);
+ return;
+ }
+ if (mAvrcp != null) {
+ mAvrcp.setAbsoluteVolume(volume);
+ }
+ }
}
- boolean isA2dpPlaying(BluetoothDevice device) {
+ public void setAvrcpAudioState(int state, BluetoothDevice device) {
+ synchronized(mBtAvrcpLock) {
+ if (mAvrcp_ext != null) {
+ mAvrcp_ext.setA2dpAudioState(state, device);
+ } else if (mAvrcp != null) {
+ mAvrcp.setA2dpAudioState(state);
+ }
+ }
+
+ if(state == BluetoothA2dp.STATE_NOT_PLAYING) {
+ GattService mGattService = GattService.getGattService();
+ if(mGattService != null) {
+ Log.d(TAG, "Enable BLE scanning");
+ mGattService.setAptXLowLatencyMode(false);
+ }
+ }
+ }
+
+ public void storeDeviceAudioVolume(BluetoothDevice device) {
+ if (device != null)
+ {
+ synchronized (mBtAvrcpLock) {
+ if (AvrcpTargetService.get() != null) {
+ AvrcpTargetService.get().storeVolumeForDevice(device);
+ } else if (mAvrcp_ext != null) {
+ //store volume in multi-a2dp for the device doesn't set as active
+ mAvrcp_ext.storeVolumeForDevice(device);
+ }
+ }
+ }
+ }
+
+ public void resetAvrcpBlacklist(BluetoothDevice device) {
+ synchronized(mBtAvrcpLock) {
+ if (mAvrcp_ext != null) {
+ mAvrcp_ext.resetBlackList(device.getAddress());
+ return;
+ }
+ if (mAvrcp != null) {
+ mAvrcp.resetBlackList(device.getAddress());
+ }
+ }
+ }
+
+ public boolean isA2dpPlaying(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
if (DBG) {
Log.d(TAG, "isA2dpPlaying(" + device + ")");
}
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
A2dpStateMachine sm = mStateMachines.get(device);
if (sm == null) {
return false;
@@ -665,6 +1147,43 @@
}
}
+ private BluetoothCodecStatus getTwsPlusCodecStatus(BluetoothCodecStatus mCodecStatus) {
+ BluetoothCodecConfig mCodecConfig = mCodecStatus.getCodecConfig();
+ BluetoothCodecConfig mNewCodecConfig;
+ Log.d(TAG, "Return TWS codec status with " + mCodecConfig.getCodecName() + " codec");
+ if(mCodecConfig.getCodecType() == BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_ADAPTIVE) {
+ mNewCodecConfig = new BluetoothCodecConfig(
+ BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_ADAPTIVE,
+ BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT,
+ BluetoothCodecConfig.SAMPLE_RATE_48000,
+ BluetoothCodecConfig.BITS_PER_SAMPLE_NONE,
+ BluetoothCodecConfig.CHANNEL_MODE_STEREO,
+ 0, 0, 0, 0);
+ } else {
+ mNewCodecConfig = new BluetoothCodecConfig(
+ BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX,
+ mCodecConfig.getCodecPriority(), mCodecConfig.getSampleRate(),
+ mCodecConfig.getBitsPerSample(), mCodecConfig.getChannelMode(),
+ mCodecConfig.getCodecSpecific1(), mCodecConfig.getCodecSpecific2(),
+ mCodecConfig.getCodecSpecific3(), mCodecConfig.getCodecSpecific4());
+ }
+ return (new BluetoothCodecStatus(mNewCodecConfig, mCodecStatus.getCodecsLocalCapabilities(),
+ mCodecStatus.getCodecsSelectableCapabilities()));
+ }
+
+ private BluetoothCodecStatus getBACodecStatus() {
+ BluetoothCodecConfig mNewCodecConfig =
+ new BluetoothCodecConfig(
+ BluetoothCodecConfig.SOURCE_CODEC_TYPE_CELT,
+ BluetoothCodecConfig.CODEC_PRIORITY_DEFAULT,
+ BluetoothCodecConfig.SAMPLE_RATE_48000,
+ BluetoothCodecConfig.BITS_PER_SAMPLE_NONE,
+ BluetoothCodecConfig.CHANNEL_MODE_STEREO,
+ 0, 0, 0, 0);
+ BluetoothCodecConfig[] mBACodecConfig = {mNewCodecConfig};
+ return (new BluetoothCodecStatus(mNewCodecConfig, mBACodecConfig, mBACodecConfig));
+ }
+
/**
* Gets the current codec status (configuration and capability).
*
@@ -678,14 +1197,28 @@
if (DBG) {
Log.d(TAG, "getCodecStatus(" + device + ")");
}
- synchronized (mStateMachines) {
+ A2dpStateMachine sm = null;
+ boolean isBAActive = false;
+ BATService mBatService = BATService.getBATService();
+ isBAActive = (mBatService != null) && (mBatService.isBATActive());
+ synchronized (mBtA2dpLock) {
if (device == null) {
device = mActiveDevice;
}
if (device == null) {
return null;
}
- A2dpStateMachine sm = mStateMachines.get(device);
+ if(isBAActive) {
+ Log.d(TAG, "getBACodecStatus(" + device + ")");
+ return getBACodecStatus();
+ }
+ if (Objects.equals(device, mDummyDevice)) {
+ sm = mStateMachines.get(mActiveDevice);
+ if (sm != null) {
+ return getTwsPlusCodecStatus(sm.getCodecStatus());
+ }
+ }
+ sm = mStateMachines.get(device);
if (sm != null) {
return sm.getCodecStatus();
}
@@ -719,11 +1252,39 @@
Log.e(TAG, "setCodecConfigPreference: Codec config can't be null");
return;
}
+ long cs4 = codecConfig.getCodecSpecific4();
+ GattService mGattService = GattService.getGattService();
+ if(cs4 > 0 && mGattService != null) {
+ switch((int)(cs4 & APTX_MODE_MASK)) {
+ case APTX_HQ:
+ mGattService.setAptXLowLatencyMode(false);
+ break;
+
+ case APTX_LL:
+ case APTX_ULL:
+ if((cs4 & APTX_SCAN_FILTER_MASK) == APTX_SCAN_FILTER_MASK) {
+ mGattService.setAptXLowLatencyMode(true);
+ } else {
+ mGattService.setAptXLowLatencyMode(false);
+ }
+ break;
+ default:
+ Log.e(TAG, cs4 + " is not a aptX profile mode feedback");
+ }
+ }
+
BluetoothCodecStatus codecStatus = getCodecStatus(device);
if (codecStatus == null) {
Log.e(TAG, "setCodecConfigPreference: Codec status is null");
return;
}
+ synchronized (mVariableLock) {
+ if (mAdapterService != null && mAdapterService.isTwsPlusDevice(device) && ( cs4 == 0 ||
+ codecConfig.getCodecType() != BluetoothCodecConfig.SOURCE_CODEC_TYPE_APTX_ADAPTIVE )) {
+ Log.w(TAG, "Block un-supportive codec on TWS+ device: " + device);
+ return;
+ }
+ }
mA2dpCodecConfig.setCodecConfigPreference(device, codecStatus, codecConfig);
}
@@ -791,19 +1352,30 @@
public int getSupportsOptionalCodecs(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
- return mAdapterService.getDatabase().getA2dpSupportsOptionalCodecs(device);
+ synchronized (mVariableLock) {
+ if(mAdapterService != null)
+ return mAdapterService.getDatabase().getA2dpSupportsOptionalCodecs(device);
+ }
+ return BluetoothA2dp.OPTIONAL_CODECS_NOT_SUPPORTED;
}
public void setSupportsOptionalCodecs(BluetoothDevice device, boolean doesSupport) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
int value = doesSupport ? BluetoothA2dp.OPTIONAL_CODECS_SUPPORTED
: BluetoothA2dp.OPTIONAL_CODECS_NOT_SUPPORTED;
- mAdapterService.getDatabase().setA2dpSupportsOptionalCodecs(device, value);
+ synchronized (mVariableLock) {
+ if(mAdapterService != null)
+ mAdapterService.getDatabase().setA2dpSupportsOptionalCodecs(device, value);
+ }
}
public int getOptionalCodecsEnabled(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
- return mAdapterService.getDatabase().getA2dpOptionalCodecsEnabled(device);
+ synchronized (mVariableLock) {
+ if(mAdapterService != null)
+ return mAdapterService.getDatabase().getA2dpOptionalCodecsEnabled(device);
+ }
+ return BluetoothA2dp.OPTIONAL_CODECS_PREF_UNKNOWN;
}
public void setOptionalCodecsEnabled(BluetoothDevice device, int value) {
@@ -814,38 +1386,96 @@
Log.w(TAG, "Unexpected value passed to setOptionalCodecsEnabled:" + value);
return;
}
- mAdapterService.getDatabase().setA2dpOptionalCodecsEnabled(device, value);
+ synchronized (mVariableLock) {
+ if(mAdapterService != null)
+ mAdapterService.getDatabase().setA2dpOptionalCodecsEnabled(device, value);
+ }
}
// Handle messages from native (JNI) to Java
void messageFromNative(A2dpStackEvent stackEvent) {
Objects.requireNonNull(stackEvent.device,
"Device should never be null, event: " + stackEvent);
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
BluetoothDevice device = stackEvent.device;
A2dpStateMachine sm = mStateMachines.get(device);
if (sm == null) {
+ Log.d(TAG, "messageFromNative: stackEvent.type: " + stackEvent.type);
if (stackEvent.type == A2dpStackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED) {
switch (stackEvent.valueInt) {
case A2dpStackEvent.CONNECTION_STATE_CONNECTED:
- case A2dpStackEvent.CONNECTION_STATE_CONNECTING:
- // Create a new state machine only when connecting to a device
- if (!connectionAllowedCheckMaxDevices(device)) {
+ case A2dpStackEvent.CONNECTION_STATE_CONNECTING: {
+ boolean connectionAllowed;
+ synchronized (mVariableLock) {
+ // Create a new state machine only when connecting to a device
+ if (mAdapterService != null && mAdapterService.isVendorIntfEnabled())
+ mA2dpStackEvent = stackEvent.valueInt;
+ if (mAdapterService != null && mAdapterService.isTwsPlusDevice(device)) {
+ sm = getOrCreateStateMachine(device);
+ break;
+ }
+ connectionAllowed = connectionAllowedCheckMaxDevices(device);
+ }
+ if (!connectionAllowed) {
Log.e(TAG, "Cannot connect to " + device
+ " : too many connected devices");
- return;
+ try {
+ mA2dpNativeInterfaceLock.readLock().lock();
+ if (mA2dpNativeInterface != null) {
+ mA2dpNativeInterface.disconnectA2dp(device);
+ return;
+ }
+ } finally {
+ mA2dpNativeInterfaceLock.readLock().unlock();
+ }
}
sm = getOrCreateStateMachine(device);
break;
+ }
default:
+ synchronized (mVariableLock) {
+ if (mAdapterService!= null && mAdapterService.isVendorIntfEnabled() &&
+ mA2dpStackEvent == A2dpStackEvent.CONNECTION_STATE_CONNECTED ||
+ mA2dpStackEvent == A2dpStackEvent.CONNECTION_STATE_CONNECTING) {
+ Log.d(TAG,"Reset local stack event value");
+ mA2dpStackEvent = EVENT_TYPE_NONE;
+ }
+ }
break;
}
}
+ } else {
+ Log.d(TAG, "messageFromNative: Going to acquire mVariableLock.");
+ synchronized (mVariableLock) {
+ Log.d(TAG, "messageFromNative: Acquired mVariableLock");
+ if (mAdapterService != null && mAdapterService.isVendorIntfEnabled()) {
+ switch (sm.getConnectionState()) {
+ case BluetoothProfile.STATE_DISCONNECTED:
+ mA2dpStackEvent = stackEvent.valueInt;
+ break;
+ default:
+ mA2dpStackEvent = EVENT_TYPE_NONE;
+ break;
+ }
+ }
+ }
+ Log.d(TAG, "messageFromNative: Released mVariableLock");
}
if (sm == null) {
Log.e(TAG, "Cannot process stack event: no state machine: " + stackEvent);
return;
}
+ if (mA2dpSrcSnkConcurrency &&
+ (A2dpStackEvent.CONNECTION_STATE_CONNECTING == stackEvent.valueInt ||
+ A2dpStackEvent.CONNECTION_STATE_CONNECTED == stackEvent.valueInt )) {
+ sA2dpSinkService = A2dpSinkService.getA2dpSinkService();
+ List<BluetoothDevice> srcDevs = sA2dpSinkService.getConnectedDevices();
+ for ( BluetoothDevice src : srcDevs ) {
+ Log.d(TAG, "calling sink disconnect to " + src);
+ sA2dpSinkService.disconnect(src);
+ }
+ }
+ Log.d(TAG, "messageFromNative: Sending STACK_EVENT: " + stackEvent + " to sm.");
sm.sendMessage(A2dpStateMachine.STACK_EVENT, stackEvent);
}
}
@@ -861,22 +1491,29 @@
@VisibleForTesting
public void codecConfigUpdated(BluetoothDevice device, BluetoothCodecStatus codecStatus,
boolean sameAudioFeedingParameters) {
+ Log.w(TAG, "codecConfigUpdated for device:" + device +
+ "sameAudioFeedingParameters: " + sameAudioFeedingParameters);
+
// Log codec config and capability metrics
BluetoothCodecConfig codecConfig = codecStatus.getCodecConfig();
- StatsLog.write(StatsLog.BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED,
- mAdapterService.obfuscateAddress(device), codecConfig.getCodecType(),
- codecConfig.getCodecPriority(), codecConfig.getSampleRate(),
- codecConfig.getBitsPerSample(), codecConfig.getChannelMode(),
- codecConfig.getCodecSpecific1(), codecConfig.getCodecSpecific2(),
- codecConfig.getCodecSpecific3(), codecConfig.getCodecSpecific4());
- BluetoothCodecConfig[] codecCapabilities = codecStatus.getCodecsSelectableCapabilities();
- for (BluetoothCodecConfig codecCapability : codecCapabilities) {
- StatsLog.write(StatsLog.BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED,
- mAdapterService.obfuscateAddress(device), codecCapability.getCodecType(),
- codecCapability.getCodecPriority(), codecCapability.getSampleRate(),
- codecCapability.getBitsPerSample(), codecCapability.getChannelMode(),
+ synchronized (mVariableLock) {
+ if(mAdapterService != null) {
+ StatsLog.write(StatsLog.BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED,
+ mAdapterService.obfuscateAddress(device), codecConfig.getCodecType(),
+ codecConfig.getCodecPriority(), codecConfig.getSampleRate(),
+ codecConfig.getBitsPerSample(), codecConfig.getChannelMode(),
codecConfig.getCodecSpecific1(), codecConfig.getCodecSpecific2(),
codecConfig.getCodecSpecific3(), codecConfig.getCodecSpecific4());
+ BluetoothCodecConfig[] codecCapabilities = codecStatus.getCodecsSelectableCapabilities();
+ for (BluetoothCodecConfig codecCapability : codecCapabilities) {
+ StatsLog.write(StatsLog.BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED,
+ mAdapterService.obfuscateAddress(device), codecCapability.getCodecType(),
+ codecCapability.getCodecPriority(), codecCapability.getSampleRate(),
+ codecCapability.getBitsPerSample(), codecCapability.getChannelMode(),
+ codecConfig.getCodecSpecific1(), codecConfig.getCodecSpecific2(),
+ codecConfig.getCodecSpecific3(), codecConfig.getCodecSpecific4());
+ }
+ }
}
broadcastCodecConfig(device, codecStatus);
@@ -884,17 +1521,108 @@
// Inform the Audio Service about the codec configuration change,
// so the Audio Service can reset accordingly the audio feeding
// parameters in the Audio HAL to the Bluetooth stack.
+ int rememberedVolume = -1;
if (isActiveDevice(device) && !sameAudioFeedingParameters) {
- mAudioManager.handleBluetoothA2dpDeviceConfigChange(device);
+ synchronized (mBtAvrcpLock) {
+ if (mAvrcp_ext != null)
+ rememberedVolume = mAvrcp_ext.getVolume(device);
+ }
+ synchronized (mAudioManagerLock) {
+ if (mAudioManager != null) {
+ mAudioManager.handleBluetoothA2dpActiveDeviceChange(device,
+ BluetoothProfile.STATE_CONNECTED, BluetoothProfile.A2DP,
+ true, rememberedVolume);
+ }
+ }
}
}
+ void updateTwsChannelMode(int state, BluetoothDevice device) {
+ Log.d(TAG, "updateTwsChannelMode: mIsTwsPlusMonoSupported: " + mIsTwsPlusMonoSupported);
+ if (mIsTwsPlusMonoSupported) {
+ BluetoothDevice peerTwsDevice = null;
+ synchronized (mVariableLock) {
+ if (mAdapterService != null)
+ peerTwsDevice = mAdapterService.getTwsPlusPeerDevice(device);
+ }
+ Log.d(TAG, "TwsChannelMode: " + mTwsPlusChannelMode + " state: " + state);
+ synchronized(mBtTwsLock) {
+ if ("mono".equals(mTwsPlusChannelMode)) {
+ if ((state == BluetoothA2dp.STATE_PLAYING) && (peerTwsDevice!= null)
+ && peerTwsDevice.isConnected() && isA2dpPlaying(peerTwsDevice)) {
+ Log.d(TAG, "updateTwsChannelMode: send delay message to set dual-mono ");
+ Message msg = mHandler.obtainMessage(SET_EBDUALMONO_CFG);
+ mHandler.sendMessageDelayed(msg, DualMonoCfg_Timeout);
+ } else if (state == BluetoothA2dp.STATE_PLAYING) {
+ Log.d(TAG, "updateTwsChannelMode: setparameters to Mono");
+ synchronized (mAudioManagerLock) {
+ if (mAudioManager != null) {
+ Log.d(TAG, "updateTwsChannelMode: Acquired mAudioManagerLock");
+ mAudioManager.setParameters("TwsChannelConfig=mono");
+ }
+ }
+ Log.d(TAG, "updateTwsChannelMode: Released mAudioManagerLock");
+ }
+ if ((state == BluetoothA2dp.STATE_NOT_PLAYING) &&
+ isA2dpPlaying(peerTwsDevice)) {
+ if (mHandler.hasMessages(SET_EBDUALMONO_CFG)) {
+ Log.d(TAG, "updateTwsChannelMode:remove delay message for dual-mono");
+ mHandler.removeMessages(SET_EBDUALMONO_CFG);
+ }
+ }
+ } else if ("dual-mono".equals(mTwsPlusChannelMode)) {
+ if ((state == BluetoothA2dp.STATE_PLAYING) &&
+ (getConnectionState(peerTwsDevice) != BluetoothProfile.STATE_CONNECTED
+ || !isA2dpPlaying(peerTwsDevice))) {
+ Log.d(TAG, "updateTwsChannelMode: send delay message to set mono");
+ Message msg = mHandler.obtainMessage(SET_EBMONO_CFG);
+ mHandler.sendMessageDelayed(msg, MonoCfg_Timeout);
+ }
+ if ((state == BluetoothA2dp.STATE_PLAYING) && isA2dpPlaying(peerTwsDevice)) {
+ if (mHandler.hasMessages(SET_EBMONO_CFG)) {
+ Log.d(TAG, "updateTwsChannelMode: remove delay message to set mono");
+ mHandler.removeMessages(SET_EBMONO_CFG);
+ }
+ }
+ if ((state == BluetoothA2dp.STATE_NOT_PLAYING)
+ && isA2dpPlaying(peerTwsDevice)) {
+ Log.d(TAG, "setparameters to Mono");
+ synchronized (mAudioManagerLock) {
+ if (mAudioManager != null)
+ mAudioManager.setParameters("TwsChannelConfig=mono");
+ }
+ mTwsPlusChannelMode = "mono";
+ }
+ }
+ }
+ } else {
+ Log.d(TAG,"TWS+ L/R to M feature not supported");
+ }
+ }
+
+ public void broadcastReconfigureA2dp() {
+ Log.w(TAG, "broadcastReconfigureA2dp(): set rcfg true to AudioManager");
+ boolean isBAActive = false;
+ BATService mBatService = BATService.getBATService();
+ isBAActive = (mBatService != null) && (mBatService.isBATActive());
+ Log.d(TAG," broadcastReconfigureA2dp: BA active " + isBAActive);
+ // If BA is active, don't inform AudioManager about reconfig.
+ if(isBAActive) {
+ return;
+ }
+ synchronized (mAudioManagerLock) {
+ if (mAudioManager != null)
+ mAudioManager.setParameters("reconfigA2dp=true");
+ }
+ }
+
+
private A2dpStateMachine getOrCreateStateMachine(BluetoothDevice device) {
if (device == null) {
Log.e(TAG, "getOrCreateStateMachine failed: device cannot be null");
return null;
}
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
A2dpStateMachine sm = mStateMachines.get(device);
if (sm != null) {
return sm;
@@ -931,8 +1659,11 @@
mActiveDevice = device;
}
- StatsLog.write(StatsLog.BLUETOOTH_ACTIVE_DEVICE_CHANGED, BluetoothProfile.A2DP,
- mAdapterService.obfuscateAddress(device));
+ synchronized (mVariableLock) {
+ if (mAdapterService != null)
+ StatsLog.write(StatsLog.BLUETOOTH_ACTIVE_DEVICE_CHANGED, BluetoothProfile.A2DP,
+ mAdapterService.obfuscateAddress(device));
+ }
Intent intent = new Intent(BluetoothA2dp.ACTION_ACTIVE_DEVICE_CHANGED);
intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT
@@ -984,7 +1715,7 @@
if (bondState != BluetoothDevice.BOND_NONE) {
return;
}
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
A2dpStateMachine sm = mStateMachines.get(device);
if (sm == null) {
return;
@@ -992,16 +1723,20 @@
if (sm.getConnectionState() != BluetoothProfile.STATE_DISCONNECTED) {
return;
}
+ }
+ synchronized (mBtAvrcpLock) {
if (mFactory.getAvrcpTargetService() != null) {
mFactory.getAvrcpTargetService().removeStoredVolumeForDevice(device);
}
-
- removeStateMachine(device);
+ if (mAvrcp_ext != null) {
+ mAvrcp_ext.removeVolumeForDevice(device);
+ }
}
+ removeStateMachine(device);
}
private void removeStateMachine(BluetoothDevice device) {
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
A2dpStateMachine sm = mStateMachines.get(device);
if (sm == null) {
Log.w(TAG, "removeStateMachine: device " + device
@@ -1027,7 +1762,7 @@
boolean supportsOptional = false;
boolean hasMandatoryCodec = false;
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
A2dpStateMachine sm = mStateMachines.get(device);
if (sm == null) {
return;
@@ -1050,7 +1785,6 @@
Log.i(TAG, "updateOptionalCodecsSupport: Mandatory codec is not selectable.");
return;
}
-
if (previousSupport == BluetoothA2dp.OPTIONAL_CODECS_SUPPORT_UNKNOWN
|| supportsOptional != (previousSupport
== BluetoothA2dp.OPTIONAL_CODECS_SUPPORTED)) {
@@ -1077,26 +1811,24 @@
if ((device == null) || (fromState == toState)) {
return;
}
- synchronized (mStateMachines) {
+ synchronized (mBtA2dpLock) {
if (toState == BluetoothProfile.STATE_CONNECTED) {
MetricsLogger.logProfileConnectionEvent(BluetoothMetricsProto.ProfileId.A2DP);
}
- // Set the active device if only one connected device is supported and it was connected
- if (toState == BluetoothProfile.STATE_CONNECTED && (mMaxConnectedAudioDevices == 1)) {
- setActiveDevice(device);
- }
- // Check if the active device is not connected anymore
- if (isActiveDevice(device) && (fromState == BluetoothProfile.STATE_CONNECTED)) {
- setActiveDevice(null);
- }
+ int bondState = BluetoothDevice.BOND_NONE;
// Check if the device is disconnected - if unbond, remove the state machine
if (toState == BluetoothProfile.STATE_DISCONNECTED) {
- int bondState = mAdapterService.getBondState(device);
+ synchronized (mVariableLock) {
+ if(mAdapterService != null)
+ bondState = mAdapterService.getBondState(device);
+ }
if (bondState == BluetoothDevice.BOND_NONE) {
if (mFactory.getAvrcpTargetService() != null) {
mFactory.getAvrcpTargetService().removeStoredVolumeForDevice(device);
}
-
+ if (mAvrcp_ext != null) {
+ mAvrcp_ext.removeVolumeForDevice(device);
+ }
removeStateMachine(device);
}
}
@@ -1118,6 +1850,10 @@
return;
}
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+ if (device.getAddress().equals(BATService.mBAAddress)) {
+ Log.d(TAG," ConnectionUpdate from BA, don't take action ");
+ return;
+ }
int toState = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, -1);
int fromState = intent.getIntExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, -1);
connectionStateChanged(device, fromState, toState);
@@ -1303,6 +2039,11 @@
if (service == null) {
return BluetoothA2dp.OPTIONAL_CODECS_SUPPORT_UNKNOWN;
}
+ AdapterService adService = AdapterService.getAdapterService();
+ if(adService.isTwsPlusDevice(device)) {
+ Log.w(TAG, "Disable optional codec support for TWS+ device");
+ return BluetoothA2dp.OPTIONAL_CODECS_NOT_SUPPORTED;
+ }
return service.getSupportsOptionalCodecs(device);
}
@@ -1327,8 +2068,19 @@
public void dump(StringBuilder sb) {
super.dump(sb);
ProfileService.println(sb, "mActiveDevice: " + mActiveDevice);
- for (A2dpStateMachine sm : mStateMachines.values()) {
- sm.dump(sb);
+ synchronized(mBtA2dpLock) {
+ for (A2dpStateMachine sm : mStateMachines.values()) {
+ sm.dump(sb);
+ }
+ }
+ synchronized(mBtAvrcpLock) {
+ if (mAvrcp_ext != null) {
+ mAvrcp_ext.dump(sb);
+ return;
+ }
+ if (mAvrcp != null) {
+ mAvrcp.dump(sb);
+ }
}
}
}
diff --git a/src/com/android/bluetooth/a2dp/A2dpStateMachine.java b/src/com/android/bluetooth/a2dp/A2dpStateMachine.java
index cc8f88d..94ad8da 100644
--- a/src/com/android/bluetooth/a2dp/A2dpStateMachine.java
+++ b/src/com/android/bluetooth/a2dp/A2dpStateMachine.java
@@ -65,6 +65,8 @@
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Scanner;
+import android.os.SystemProperties;
+import com.android.bluetooth.btservice.AdapterService;
final class A2dpStateMachine extends StateMachine {
private static final boolean DBG = true;
@@ -132,6 +134,7 @@
// Stop if auido is still playing
log("doQuit: stopped playing " + mDevice);
mIsPlaying = false;
+ mA2dpService.setAvrcpAudioState(BluetoothA2dp.STATE_NOT_PLAYING, mDevice);
broadcastAudioState(BluetoothA2dp.STATE_NOT_PLAYING,
BluetoothA2dp.STATE_PLAYING);
}
@@ -149,19 +152,26 @@
Message currentMessage = getCurrentMessage();
Log.i(TAG, "Enter Disconnected(" + mDevice + "): " + (currentMessage == null ? "null"
: messageWhatToString(currentMessage.what)));
- mConnectionState = BluetoothProfile.STATE_DISCONNECTED;
-
+ synchronized (this) {
+ mConnectionState = BluetoothProfile.STATE_DISCONNECTED;
+ }
removeDeferredMessages(DISCONNECT);
if (mLastConnectionState != -1) {
// Don't broadcast during startup
- broadcastConnectionState(mConnectionState, mLastConnectionState);
if (mIsPlaying) {
Log.i(TAG, "Disconnected: stopped playing: " + mDevice);
mIsPlaying = false;
+ mA2dpService.setAvrcpAudioState(BluetoothA2dp.STATE_NOT_PLAYING, mDevice);
broadcastAudioState(BluetoothA2dp.STATE_NOT_PLAYING,
BluetoothA2dp.STATE_PLAYING);
}
+ broadcastConnectionState(mConnectionState, mLastConnectionState);
+ AdapterService adapterService = AdapterService.getAdapterService();
+ if (adapterService.isVendorIntfEnabled() &&
+ adapterService.isTwsPlusDevice(mDevice)) {
+ mA2dpService.updateTwsChannelMode(BluetoothA2dp.STATE_NOT_PLAYING, mDevice);
+ }
}
}
@@ -264,7 +274,9 @@
Log.i(TAG, "Enter Connecting(" + mDevice + "): " + (currentMessage == null ? "null"
: messageWhatToString(currentMessage.what)));
sendMessageDelayed(CONNECT_TIMEOUT, sConnectTimeoutMs);
- mConnectionState = BluetoothProfile.STATE_CONNECTING;
+ synchronized (this) {
+ mConnectionState = BluetoothProfile.STATE_CONNECTING;
+ }
broadcastConnectionState(mConnectionState, mLastConnectionState);
}
@@ -360,7 +372,9 @@
Log.i(TAG, "Enter Disconnecting(" + mDevice + "): " + (currentMessage == null ? "null"
: messageWhatToString(currentMessage.what)));
sendMessageDelayed(CONNECT_TIMEOUT, sConnectTimeoutMs);
- mConnectionState = BluetoothProfile.STATE_DISCONNECTING;
+ synchronized (this) {
+ mConnectionState = BluetoothProfile.STATE_DISCONNECTING;
+ }
broadcastConnectionState(mConnectionState, mLastConnectionState);
}
@@ -464,8 +478,9 @@
Message currentMessage = getCurrentMessage();
Log.i(TAG, "Enter Connected(" + mDevice + "): " + (currentMessage == null ? "null"
: messageWhatToString(currentMessage.what)));
- mConnectionState = BluetoothProfile.STATE_CONNECTED;
-
+ synchronized (this) {
+ mConnectionState = BluetoothProfile.STATE_CONNECTED;
+ }
removeDeferredMessages(CONNECT);
// Each time a device connects, we want to re-check if it supports optional
@@ -557,14 +572,22 @@
// in Connected state
private void processAudioStateEvent(int state) {
+ Log.i(TAG, "Connected: processAudioStateEvent: state: " + state + " mIsPlaying: " + mIsPlaying);
switch (state) {
case A2dpStackEvent.AUDIO_STATE_STARTED:
synchronized (this) {
if (!mIsPlaying) {
Log.i(TAG, "Connected: started playing: " + mDevice);
mIsPlaying = true;
+ mA2dpService.setAvrcpAudioState(BluetoothA2dp.STATE_PLAYING, mDevice);
broadcastAudioState(BluetoothA2dp.STATE_PLAYING,
BluetoothA2dp.STATE_NOT_PLAYING);
+ Log.i(TAG,"state:AUDIO_STATE_STARTED");
+ }
+ AdapterService adapterService = AdapterService.getAdapterService();
+ if (adapterService.isVendorIntfEnabled() &&
+ adapterService.isTwsPlusDevice(mDevice)) {
+ mA2dpService.updateTwsChannelMode(BluetoothA2dp.STATE_PLAYING, mDevice);
}
}
break;
@@ -574,6 +597,7 @@
if (mIsPlaying) {
Log.i(TAG, "Connected: stopped playing: " + mDevice);
mIsPlaying = false;
+ mA2dpService.setAvrcpAudioState(BluetoothA2dp.STATE_NOT_PLAYING, mDevice);
broadcastAudioState(BluetoothA2dp.STATE_NOT_PLAYING,
BluetoothA2dp.STATE_PLAYING);
}
@@ -596,7 +620,7 @@
boolean isConnected() {
synchronized (this) {
- return (getConnectionState() == BluetoothProfile.STATE_CONNECTED);
+ return (mConnectionState == BluetoothProfile.STATE_CONNECTED);
}
}
@@ -618,13 +642,40 @@
BluetoothCodecConfig prevCodecConfig = null;
BluetoothCodecStatus prevCodecStatus = mCodecStatus;
+ int new_codec_type = newCodecStatus.getCodecConfig().getCodecType();
+
+ // Split A2dp will be enabled by default
+ boolean isSplitA2dpEnabled = true;
+ AdapterService adapterService = AdapterService.getAdapterService();
+
+ if (adapterService != null){
+ isSplitA2dpEnabled = adapterService.isSplitA2dpEnabled();
+ Log.v(TAG,"isSplitA2dpEnabled: " + isSplitA2dpEnabled);
+ } else {
+ Log.e(TAG,"adapterService is null");
+ }
+
+ Log.w(TAG,"processCodecConfigEvent: new_codec_type = " + new_codec_type);
+
+ if (isSplitA2dpEnabled) {
+ if (new_codec_type == BluetoothCodecConfig.SOURCE_CODEC_TYPE_MAX) {
+ if (adapterService.isVendorIntfEnabled() &&
+ adapterService.isTwsPlusDevice(mDevice)) {
+ Log.d(TAG,"TWSP device streaming,not calling reconfig");
+ mCodecStatus = newCodecStatus;
+ return;
+ }
+ mA2dpService.broadcastReconfigureA2dp();
+ Log.w(TAG,"Split A2dp enabled rcfg send to Audio for codec max");
+ return;
+ }
+ }
synchronized (this) {
if (mCodecStatus != null) {
prevCodecConfig = mCodecStatus.getCodecConfig();
}
mCodecStatus = newCodecStatus;
}
-
if (DBG) {
Log.d(TAG, "A2DP Codec Config: " + prevCodecConfig + "->"
+ newCodecStatus.getCodecConfig());
@@ -665,9 +716,28 @@
return;
}
- boolean sameAudioFeedingParameters =
- newCodecStatus.getCodecConfig().sameAudioFeedingParameters(prevCodecConfig);
- mA2dpService.codecConfigUpdated(mDevice, mCodecStatus, sameAudioFeedingParameters);
+ if (!isSplitA2dpEnabled) {
+ boolean isUpdateRequired = false;
+ if ((prevCodecConfig != null) && (prevCodecConfig.getCodecType() != new_codec_type)) {
+ Log.d(TAG, "previous codec is differs from new codec");
+ isUpdateRequired = true;
+ } else if (!newCodecStatus.getCodecConfig().sameAudioFeedingParameters(prevCodecConfig)) {
+ Log.d(TAG, "codec config parameters mismatched with previous config: ");
+ isUpdateRequired = true;
+ } else if ((newCodecStatus.getCodecConfig().getCodecType()
+ == BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC)
+ && (prevCodecConfig != null)
+ && (prevCodecConfig.getCodecSpecific1()
+ != newCodecStatus.getCodecConfig().getCodecSpecific1())) {
+ Log.d(TAG, "LDAC: codec config parameters mismatched with previous config: ");
+ isUpdateRequired = true;
+ }
+ Log.d(TAG, "isUpdateRequired: " + isUpdateRequired);
+ //update MM only when previous and current codec config has been changed.
+ if (isUpdateRequired) {
+ mA2dpService.codecConfigUpdated(mDevice, mCodecStatus, false);
+ }
+ }
}
// This method does not check for error conditon (newState == prevState)
diff --git a/src/com/android/bluetooth/a2dpsink/A2dpSinkService.java b/src/com/android/bluetooth/a2dpsink/A2dpSinkService.java
old mode 100644
new mode 100755
index 5271cc7..41a0db4
--- a/src/com/android/bluetooth/a2dpsink/A2dpSinkService.java
+++ b/src/com/android/bluetooth/a2dpsink/A2dpSinkService.java
@@ -21,11 +21,17 @@
import android.bluetooth.BluetoothProfile;
import android.bluetooth.IBluetoothA2dpSink;
import android.util.Log;
+import android.os.SystemProperties;
+
import com.android.bluetooth.Utils;
import com.android.bluetooth.btservice.AdapterService;
+import com.android.bluetooth.a2dp.A2dpService;
+import com.android.bluetooth.hfp.HeadsetService;
import com.android.bluetooth.btservice.ProfileService;
import com.android.internal.annotations.VisibleForTesting;
+import com.android.bluetooth.avrcpcontroller.AvrcpControllerService;
+
import java.util.ArrayList;
import java.util.Arrays;
@@ -40,16 +46,23 @@
*/
public class A2dpSinkService extends ProfileService {
private static final String TAG = "A2dpSinkService";
- private static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
- static final int MAXIMUM_CONNECTED_DEVICES = 1;
+ private static final boolean DBG = true;
+ //static final int MAX_ALLOWED_SINK_CONNECTIONS = 2;
private final BluetoothAdapter mAdapter;
- protected Map<BluetoothDevice, A2dpSinkStateMachine> mDeviceStateMap =
+ protected static Map<BluetoothDevice, A2dpSinkStateMachine> mDeviceStateMap =
new ConcurrentHashMap<>(1);
- private A2dpSinkStreamHandler mA2dpSinkStreamHandler;
+ private static final Object mBtA2dpLock = new Object();
+ private static A2dpSinkStreamHandler mA2dpSinkStreamHandler;
private static A2dpSinkService sService;
+ private static A2dpService sA2dpService;
+ private static HeadsetService sHeadsetService;
+ private static boolean mA2dpSrcSnkConcurrency;
+ protected static BluetoothDevice mStreamingDevice;
+ private static int mMaxA2dpSinkConnections = 1;
+ public static final int MAX_ALLOWED_SINK_CONNECTIONS = 2;
static {
classInitNative();
}
@@ -59,14 +72,24 @@
initNative();
sService = this;
mA2dpSinkStreamHandler = new A2dpSinkStreamHandler(this, this);
+ mMaxA2dpSinkConnections = Math.min(
+ SystemProperties.getInt("persist.vendor.bt.a2dp.sink_conn", 1),
+ MAX_ALLOWED_SINK_CONNECTIONS);
+ mA2dpSrcSnkConcurrency= SystemProperties.getBoolean(
+ "persist.vendor.service.bt.a2dp_concurrency", false);
+ if (DBG) {
+ Log.d(TAG, "A2DP concurrency set to " + mA2dpSrcSnkConcurrency);
+ }
return true;
}
@Override
protected boolean stop() {
- for (A2dpSinkStateMachine stateMachine : mDeviceStateMap.values()) {
- stateMachine.quitNow();
- }
+ synchronized (mBtA2dpLock) {
+ for (A2dpSinkStateMachine stateMachine : mDeviceStateMap.values()) {
+ stateMachine.quitNow();
+ }
+ }
sService = null;
return true;
}
@@ -91,6 +114,13 @@
* Request audio focus such that the designated device can stream audio
*/
public void requestAudioFocus(BluetoothDevice device, boolean request) {
+ A2dpSinkStateMachine stateMachine = null;
+ synchronized (mBtA2dpLock) {
+ stateMachine = mDeviceStateMap.get(device);
+ if (stateMachine == null) {
+ return;
+ }
+ }
mA2dpSinkStreamHandler.requestAudioFocus(request);
}
@@ -230,6 +260,22 @@
}
A2dpSinkStateMachine stateMachine = getOrCreateStateMachine(device);
if (stateMachine != null) {
+ if (mA2dpSrcSnkConcurrency) {
+ //in A2dp Concurrency mode, it need to disconnect all sink devices and headset clients
+ //before connecting to A2dp Source device.
+ sA2dpService = A2dpService.getA2dpService();
+ List<BluetoothDevice> snkDevs = sA2dpService.getConnectedDevices();
+ for( BluetoothDevice snk : snkDevs ) {
+ Log.d(TAG, "calling src disconnect to " + snk);
+ sA2dpService.disconnect(snk);
+ }
+ sHeadsetService = HeadsetService.getHeadsetService();
+ List<BluetoothDevice> hsDevs = sHeadsetService.getConnectedDevices();
+ for ( BluetoothDevice hs : hsDevs ) {
+ Log.d(TAG, "calling headset disconnect to " + hs);
+ sHeadsetService.disconnect(hs);
+ }
+ }
stateMachine.connect();
return true;
} else {
@@ -277,13 +323,93 @@
}
protected A2dpSinkStateMachine getOrCreateStateMachine(BluetoothDevice device) {
- A2dpSinkStateMachine stateMachine = mDeviceStateMap.get(device);
- if (stateMachine == null) {
- stateMachine = newStateMachine(device);
- mDeviceStateMap.put(device, stateMachine);
- stateMachine.start();
+ if (device == null) {
+ Log.e(TAG, "getOrCreateStateMachine failed: device cannot be null");
+ return null;
}
- return stateMachine;
+ synchronized (mBtA2dpLock) {
+ A2dpSinkStateMachine stateMachine = mDeviceStateMap.get(device);
+ if (stateMachine == null) {
+ // Limit the maximum number of state machines to avoid DoS
+ if (mDeviceStateMap.size() >= mMaxA2dpSinkConnections) {
+ Log.e(TAG, "Maximum number of A2DP Sink Connections reached: "
+ + mMaxA2dpSinkConnections);
+ return null;
+ }
+ Log.d(TAG, "Creating a new state machine for " + device);
+ stateMachine = newStateMachine(device);
+ mDeviceStateMap.put(device, stateMachine);
+ stateMachine.start();
+ }
+ return stateMachine;
+ }
+ }
+
+ public static BluetoothDevice getCurrentStreamingDevice() {
+ return mStreamingDevice;
+ }
+
+ public void informTGStatePlaying(BluetoothDevice device, boolean isPlaying) {
+ Log.d(TAG, "informTGStatePlaying: device: " + device
+ + ", mStreamingDevice:" + mStreamingDevice);
+ A2dpSinkStateMachine mStateMachine = null;
+ synchronized (mBtA2dpLock) {
+ mStateMachine = mDeviceStateMap.get(device);
+ if (mStateMachine == null) {
+ return;
+ }
+ }
+ if (mStateMachine != null) {
+ if (!isPlaying) {
+ //mStateMachine.sendMessage(A2dpSinkStateMachine.EVENT_AVRCP_TG_PAUSE);
+ mA2dpSinkStreamHandler.obtainMessage(
+ A2dpSinkStreamHandler.SRC_PAUSE).sendToTarget();
+ } else {
+ // Soft-Handoff from AVRCP Cmd (if received before AVDTP_START)
+ initiateHandoffOperations(device);
+ if (mStreamingDevice != null && !mStreamingDevice.equals(device)) {
+ Log.d(TAG, "updating streaming device after avrcp status command");
+ mStreamingDevice = device;
+ }
+ //mStateMachine.sendMessage(A2dpSinkStateMachine.EVENT_AVRCP_TG_PLAY);
+ mA2dpSinkStreamHandler.obtainMessage(
+ A2dpSinkStreamHandler.SRC_PLAY).sendToTarget();
+ }
+ }
+ }
+
+ /* This API performs all the operations required for doing soft-Handoff */
+ public synchronized void initiateHandoffOperations(BluetoothDevice device) {
+ if (mStreamingDevice != null && !mStreamingDevice.equals(device)) {
+ Log.d(TAG, "Soft-Handoff. Prev Device:" + mStreamingDevice + ", New: " + device);
+
+ for (A2dpSinkStateMachine otherSm: mDeviceStateMap.values()) {
+ BluetoothDevice otherDevice = otherSm.getDevice();
+ if (mStreamingDevice.equals(otherDevice)) {
+ Log.d(TAG, "Release Audio Focus for " + otherDevice);
+ mA2dpSinkStreamHandler.obtainMessage(
+ A2dpSinkStreamHandler.RELEASE_FOCUS).sendToTarget();
+ // Send Passthrough Command for PAUSE
+ AvrcpControllerService avrcpService =
+ AvrcpControllerService.getAvrcpControllerService();
+ avrcpService.sendPassThroughCommandNative(Utils.getByteAddress(mStreamingDevice),
+ AvrcpControllerService.PASS_THRU_CMD_ID_PAUSE,
+ AvrcpControllerService.KEY_STATE_PRESSED);
+ avrcpService.sendPassThroughCommandNative(Utils.getByteAddress(mStreamingDevice),
+ AvrcpControllerService.PASS_THRU_CMD_ID_PAUSE,
+ AvrcpControllerService.KEY_STATE_RELEASED);
+ /* set autoconnect priority of non-streaming device to PRIORITY_ON and priority
+ * of streaming device to PRIORITY_AUTO_CONNECT */
+ avrcpService.onDeviceUpdated(device);
+ setPriority(otherDevice, BluetoothProfile.PRIORITY_ON);
+ setPriority(device, BluetoothProfile.PRIORITY_AUTO_CONNECT);
+ break;
+ }
+ }
+ } else if (mStreamingDevice == null && device != null) {
+ Log.d(TAG, "Prev Device: Null. New Streaming Device: " + device);
+ // No Action Required
+ }
}
List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {
@@ -305,7 +431,7 @@
return deviceList;
}
- synchronized int getConnectionState(BluetoothDevice device) {
+ synchronized public int getConnectionState(BluetoothDevice device) {
A2dpSinkStateMachine stateMachine = mDeviceStateMap.get(device);
return (stateMachine == null) ? BluetoothProfile.STATE_DISCONNECTED
: stateMachine.getState();
@@ -318,7 +444,7 @@
* @param priority the priority of the profile
* @return true on success, otherwise false
*/
- public boolean setPriority(BluetoothDevice device, int priority) {
+ public boolean setPriority(BluetoothDevice device, int priority) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
if (DBG) {
Log.d(TAG, "Saved priority " + device + " = " + priority);
@@ -363,6 +489,14 @@
boolean isA2dpPlaying(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ Log.d(TAG, "isA2dpPlaying(" + device + ")");
+ A2dpSinkStateMachine sm = null;
+ synchronized (mBtA2dpLock) {
+ sm = mDeviceStateMap.get(device);
+ if (sm == null) {
+ return false;
+ }
+ }
return mA2dpSinkStreamHandler.isPlaying();
}
@@ -404,13 +538,57 @@
public native void informAudioTrackGainNative(float gain);
private void onConnectionStateChanged(byte[] address, int state) {
+ BluetoothDevice device = getDevice(address);
+ Log.d(TAG, "onConnectionStateChanged. State = " + state + ", device:" + device
+ + ", streaming:" + mStreamingDevice);
+
StackEvent event = StackEvent.connectionStateChanged(getDevice(address), state);
A2dpSinkStateMachine stateMachine = getOrCreateStateMachine(event.mDevice);
+
+ if (stateMachine == null || device == null) {
+ Log.e(TAG, "State Machine not found for device:" + device + ". Return.");
+ return;
+ }
+
+ // If streaming device is disconnected, release audio focus and update mStreamingDevice
+ if (state == BluetoothProfile.STATE_DISCONNECTED && device.equals(mStreamingDevice)) {
+ Log.d(TAG, "Release Audio Focus for Streaming device: " + device);
+ mA2dpSinkStreamHandler.obtainMessage(
+ A2dpSinkStreamHandler.RELEASE_FOCUS).sendToTarget();
+ mStreamingDevice = null;
+ }
+
+ if (mA2dpSrcSnkConcurrency &&
+ (state == BluetoothProfile.STATE_CONNECTING ||
+ state == BluetoothProfile.STATE_CONNECTED)) {
+ sA2dpService = A2dpService.getA2dpService();
+ List<BluetoothDevice> snkDevs = sA2dpService.getConnectedDevices();
+ for ( BluetoothDevice snk : snkDevs ) {
+ Log.d(TAG, "calling src disconnect to " + snk);
+ sA2dpService.disconnect(snk);
+ }
+ sHeadsetService = HeadsetService.getHeadsetService();
+ List<BluetoothDevice> hsDevs = sHeadsetService.getConnectedDevices();
+ for ( BluetoothDevice hs : hsDevs ) {
+ Log.d(TAG, "calling headset disconnect to " + hs);
+ sHeadsetService.disconnect(hs);
+ }
+ }
stateMachine.sendMessage(A2dpSinkStateMachine.STACK_EVENT, event);
}
private void onAudioStateChanged(byte[] address, int state) {
+ BluetoothDevice device = getDevice(address);
+ Log.d(TAG, "onAudioStateChanged. Audio State = " + state + ", device:" + device);
+
+ A2dpSinkStateMachine stateMachine = mDeviceStateMap.get(device);
+ if (stateMachine == null) {
+ return;
+ }
+
if (state == StackEvent.AUDIO_STATE_STARTED) {
+ initiateHandoffOperations(device);
+ mStreamingDevice = device;
mA2dpSinkStreamHandler.obtainMessage(
A2dpSinkStreamHandler.SRC_STR_START).sendToTarget();
} else if (state == StackEvent.AUDIO_STATE_STOPPED
@@ -421,6 +599,10 @@
}
private void onAudioConfigChanged(byte[] address, int sampleRate, int channelCount) {
+ BluetoothDevice device = getDevice(address);
+ Log.d(TAG, "onAudioConfigChanged:- device:" + device + " samplerate:" + sampleRate
+ + ", channelCount:" + channelCount);
+
StackEvent event = StackEvent.audioConfigChanged(getDevice(address), sampleRate,
channelCount);
A2dpSinkStateMachine stateMachine = getOrCreateStateMachine(event.mDevice);
diff --git a/src/com/android/bluetooth/a2dpsink/A2dpSinkStateMachine.java b/src/com/android/bluetooth/a2dpsink/A2dpSinkStateMachine.java
old mode 100644
new mode 100755
index 77ead16..13e73f2
--- a/src/com/android/bluetooth/a2dpsink/A2dpSinkStateMachine.java
+++ b/src/com/android/bluetooth/a2dpsink/A2dpSinkStateMachine.java
@@ -18,11 +18,13 @@
import static android.bluetooth.BluetoothProfile.PRIORITY_OFF;
import android.bluetooth.BluetoothA2dpSink;
+import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothAudioConfig;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
import android.content.Intent;
import android.media.AudioFormat;
+import android.media.AudioSystem;
import android.os.Message;
import android.util.Log;
@@ -36,7 +38,7 @@
public class A2dpSinkStateMachine extends StateMachine {
static final String TAG = "A2DPSinkStateMachine";
- static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
+ static final boolean DBG = true;
//0->99 Events from Outside
public static final int CONNECT = 1;
@@ -45,6 +47,7 @@
//100->199 Internal Events
protected static final int CLEANUP = 100;
private static final int CONNECT_TIMEOUT = 101;
+ private static final String BT_ADDR_KEY = "bt_addr";
//200->299 Events from Native
static final int STACK_EVENT = 200;
@@ -58,6 +61,7 @@
protected final Connecting mConnecting;
protected final Connected mConnected;
protected final Disconnecting mDisconnecting;
+ private BluetoothAdapter mAdapter;
protected int mMostRecentState = BluetoothProfile.STATE_DISCONNECTED;
protected BluetoothAudioConfig mAudioConfig = null;
@@ -73,12 +77,19 @@
mConnecting = new Connecting();
mConnected = new Connected();
mDisconnecting = new Disconnecting();
+ mAdapter = BluetoothAdapter.getDefaultAdapter();
addState(mDisconnected);
addState(mConnecting);
addState(mConnected);
addState(mDisconnecting);
+ if (mAdapter != null) {
+ String bdAddr = mAdapter.getAddress();
+ AudioSystem.setParameters(BT_ADDR_KEY + "=" + bdAddr);
+ Log.e(TAG, "AudioSystem.setParameters, Key: " + BT_ADDR_KEY + " Value: " + bdAddr);
+ }
+
setInitialState(mDisconnected);
}
diff --git a/src/com/android/bluetooth/a2dpsink/A2dpSinkStreamHandler.java b/src/com/android/bluetooth/a2dpsink/A2dpSinkStreamHandler.java
index 5aa3cbb..79dc627 100644
--- a/src/com/android/bluetooth/a2dpsink/A2dpSinkStreamHandler.java
+++ b/src/com/android/bluetooth/a2dpsink/A2dpSinkStreamHandler.java
@@ -56,7 +56,7 @@
*/
public class A2dpSinkStreamHandler extends Handler {
private static final String TAG = "A2dpSinkStreamHandler";
- private static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
+ private static final boolean DBG = true;
// Configuration Variables
private static final int DEFAULT_DUCK_PERCENT = 25;
@@ -73,6 +73,7 @@
public static final int AUDIO_FOCUS_CHANGE = 7; // Audio focus callback with associated change
public static final int REQUEST_FOCUS = 8; // Request focus when the media service is active
public static final int DELAYED_PAUSE = 9; // If a call just started allow stack time to settle
+ public static final int RELEASE_FOCUS = 10;
// Used to indicate focus lost
private static final int STATE_FOCUS_LOST = 0;
@@ -140,9 +141,16 @@
switch (message.what) {
case SRC_STR_START:
mStreamAvailable = true;
+ Log.d(TAG, " isTvDevice = " + isTvDevice() +
+ "shouldRequestFocus = " + shouldRequestFocus());
if (isTvDevice() || shouldRequestFocus()) {
requestAudioFocusIfNone();
}
+
+ // Audio stream has started, stop it if we don't have focus.
+ if (mAudioFocus == AudioManager.AUDIOFOCUS_NONE) {
+ requestAudioFocus();
+ }
break;
case SRC_STR_STOP:
@@ -166,6 +174,11 @@
requestAudioFocusIfNone();
break;
}
+
+ // Audio stream has started, stop it if we don't have focus.
+ if (mAudioFocus == AudioManager.AUDIOFOCUS_NONE) {
+ requestAudioFocus();
+ }
break;
case SRC_PAUSE:
@@ -177,6 +190,10 @@
requestAudioFocusIfNone();
break;
+ case RELEASE_FOCUS:
+ abandonAudioFocus();
+ break;
+
case DISCONNECT:
// Remote device has disconnected, restore everything to default state.
mSentPause = false;
@@ -247,25 +264,30 @@
private void requestAudioFocusIfNone() {
if (DBG) Log.d(TAG, "requestAudioFocusIfNone()");
if (mAudioFocus != AudioManager.AUDIOFOCUS_GAIN) {
+ Log.d(TAG, " mAudioFocus = " + mAudioFocus);
requestAudioFocus();
}
}
private synchronized int requestAudioFocus() {
- if (DBG) Log.d(TAG, "requestAudioFocus()");
// Bluetooth A2DP may carry Music, Audio Books, Navigation, or other sounds so mark content
// type unknown.
+ Log.d(TAG, " requestAudioFocus() ");
AudioAttributes streamAttributes =
new AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_MEDIA)
.setContentType(AudioAttributes.CONTENT_TYPE_UNKNOWN)
.build();
- // Bluetooth ducking is handled at the native layer at the request of AudioManager.
+ // Bluetooth ducking is handled at the native layer so tell the Audio Manger to notify the
+ // focus change listener via .setWillPauseWhenDucked().
AudioFocusRequest focusRequest =
new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN).setAudioAttributes(
streamAttributes)
+ .setWillPauseWhenDucked(true)
.setOnAudioFocusChangeListener(mAudioFocusListener, this)
.build();
int focusRequestStatus = mAudioManager.requestAudioFocus(focusRequest);
+ Log.d(TAG, " focusRequestStatus = " + focusRequestStatus +
+ " focusRequest: " + focusRequest);
// If the request is granted begin streaming immediately and schedule an upgrade.
if (focusRequestStatus == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
startFluorideStreaming();
@@ -312,10 +334,22 @@
}
private synchronized void abandonAudioFocus() {
- if (DBG) Log.d(TAG, "abandonAudioFocus()");
stopFluorideStreaming();
- mAudioManager.abandonAudioFocus(mAudioFocusListener);
- mAudioFocus = AudioManager.AUDIOFOCUS_NONE;
+ if (mAudioFocus != AudioManager.AUDIOFOCUS_NONE) {
+ Log.d(TAG, "abandoning audio focus");
+ AudioAttributes streamAttributes =
+ new AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_MEDIA)
+ .setContentType(AudioAttributes.CONTENT_TYPE_UNKNOWN)
+ .build();
+ AudioFocusRequest mfocusRequest =
+ new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN).setAudioAttributes(
+ streamAttributes)
+ .setWillPauseWhenDucked(true)
+ .setOnAudioFocusChangeListener(mAudioFocusListener, this)
+ .build();
+ mAudioManager.abandonAudioFocusRequest(mfocusRequest);
+ mAudioFocus = AudioManager.AUDIOFOCUS_NONE;
+ }
}
/**
diff --git a/src/com/android/bluetooth/avrcp/AddressedMediaPlayer.java b/src/com/android/bluetooth/avrcp/AddressedMediaPlayer.java
new file mode 100644
index 0000000..f8a9cf6
--- /dev/null
+++ b/src/com/android/bluetooth/avrcp/AddressedMediaPlayer.java
@@ -0,0 +1,646 @@
+/*
+ * Copyright (C) 2016 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.bluetooth.avrcp;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.media.MediaDescription;
+import android.media.MediaMetadata;
+import android.media.session.MediaSession;
+import android.media.session.MediaSession.QueueItem;
+import android.media.session.PlaybackState;
+import android.os.Bundle;
+import android.util.Log;
+
+import com.android.bluetooth.Utils;
+import com.android.bluetooth.btservice.ProfileService;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/*************************************************************************************************
+ * Provides functionality required for Addressed Media Player, like Now Playing List related
+ * browsing commands, control commands to the current addressed player(playItem, play, pause, etc)
+ * Acts as an Interface to communicate with media controller APIs for NowPlayingItems.
+ ************************************************************************************************/
+
+public class AddressedMediaPlayer {
+ private static final String TAG = "AddressedMediaPlayer";
+ private static final Boolean DEBUG = true;
+
+ private static final long SINGLE_QID = 1;
+ private static final String UNKNOWN_TITLE = "(unknown)";
+
+ static private final String GPM_BUNDLE_METADATA_KEY =
+ "com.google.android.music.mediasession.music_metadata";
+
+ private AvrcpMediaRspInterface mMediaInterface;
+ private Avrcp_ext mAvrcp = null;
+ @NonNull private List<MediaSession.QueueItem> mNowPlayingList;
+
+ private final List<MediaSession.QueueItem> mEmptyNowPlayingList;
+
+ private long mLastTrackIdSent;
+
+ public AddressedMediaPlayer(AvrcpMediaRspInterface mediaInterface) {
+ mEmptyNowPlayingList = new ArrayList<MediaSession.QueueItem>();
+ mNowPlayingList = mEmptyNowPlayingList;
+ mMediaInterface = mediaInterface;
+ mLastTrackIdSent = MediaSession.QueueItem.UNKNOWN_ID;
+ }
+
+ public AddressedMediaPlayer(AvrcpMediaRspInterface mediaInterface, Avrcp_ext mAvrcp_ext) {
+ this(mediaInterface);
+ mAvrcp = mAvrcp_ext;
+ }
+
+ void cleanup() {
+ if (DEBUG) {
+ Log.v(TAG, "cleanup");
+ }
+ mNowPlayingList = mEmptyNowPlayingList;
+ mMediaInterface = null;
+ mLastTrackIdSent = MediaSession.QueueItem.UNKNOWN_ID;
+ }
+
+ /* get now playing list from addressed player */
+ void getFolderItemsNowPlaying(byte[] bdaddr, AvrcpCmd.FolderItemsCmd reqObj,
+ @Nullable MediaController mediaController) {
+ if (mediaController == null) {
+ // No players (if a player exists, we would have selected it)
+ Log.e(TAG, "mediaController = null, sending no available players response");
+ mMediaInterface.folderItemsRsp(bdaddr, AvrcpConstants.RSP_NO_AVBL_PLAY, null);
+ return;
+ }
+ List<MediaSession.QueueItem> items = updateNowPlayingList(mediaController);
+ getFolderItemsFilterAttr(bdaddr, reqObj, items, AvrcpConstants.BTRC_SCOPE_NOW_PLAYING,
+ reqObj.mStartItem, reqObj.mEndItem, mediaController);
+ }
+
+ /* get item attributes for item in now playing list */
+ void getItemAttr(byte[] bdaddr, AvrcpCmd.ItemAttrCmd itemAttr,
+ @Nullable MediaController mediaController) {
+ int status = AvrcpConstants.RSP_NO_ERROR;
+ long mediaId = ByteBuffer.wrap(itemAttr.mUid).getLong();
+ List<MediaSession.QueueItem> items = updateNowPlayingList(mediaController);
+
+ // NOTE: this is out-of-spec (AVRCP 1.6.1 sec 6.10.4.3, p90) but we answer it anyway
+ // because some CTs ask for it.
+ if (Arrays.equals(itemAttr.mUid, AvrcpConstants.TRACK_IS_SELECTED)) {
+ mediaId = getActiveQueueItemId(mediaController);
+ if (DEBUG) {
+ Log.d(TAG, "getItemAttr: Remote requests for now playing contents, sending UID: "
+ + mediaId);
+ }
+ }
+
+ if (DEBUG) {
+ Log.d(TAG, "getItemAttr-UID: 0x" + Utils.byteArrayToString(itemAttr.mUid));
+ }
+ for (MediaSession.QueueItem item : items) {
+ if (item.getQueueId() == mediaId) {
+ getItemAttrFilterAttr(bdaddr, itemAttr, item, mediaController);
+ return;
+ }
+ }
+
+ // Couldn't find it, so the id is invalid
+ mMediaInterface.getItemAttrRsp(bdaddr, AvrcpConstants.RSP_INV_ITEM, null);
+ }
+
+ /* Refresh and get the queue of now playing.
+ */
+ @NonNull
+ List<MediaSession.QueueItem> updateNowPlayingList(@Nullable MediaController mediaController) {
+ if (mediaController == null) {
+ return mEmptyNowPlayingList;
+ }
+ List<MediaSession.QueueItem> items = mediaController.getQueue();
+ if (items == null) {
+ Log.i(TAG, "null queue from " + mediaController.getPackageName()
+ + ", constructing single-item list");
+
+ // Because we are database-unaware, we can just number the item here whatever we want
+ // because they have to re-poll it every time.
+ MediaMetadata metadata = mediaController.getMetadata();
+ if (metadata == null) {
+ Log.w(TAG, "Controller has no metadata!? Making an empty one");
+ metadata = (new MediaMetadata.Builder()).build();
+ }
+
+ MediaDescription.Builder bob = new MediaDescription.Builder();
+ MediaDescription desc = metadata.getDescription();
+
+ // set the simple ones that MediaMetadata builds for us
+ bob.setMediaId(desc.getMediaId());
+ bob.setTitle(desc.getTitle());
+ bob.setSubtitle(desc.getSubtitle());
+ bob.setDescription(desc.getDescription());
+ // fill the ones that we use later
+ bob.setExtras(fillBundle(metadata, desc.getExtras()));
+
+ // build queue item with the new metadata
+ MediaSession.QueueItem current = new QueueItem(bob.build(), SINGLE_QID);
+
+ items = new ArrayList<MediaSession.QueueItem>();
+ items.add(current);
+ }
+
+ if (!items.equals(mNowPlayingList)) {
+ sendNowPlayingListChanged();
+ }
+ mNowPlayingList = items;
+
+ return mNowPlayingList;
+ }
+
+ private void sendNowPlayingListChanged() {
+ if (mMediaInterface == null) {
+ return;
+ }
+ if (DEBUG) {
+ Log.d(TAG, "sendNowPlayingListChanged()");
+ }
+ mMediaInterface.nowPlayingChangedRsp(AvrcpConstants.NOTIFICATION_TYPE_CHANGED);
+ }
+
+ private Bundle fillBundle(MediaMetadata metadata, Bundle currentExtras) {
+ if (metadata == null) {
+ Log.i(TAG, "fillBundle: metadata is null");
+ return currentExtras;
+ }
+
+ Bundle bundle = currentExtras;
+ if (bundle == null) {
+ bundle = new Bundle();
+ }
+
+ String[] stringKeys = {
+ MediaMetadata.METADATA_KEY_TITLE,
+ MediaMetadata.METADATA_KEY_ARTIST,
+ MediaMetadata.METADATA_KEY_ALBUM,
+ MediaMetadata.METADATA_KEY_GENRE
+ };
+ for (String key : stringKeys) {
+ String current = bundle.getString(key);
+ if (current == null) {
+ bundle.putString(key, metadata.getString(key));
+ }
+ }
+
+ String[] longKeys = {
+ MediaMetadata.METADATA_KEY_TRACK_NUMBER,
+ MediaMetadata.METADATA_KEY_NUM_TRACKS,
+ MediaMetadata.METADATA_KEY_DURATION
+ };
+ for (String key : longKeys) {
+ if (!bundle.containsKey(key)) {
+ bundle.putLong(key, metadata.getLong(key));
+ }
+ }
+ return bundle;
+ }
+
+ /* Instructs media player to play particular media item */
+ void playItem(byte[] bdaddr, byte[] uid, @Nullable MediaController mediaController) {
+ long qid = ByteBuffer.wrap(uid).getLong();
+ List<MediaSession.QueueItem> items = updateNowPlayingList(mediaController);
+
+ if (mediaController == null) {
+ Log.e(TAG, "No mediaController when PlayItem " + qid + " requested");
+ mMediaInterface.playItemRsp(bdaddr, AvrcpConstants.RSP_INTERNAL_ERR);
+ return;
+ }
+
+ MediaController.TransportControls mediaControllerCntrl =
+ mediaController.getTransportControls();
+
+ if (items == null) {
+ Log.w(TAG, "nowPlayingItems is null");
+ mMediaInterface.playItemRsp(bdaddr, AvrcpConstants.RSP_INTERNAL_ERR);
+ return;
+ }
+
+ for (MediaSession.QueueItem item : items) {
+ if (qid == item.getQueueId()) {
+ if (DEBUG) {
+ Log.d(TAG, "Skipping to ID " + qid);
+ }
+ mediaControllerCntrl.skipToQueueItem(qid);
+ mMediaInterface.playItemRsp(bdaddr, AvrcpConstants.RSP_NO_ERROR);
+ return;
+ }
+ }
+
+ Log.w(TAG, "Invalid now playing Queue ID " + qid);
+ mMediaInterface.playItemRsp(bdaddr, AvrcpConstants.RSP_INV_ITEM);
+ }
+
+ void getTotalNumOfItems(byte[] bdaddr, @Nullable MediaController mediaController) {
+ List<MediaSession.QueueItem> items = updateNowPlayingList(mediaController);
+ if (DEBUG) {
+ Log.d(TAG, "getTotalNumOfItems: " + items.size() + " items.");
+ }
+ mMediaInterface.getTotalNumOfItemsRsp(bdaddr, AvrcpConstants.RSP_NO_ERROR, 0, items.size());
+ }
+
+ void sendTrackChangeWithId(int type, @Nullable MediaController mediaController) {
+ Log.d(TAG, "sendTrackChangeWithId (" + type + "): controller " + mediaController);
+ long qid = getActiveQueueItemId(mediaController);
+ byte[] track = ByteBuffer.allocate(AvrcpConstants.UID_SIZE).putLong(qid).array();
+ Log.d(TAG, "qid: " + qid );
+ if ((type == AvrcpConstants.NOTIFICATION_TYPE_INTERIM) &&
+ (qid != MediaSession.QueueItem.UNKNOWN_ID) &&
+ (qid != mLastTrackIdSent)) {
+ byte[] lastTrack =
+ ByteBuffer.allocate(AvrcpConstants.UID_SIZE).putLong(mLastTrackIdSent).array();
+ mMediaInterface.trackChangedRsp(type, lastTrack);
+ type = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ }
+ // The nowPlayingList changed: the new list has the full data for the current item
+ Log.d(TAG, "last_sent_qid: " + mLastTrackIdSent);
+ mMediaInterface.trackChangedRsp(type, track);
+ mLastTrackIdSent = qid;
+ }
+
+ void sendTrackChangeWithId(int type, @Nullable MediaController mediaController, byte[] bdaddr) {
+ Log.d(TAG, "sendTrackChangeWithId (" + type + "): controller " + mediaController);
+ if(mAvrcp == null) {
+ sendTrackChangeWithId(type, mediaController);
+ return;
+ }
+ long qid = getActiveQueueItemId(mediaController);
+ byte[] track = ByteBuffer.allocate(AvrcpConstants.UID_SIZE).putLong(qid).array();
+ Log.d(TAG, "qid: " + qid );
+ if ((type == AvrcpConstants.NOTIFICATION_TYPE_INTERIM) &&
+ (qid != MediaSession.QueueItem.UNKNOWN_ID) &&
+ (qid != mLastTrackIdSent)) {
+ byte[] lastTrack =
+ ByteBuffer.allocate(AvrcpConstants.UID_SIZE).putLong(mLastTrackIdSent).array();
+ mAvrcp.trackChangedAddressedRsp(type, lastTrack, bdaddr);
+ type = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ }
+ // The nowPlayingList changed: the new list has the full data for the current item
+ Log.d(TAG, "last_sent_qid: " + mLastTrackIdSent);
+ mAvrcp.trackChangedAddressedRsp(type, track, bdaddr);
+ mLastTrackIdSent = qid;
+ }
+
+ /*
+ * helper method to check if startItem and endItem index is with range of
+ * MediaItem list. (Resultset containing all items in current path)
+ */
+ @Nullable
+ private List<MediaSession.QueueItem> getQueueSubset(@NonNull List<MediaSession.QueueItem> items,
+ long startItem, long endItem) {
+ if (endItem > items.size()) {
+ endItem = items.size() - 1;
+ }
+ if (startItem > Integer.MAX_VALUE) {
+ startItem = Integer.MAX_VALUE;
+ }
+ try {
+ List<MediaSession.QueueItem> selected =
+ items.subList((int) startItem, (int) Math.min(items.size(), endItem + 1));
+ if (selected.isEmpty()) {
+ Log.i(TAG, "itemsSubList is empty.");
+ return null;
+ }
+ return selected;
+ } catch (IndexOutOfBoundsException ex) {
+ Log.i(TAG, "Range (" + startItem + ", " + endItem + ") invalid");
+ } catch (IllegalArgumentException ex) {
+ Log.i(TAG, "Range start " + startItem + " > size (" + items.size() + ")");
+ }
+ return null;
+ }
+
+ /*
+ * helper method to filter required attibutes before sending GetFolderItems
+ * response
+ */
+ private void getFolderItemsFilterAttr(byte[] bdaddr, AvrcpCmd.FolderItemsCmd folderItemsReqObj,
+ @NonNull List<MediaSession.QueueItem> items, byte scope, long startItem, long endItem,
+ @NonNull MediaController mediaController) {
+ if (DEBUG) {
+ Log.d(TAG,
+ "getFolderItemsFilterAttr: startItem =" + startItem + ", endItem = " + endItem);
+ }
+
+ List<MediaSession.QueueItem> resultItems = getQueueSubset(items, startItem, endItem);
+ /* check for index out of bound errors */
+ if (resultItems == null) {
+ Log.w(TAG, "getFolderItemsFilterAttr: resultItems is empty");
+ mMediaInterface.folderItemsRsp(bdaddr, AvrcpConstants.RSP_INV_RANGE, null);
+ return;
+ }
+
+ FolderItemsData folderDataNative = new FolderItemsData(resultItems.size());
+
+ /* variables to accumulate attrs */
+ ArrayList<String> attrArray = new ArrayList<String>();
+ ArrayList<Integer> attrId = new ArrayList<Integer>();
+
+ for (int itemIndex = 0; itemIndex < resultItems.size(); itemIndex++) {
+ MediaSession.QueueItem item = resultItems.get(itemIndex);
+ // get the queue id
+ long qid = item.getQueueId();
+ byte[] uid = ByteBuffer.allocate(AvrcpConstants.UID_SIZE).putLong(qid).array();
+
+ // get the array of uid from 2d to array 1D array
+ for (int idx = 0; idx < AvrcpConstants.UID_SIZE; idx++) {
+ folderDataNative.mItemUid[itemIndex * AvrcpConstants.UID_SIZE + idx] = uid[idx];
+ }
+
+ /* Set display name for current item */
+ folderDataNative.mDisplayNames[itemIndex] =
+ getAttrValue(bdaddr, AvrcpConstants.ATTRID_TITLE, item, mediaController);
+
+ int maxAttributesRequested = 0;
+ boolean isAllAttribRequested = false;
+ /* check if remote requested for attributes */
+ if (folderItemsReqObj.mNumAttr != AvrcpConstants.NUM_ATTR_NONE) {
+ int attrCnt = 0;
+
+ /* add requested attr ids to a temp array */
+ if (folderItemsReqObj.mNumAttr == AvrcpConstants.NUM_ATTR_ALL) {
+ isAllAttribRequested = true;
+ maxAttributesRequested = AvrcpConstants.MAX_NUM_ATTR;
+ } else {
+ /* get only the requested attribute ids from the request */
+ maxAttributesRequested = folderItemsReqObj.mNumAttr;
+ }
+
+ /* lookup and copy values of attributes for ids requested above */
+ for (int idx = 0; idx < maxAttributesRequested; idx++) {
+ /* check if media player provided requested attributes */
+ String value = null;
+
+ int attribId =
+ isAllAttribRequested ? (idx + 1) : folderItemsReqObj.mAttrIDs[idx];
+ value = getAttrValue(bdaddr, attribId, item, mediaController);
+ if (value != null) {
+ attrArray.add(value);
+ attrId.add(attribId);
+ attrCnt++;
+ }
+ }
+ /* add num attr actually received from media player for a particular item */
+ folderDataNative.mAttributesNum[itemIndex] = attrCnt;
+ }
+ }
+
+ /* copy filtered attr ids and attr values to response parameters */
+ if (folderItemsReqObj.mNumAttr != AvrcpConstants.NUM_ATTR_NONE) {
+ folderDataNative.mAttrIds = new int[attrId.size()];
+ for (int attrIndex = 0; attrIndex < attrId.size(); attrIndex++) {
+ folderDataNative.mAttrIds[attrIndex] = attrId.get(attrIndex);
+ }
+ folderDataNative.mAttrValues = attrArray.toArray(new String[attrArray.size()]);
+ }
+ for (int attrIndex = 0; attrIndex < folderDataNative.mAttributesNum.length; attrIndex++) {
+ if (DEBUG) {
+ Log.d(TAG, "folderDataNative.mAttributesNum"
+ + folderDataNative.mAttributesNum[attrIndex] + " attrIndex " + attrIndex);
+ }
+ }
+
+ /* create rsp object and send response to remote device */
+ FolderItemsRsp rspObj =
+ new FolderItemsRsp(AvrcpConstants.RSP_NO_ERROR, Avrcp.sUIDCounter, scope,
+ folderDataNative.mNumItems, folderDataNative.mFolderTypes,
+ folderDataNative.mPlayable, folderDataNative.mItemTypes,
+ folderDataNative.mItemUid, folderDataNative.mDisplayNames,
+ folderDataNative.mAttributesNum, folderDataNative.mAttrIds,
+ folderDataNative.mAttrValues);
+ mMediaInterface.folderItemsRsp(bdaddr, AvrcpConstants.RSP_NO_ERROR, rspObj);
+ }
+
+ private String getAttrValue(byte []bdaddr, int attr, MediaSession.QueueItem item,
+ @Nullable MediaController mediaController) {
+ String attrValue = null;
+ if (item == null) {
+ if (DEBUG) {
+ Log.d(TAG, "getAttrValue received null item");
+ }
+ return null;
+ }
+ try {
+ MediaDescription desc = item.getDescription();
+ Bundle extras = desc.getExtras();
+ boolean isCurrentTrack = item.getQueueId() == getActiveQueueItemId(mediaController);
+ MediaMetadata data = null;
+ if (isCurrentTrack) {
+ if (DEBUG) {
+ Log.d(TAG, "getAttrValue: item is active, using current data");
+ }
+ data = mediaController.getMetadata();
+ if (data == null) {
+ Log.e(TAG, "getMetadata didn't give us any metadata for the current track");
+ }
+ }
+
+ if (data == null) {
+ // TODO: This code can be removed when b/63117921 is resolved
+ data = (MediaMetadata) extras.get(GPM_BUNDLE_METADATA_KEY);
+ extras = null; // We no longer need the data in here
+ }
+
+ extras = fillBundle(data, extras);
+
+ if (DEBUG) {
+ Log.d(TAG, "getAttrValue: item " + item + " : " + desc);
+ }
+ switch (attr) {
+ case AvrcpConstants.ATTRID_TITLE:
+ /* Title is mandatory attribute */
+ if (isCurrentTrack) {
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_TITLE);
+ } else {
+ attrValue = desc.getTitle().toString();
+ }
+ if (attrValue == null)
+ attrValue = "<Unknown Title>";
+ break;
+
+ case AvrcpConstants.ATTRID_ARTIST:
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_ARTIST);
+ break;
+
+ case AvrcpConstants.ATTRID_ALBUM:
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_ALBUM);
+ break;
+
+ case AvrcpConstants.ATTRID_TRACK_NUM:
+ attrValue =
+ Long.toString(extras.getLong(MediaMetadata.METADATA_KEY_TRACK_NUMBER));
+ break;
+
+ case AvrcpConstants.ATTRID_NUM_TRACKS:
+ attrValue =
+ Long.toString(extras.getLong(MediaMetadata.METADATA_KEY_NUM_TRACKS));
+ break;
+
+ case AvrcpConstants.ATTRID_GENRE:
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_GENRE);
+ break;
+
+ case AvrcpConstants.ATTRID_PLAY_TIME:
+ attrValue = Long.toString(extras.getLong(MediaMetadata.METADATA_KEY_DURATION));
+ break;
+
+ case AvrcpConstants.ATTRID_COVER_ART:
+ if (mAvrcp != null) {
+ attrValue = mAvrcp.getImgHandleFromTitle(bdaddr,
+ desc.getTitle().toString());
+ } else {
+ if (DEBUG) Log.d(TAG, " mAvrcp null ");
+ }
+ break;
+
+ default:
+ Log.e(TAG, "getAttrValue: Unknown attribute ID requested: " + attr);
+ return null;
+ }
+ } catch (NullPointerException ex) {
+ Log.w(TAG, "getAttrValue: attr id not found in result");
+ /* checking if attribute is title, then it is mandatory and cannot send null */
+ if (attr == AvrcpConstants.ATTRID_TITLE) {
+ attrValue = "<Unknown Title>";
+ } else {
+ return null;
+ }
+ }
+ if (DEBUG) {
+ Log.d(TAG, "getAttrValue: attrvalue = " + attrValue + ", attr id: " + attr);
+ }
+ return attrValue;
+ }
+
+ private void getItemAttrFilterAttr(byte[] bdaddr, AvrcpCmd.ItemAttrCmd mItemAttrReqObj,
+ MediaSession.QueueItem mediaItem, @Nullable MediaController mediaController) {
+ /* Response parameters */
+ int[] attrIds = null; /* array of attr ids */
+ String[] attrValues = null; /* array of attr values */
+
+ /* variables to temperorily add attrs */
+ ArrayList<String> attrArray = new ArrayList<String>();
+ ArrayList<Integer> attrId = new ArrayList<Integer>();
+ ArrayList<Integer> attrTempId = new ArrayList<Integer>();
+
+ /* check if remote device has requested for attributes */
+ if (mItemAttrReqObj.mNumAttr != AvrcpConstants.NUM_ATTR_NONE) {
+ if (mItemAttrReqObj.mNumAttr == AvrcpConstants.NUM_ATTR_ALL) {
+ for (int idx = 1; idx < AvrcpConstants.MAX_NUM_ATTR; idx++) {
+ attrTempId.add(idx); /* attr id 0x00 is unused */
+ }
+ } else {
+ /* get only the requested attribute ids from the request */
+ for (int idx = 0; idx < mItemAttrReqObj.mNumAttr; idx++) {
+ if (DEBUG) {
+ Log.d(TAG, "getItemAttrFilterAttr: attr id[" + idx + "] :"
+ + mItemAttrReqObj.mAttrIDs[idx]);
+ }
+ attrTempId.add(mItemAttrReqObj.mAttrIDs[idx]);
+ }
+ }
+ }
+
+ if (DEBUG) {
+ Log.d(TAG, "getItemAttrFilterAttr: attr id list size:" + attrTempId.size());
+ }
+ /* lookup and copy values of attributes for ids requested above */
+ for (int idx = 0; idx < attrTempId.size(); idx++) {
+ /* check if media player provided requested attributes */
+ String value = getAttrValue(bdaddr, attrTempId.get(idx), mediaItem, mediaController);
+ if (value != null) {
+ attrArray.add(value);
+ attrId.add(attrTempId.get(idx));
+ }
+ }
+
+ /* copy filtered attr ids and attr values to response parameters */
+ if (mItemAttrReqObj.mNumAttr != AvrcpConstants.NUM_ATTR_NONE) {
+ attrIds = new int[attrId.size()];
+
+ for (int attrIndex = 0; attrIndex < attrId.size(); attrIndex++) {
+ attrIds[attrIndex] = attrId.get(attrIndex);
+ }
+
+ attrValues = attrArray.toArray(new String[attrId.size()]);
+
+ /* create rsp object and send response */
+ ItemAttrRsp rspObj = new ItemAttrRsp(AvrcpConstants.RSP_NO_ERROR, attrIds, attrValues);
+ mMediaInterface.getItemAttrRsp(bdaddr, AvrcpConstants.RSP_NO_ERROR, rspObj);
+ return;
+ }
+ }
+
+ private long getActiveQueueItemId(@Nullable MediaController controller) {
+ if (controller == null) {
+ return MediaSession.QueueItem.UNKNOWN_ID;
+ }
+ PlaybackState state = controller.getPlaybackState();
+ if (state == null || state.getState() == PlaybackState.STATE_NONE) {
+ return MediaSession.QueueItem.UNKNOWN_ID;
+ }
+ long qid = state.getActiveQueueItemId();
+ if (qid != MediaSession.QueueItem.UNKNOWN_ID) {
+ return qid;
+ }
+ // Check if we're presenting a "one item queue"
+ if (controller.getMetadata() != null) {
+ return SINGLE_QID;
+ }
+ return MediaSession.QueueItem.UNKNOWN_ID;
+ }
+
+ String displayMediaItem(MediaSession.QueueItem item) {
+ StringBuilder sb = new StringBuilder();
+ sb.append("#");
+ sb.append(item.getQueueId());
+ sb.append(": ");
+ sb.append(Utils.ellipsize(getAttrValue(null, AvrcpConstants.ATTRID_TITLE, item, null)));
+ sb.append(" - ");
+ sb.append(Utils.ellipsize(getAttrValue(null, AvrcpConstants.ATTRID_ALBUM, item, null)));
+ sb.append(" by ");
+ sb.append(Utils.ellipsize(getAttrValue(null, AvrcpConstants.ATTRID_ARTIST, item, null)));
+ sb.append(" (");
+ sb.append(getAttrValue(null, AvrcpConstants.ATTRID_PLAY_TIME, item, null));
+ sb.append(" ");
+ sb.append(getAttrValue(null, AvrcpConstants.ATTRID_TRACK_NUM, item, null));
+ sb.append("/");
+ sb.append(getAttrValue(null, AvrcpConstants.ATTRID_NUM_TRACKS, item, null));
+ sb.append(") ");
+ sb.append(getAttrValue(null, AvrcpConstants.ATTRID_GENRE, item, null));
+ return sb.toString();
+ }
+
+ public void dump(StringBuilder sb, @Nullable MediaController mediaController) {
+ ProfileService.println(sb, "AddressedPlayer info:");
+ ProfileService.println(sb, "mLastTrackIdSent: " + mLastTrackIdSent);
+ ProfileService.println(sb, "mNowPlayingList: " + mNowPlayingList.size() + " elements");
+ long currentQueueId = getActiveQueueItemId(mediaController);
+ for (MediaSession.QueueItem item : mNowPlayingList) {
+ long itemId = item.getQueueId();
+ ProfileService.println(sb,
+ (itemId == currentQueueId ? "*" : " ") + displayMediaItem(item));
+ }
+ }
+}
diff --git a/src/com/android/bluetooth/avrcp/Avrcp.java b/src/com/android/bluetooth/avrcp/Avrcp.java
new file mode 100644
index 0000000..b507e67
--- /dev/null
+++ b/src/com/android/bluetooth/avrcp/Avrcp.java
@@ -0,0 +1,3410 @@
+/*
+ * Copyright (C) 2016 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.bluetooth.avrcp;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothAvrcp;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.graphics.Color;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.pm.ResolveInfo;
+import android.content.res.Resources;
+import android.media.AudioManager;
+import android.media.AudioAttributes;
+import android.media.AudioPlaybackConfiguration;
+import android.media.MediaDescription;
+import android.media.MediaMetadata;
+import android.media.session.MediaSession;
+import android.media.session.MediaSessionManager;
+import android.media.session.PlaybackState;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.os.SystemClock;
+import android.os.SystemProperties;
+import android.os.UserManager;
+import android.util.Log;
+import android.view.KeyEvent;
+
+import com.android.bluetooth.btservice.AdapterService;
+import com.android.bluetooth.btservice.AbstractionLayer;
+import com.android.bluetooth.R;
+import com.android.bluetooth.Utils;
+import com.android.bluetooth.btservice.ProfileService;
+
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.NotificationChannel;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import com.android.bluetooth.hfp.HeadsetService;
+
+import com.android.bluetooth.hfp.HeadsetService;
+import com.android.bluetooth.avrcpcontroller.AvrcpControllerService;
+
+/******************************************************************************
+ * support Bluetooth AVRCP profile. support metadata, play status, event
+ * notifications, address player selection and browse feature implementation.
+ ******************************************************************************/
+
+public final class Avrcp {
+ static final boolean DEBUG = true;
+ private static final String TAG = "Avrcp";
+ private static final String ABSOLUTE_VOLUME_BLACKLIST = "absolute_volume_blacklist";
+ private static final String AVRCP_VERSION_PROPERTY = "persist.bluetooth.avrcpversion";
+ private static final String AVRCP_1_4_STRING = "avrcp14";
+ private static final String AVRCP_1_5_STRING = "avrcp15";
+ private static final String AVRCP_1_6_STRING = "avrcp16";
+ private static final String AVRCP_NOTIFICATION_ID = "avrcp_notification";
+
+ private Context mContext;
+ private final AudioManager mAudioManager;
+ private volatile AvrcpMessageHandler mHandler;
+ private Handler mAudioManagerPlaybackHandler;
+ private AudioManagerPlaybackListener mAudioManagerPlaybackCb;
+ private MediaSessionManager mMediaSessionManager;
+ @Nullable private MediaController mMediaController;
+ private MediaControllerListener mMediaControllerCb;
+ private MediaAttributes mMediaAttributes;
+ private long mLastQueueId;
+ private PackageManager mPackageManager;
+ private int mTransportControlFlags;
+ @NonNull private PlaybackState mCurrentPlayState;
+ private int mA2dpState;
+ private boolean mAudioManagerIsPlaying;
+ private int mPlayStatusChangedNT;
+ private byte mReportedPlayStatus;
+ private int mTrackChangedNT;
+ private int mPlayPosChangedNT;
+ private int mAddrPlayerChangedNT;
+ private int mAvailablePlayersChangedNT;
+ private int mReportedPlayerID;
+ private int mNowPlayingListChangedNT;
+ private long mPlaybackIntervalMs;
+ private long mLastReportedPosition;
+ private long mNextPosMs;
+ private long mPrevPosMs;
+ private int mFeatures;
+ private int mRemoteVolume;
+ private int mLastRemoteVolume;
+ private int mInitialRemoteVolume;
+ private NotificationManager mNotificationManager;
+
+ /* Local volume in audio index 0-15 */
+ private int mLocalVolume;
+ private int mLastLocalVolume;
+ private int mAbsVolThreshold;
+ private int mLastPassthroughcmd;
+
+ private boolean mFastforward;
+ private boolean mRewind;
+
+ private String mAddress;
+ private HashMap<Integer, Integer> mVolumeMapping;
+
+ private int mLastDirection;
+ private final int mVolumeStep;
+ private final int mAudioStreamMax;
+ private boolean mVolCmdSetInProgress;
+ private int mAbsVolRetryTimes;
+
+ private static final int NO_PLAYER_ID = 0;
+
+ private int mCurrAddrPlayerID;
+ private int mCurrBrowsePlayerID;
+ private int mLastUsedPlayerID;
+ private AvrcpMediaRsp mAvrcpMediaRsp;
+
+ /* UID counter to be shared across different files. */
+ static short sUIDCounter = AvrcpConstants.DEFAULT_UID_COUNTER;
+
+ /* BTRC features */
+ public static final int BTRC_FEAT_METADATA = 0x01;
+ public static final int BTRC_FEAT_ABSOLUTE_VOLUME = 0x02;
+ public static final int BTRC_FEAT_BROWSE = 0x04;
+ public static final int BTRC_FEAT_AVRC_UI_UPDATE = 0x08;
+
+ /* AVRC response codes, from avrc_defs */
+ private static final int AVRC_RSP_NOT_IMPL = 8;
+ private static final int AVRC_RSP_ACCEPT = 9;
+ private static final int AVRC_RSP_REJ = 10;
+ private static final int AVRC_RSP_IN_TRANS = 11;
+ private static final int AVRC_RSP_IMPL_STBL = 12;
+ private static final int AVRC_RSP_CHANGED = 13;
+ private static final int AVRC_RSP_INTERIM = 15;
+
+ /* AVRC request commands from Native */
+ private static final int MSG_NATIVE_REQ_GET_RC_FEATURES = 1;
+ private static final int MSG_NATIVE_REQ_GET_PLAY_STATUS = 2;
+ private static final int MSG_NATIVE_REQ_GET_ELEM_ATTRS = 3;
+ private static final int MSG_NATIVE_REQ_REGISTER_NOTIFICATION = 4;
+ private static final int MSG_NATIVE_REQ_VOLUME_CHANGE = 5;
+ private static final int MSG_NATIVE_REQ_GET_FOLDER_ITEMS = 6;
+ private static final int MSG_NATIVE_REQ_SET_ADDR_PLAYER = 7;
+ private static final int MSG_NATIVE_REQ_SET_BR_PLAYER = 8;
+ private static final int MSG_NATIVE_REQ_CHANGE_PATH = 9;
+ private static final int MSG_NATIVE_REQ_PLAY_ITEM = 10;
+ private static final int MSG_NATIVE_REQ_GET_ITEM_ATTR = 11;
+ private static final int MSG_NATIVE_REQ_GET_TOTAL_NUM_OF_ITEMS = 12;
+ private static final int MSG_NATIVE_REQ_PASS_THROUGH = 13;
+
+ /* other AVRC messages */
+ private static final int MSG_PLAY_INTERVAL_TIMEOUT = 14;
+ private static final int MSG_SET_ABSOLUTE_VOLUME = 16;
+ private static final int MSG_ABS_VOL_TIMEOUT = 17;
+ private static final int MSG_SET_A2DP_AUDIO_STATE = 18;
+ private static final int MSG_NOW_PLAYING_CHANGED_RSP = 19;
+ private final static int MESSAGE_SET_MEDIA_SESSION = 24;
+
+ private static final int CMD_TIMEOUT_DELAY = 2000;
+ private static final int MAX_ERROR_RETRY_TIMES = 6;
+ private static final int AVRCP_MAX_VOL = 127;
+ private static final int AVRCP_BASE_VOLUME_STEP = 1;
+ private static final int SET_MEDIA_SESSION_DELAY = 300;
+
+ /* Communicates with MediaPlayer to fetch media content */
+ private BrowsedMediaPlayer mBrowsedMediaPlayer;
+
+ /* Addressed player handling */
+ private AddressedMediaPlayer mAddressedMediaPlayer;
+
+ /* List of Media player instances, useful for retrieving MediaPlayerList or MediaPlayerInfo */
+ private SortedMap<Integer, MediaPlayerInfo> mMediaPlayerInfoList;
+ private boolean mAvailablePlayerViewChanged;
+
+ /* List of media players which supports browse */
+ private List<BrowsePlayerInfo> mBrowsePlayerInfoList;
+
+ /* Manage browsed players */
+ private AvrcpBrowseManager mAvrcpBrowseManager;
+
+ /* Broadcast receiver for device connections intent broadcasts */
+ private final BroadcastReceiver mAvrcpReceiver = new AvrcpServiceBroadcastReceiver();
+ private final BroadcastReceiver mBootReceiver = new AvrcpServiceBootReceiver();
+
+ /* Recording passthrough key dispatches */
+ private static final int PASSTHROUGH_LOG_MAX_SIZE = DEBUG ? 50 : 10;
+ private EvictingQueue<MediaKeyLog> mPassthroughLogs; // Passthorugh keys dispatched
+ private List<MediaKeyLog> mPassthroughPending; // Passthrough keys sent not dispatched yet
+ private int mPassthroughDispatched; // Number of keys dispatched
+ private boolean pts_test = false;
+
+ private class MediaKeyLog {
+ private long mTimeSent;
+ private long mTimeProcessed;
+ private String mPackage;
+ private KeyEvent mEvent;
+
+ MediaKeyLog(long time, KeyEvent event) {
+ mEvent = event;
+ mTimeSent = time;
+ }
+
+ public boolean addDispatch(long time, KeyEvent event, String packageName) {
+ if (mPackage != null) {
+ return false;
+ }
+ if (event.getAction() != mEvent.getAction()) {
+ return false;
+ }
+ if (event.getKeyCode() != mEvent.getKeyCode()) {
+ return false;
+ }
+ mPackage = packageName;
+ mTimeProcessed = time;
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append(android.text.format.DateFormat.format("MM-dd HH:mm:ss", mTimeSent));
+ sb.append(" " + mEvent.toString());
+ if (mPackage == null) {
+ sb.append(" (undispatched)");
+ } else {
+ sb.append(" to " + mPackage);
+ sb.append(" in " + (mTimeProcessed - mTimeSent) + "ms");
+ }
+ return sb.toString();
+ }
+ }
+
+ static {
+ classInitNative();
+ }
+
+ private Avrcp(Context context) {
+ mMediaAttributes = new MediaAttributes(null);
+ mLastQueueId = MediaSession.QueueItem.UNKNOWN_ID;
+ mCurrentPlayState =
+ new PlaybackState.Builder().setState(PlaybackState.STATE_NONE, -1L, 0.0f).build();
+ mReportedPlayStatus = PLAYSTATUS_ERROR;
+ mA2dpState = BluetoothA2dp.STATE_NOT_PLAYING;
+ mAudioManagerIsPlaying = false;
+ mPlayStatusChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ mTrackChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ mPlayPosChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ mAddrPlayerChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ mAvailablePlayersChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ mNowPlayingListChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ mPlaybackIntervalMs = 0L;
+ mLastReportedPosition = -1;
+ mNextPosMs = -1;
+ mPrevPosMs = -1;
+ mFeatures = 0;
+ mRemoteVolume = -1;
+ mInitialRemoteVolume = -1;
+ mLastRemoteVolume = -1;
+ mLastDirection = 0;
+ mVolCmdSetInProgress = false;
+ mAbsVolRetryTimes = 0;
+ mFastforward = false;
+ mRewind = false;
+ mLastPassthroughcmd = KeyEvent.KEYCODE_UNKNOWN;
+ mLocalVolume = -1;
+ mLastLocalVolume = -1;
+ mAbsVolThreshold = 0;
+ mVolumeMapping = new HashMap<Integer, Integer>();
+ mCurrAddrPlayerID = NO_PLAYER_ID;
+ mReportedPlayerID = mCurrAddrPlayerID;
+ mCurrBrowsePlayerID = 0;
+ mContext = context;
+ mLastUsedPlayerID = 0;
+ mAddressedMediaPlayer = null;
+ initNative();
+
+ mMediaSessionManager =
+ (MediaSessionManager) context.getSystemService(Context.MEDIA_SESSION_SERVICE);
+ mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+ mAudioStreamMax = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
+ mVolumeStep = Math.max(AVRCP_BASE_VOLUME_STEP, AVRCP_MAX_VOL / mAudioStreamMax);
+
+ Resources resources = context.getResources();
+ if (resources != null) {
+ mAbsVolThreshold =
+ resources.getInteger(R.integer.a2dp_absolute_volume_initial_threshold);
+
+ // Update the threshold if the thresholdPercent is valid
+ int thresholdPercent =
+ resources.getInteger(R.integer.a2dp_absolute_volume_initial_threshold_percent);
+ if (thresholdPercent >= 0 && thresholdPercent <= 100) {
+ mAbsVolThreshold = (thresholdPercent * mAudioStreamMax) / 100;
+ }
+ }
+
+ // Register for package removal intent broadcasts for media button receiver persistence
+ IntentFilter pkgFilter = new IntentFilter();
+ pkgFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
+ pkgFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
+ pkgFilter.addAction(Intent.ACTION_PACKAGE_CHANGED);
+ pkgFilter.addAction(Intent.ACTION_PACKAGE_DATA_CLEARED);
+ pkgFilter.addDataScheme("package");
+ context.registerReceiver(mAvrcpReceiver, pkgFilter);
+
+ IntentFilter bootFilter = new IntentFilter();
+ bootFilter.addAction(Intent.ACTION_USER_UNLOCKED);
+ context.registerReceiver(mBootReceiver, bootFilter);
+ pts_test = SystemProperties.getBoolean("vendor.bluetooth.avrcpct-passthrough.pts", false);
+
+
+ // create Notification channel.
+ mNotificationManager = (NotificationManager)
+ mContext.getSystemService(Context.NOTIFICATION_SERVICE);
+ NotificationChannel mChannel = new NotificationChannel(AVRCP_NOTIFICATION_ID,
+ mContext.getString(R.string.avrcp_notification_name),
+ NotificationManager.IMPORTANCE_DEFAULT);
+ mChannel.setDescription(mContext.getString(R.string.bluetooth_advanced_feat_description));
+ mChannel.enableLights(true);
+ mChannel.enableVibration(false);
+ mChannel.setSound(Uri.EMPTY, Notification.AUDIO_ATTRIBUTES_DEFAULT);
+ mChannel.setLightColor(Color.GREEN);
+ mNotificationManager.createNotificationChannel(mChannel);
+
+ }
+
+ private synchronized void start() {
+ HandlerThread thread = new HandlerThread("BluetoothAvrcpHandler");
+ thread.start();
+ Looper looper = thread.getLooper();
+ mHandler = new AvrcpMessageHandler(looper);
+ mAudioManagerPlaybackHandler = new Handler(looper);
+ mAudioManagerPlaybackCb = new AudioManagerPlaybackListener();
+ mMediaControllerCb = new MediaControllerListener();
+ mAvrcpMediaRsp = new AvrcpMediaRsp();
+ mMediaPlayerInfoList = new TreeMap<Integer, MediaPlayerInfo>();
+ mAvailablePlayerViewChanged = false;
+ mBrowsePlayerInfoList = Collections.synchronizedList(new ArrayList<BrowsePlayerInfo>());
+ mPassthroughDispatched = 0;
+ mPassthroughLogs = new EvictingQueue<MediaKeyLog>(PASSTHROUGH_LOG_MAX_SIZE);
+ mPassthroughPending = Collections.synchronizedList(new ArrayList<MediaKeyLog>());
+ if (mMediaSessionManager != null) {
+ mMediaSessionManager.addOnActiveSessionsChangedListener(mActiveSessionListener, null,
+ mHandler);
+ mMediaSessionManager.setCallback(mButtonDispatchCallback, null);
+ }
+ mPackageManager = mContext.getApplicationContext().getPackageManager();
+
+ /* create object to communicate with addressed player */
+ mAddressedMediaPlayer = new AddressedMediaPlayer(mAvrcpMediaRsp);
+
+ /* initialize BrowseMananger which manages Browse commands and response */
+ mAvrcpBrowseManager = new AvrcpBrowseManager(mContext, mAvrcpMediaRsp);
+
+ initMediaPlayersList();
+
+ UserManager manager = UserManager.get(mContext);
+ if (manager == null || manager.isUserUnlocked()) {
+ if (DEBUG) {
+ Log.d(TAG, "User already unlocked, initializing player lists");
+ }
+ // initialize browsable player list and build media player list
+ buildBrowsablePlayerList();
+ }
+
+ mAudioManager.registerAudioPlaybackCallback(mAudioManagerPlaybackCb,
+ mAudioManagerPlaybackHandler);
+ }
+
+ public static Avrcp make(Context context) {
+ if (DEBUG) {
+ Log.v(TAG, "make");
+ }
+ Avrcp ar = new Avrcp(context);
+ ar.start();
+ return ar;
+ }
+
+ public synchronized void doQuit() {
+ if (DEBUG) {
+ Log.d(TAG, "doQuit");
+ }
+ if (mAudioManager != null) {
+ mAudioManager.unregisterAudioPlaybackCallback(mAudioManagerPlaybackCb);
+ }
+ if (mMediaController != null) {
+ mMediaController.unregisterCallback(mMediaControllerCb);
+ }
+ if (mMediaSessionManager != null) {
+ mMediaSessionManager.setCallback(null, null);
+ mMediaSessionManager.removeOnActiveSessionsChangedListener(mActiveSessionListener);
+ }
+
+ mAudioManagerPlaybackHandler.removeCallbacksAndMessages(null);
+ mHandler.removeCallbacksAndMessages(null);
+ Looper looper = mHandler.getLooper();
+ mHandler = null;
+ if (looper != null) {
+ looper.quitSafely();
+ }
+ mAudioManagerPlaybackHandler = null;
+ mContext.unregisterReceiver(mAvrcpReceiver);
+ mContext.unregisterReceiver(mBootReceiver);
+
+ mAddressedMediaPlayer.cleanup();
+ mAvrcpBrowseManager.cleanup();
+
+ if (mNotificationManager != null )
+ mNotificationManager.deleteNotificationChannel(AVRCP_NOTIFICATION_ID);
+ }
+
+ public void cleanup() {
+ if (DEBUG) {
+ Log.d(TAG, "cleanup");
+ }
+ cleanupNative();
+ if (mVolumeMapping != null) {
+ mVolumeMapping.clear();
+ }
+ }
+
+ private class AudioManagerPlaybackListener extends AudioManager.AudioPlaybackCallback {
+ @Override
+ public void onPlaybackConfigChanged(List<AudioPlaybackConfiguration> configs) {
+ super.onPlaybackConfigChanged(configs);
+ boolean isPlaying = false;
+ for (AudioPlaybackConfiguration config : configs) {
+ if (DEBUG) {
+ Log.d(TAG, "AudioManager Player: "
+ + AudioPlaybackConfiguration.toLogFriendlyString(config));
+ }
+ if (config.getPlayerState() == AudioPlaybackConfiguration.PLAYER_STATE_STARTED) {
+ isPlaying = true;
+ break;
+ }
+ }
+ if (DEBUG) {
+ Log.d(TAG, "AudioManager isPlaying: " + isPlaying);
+ }
+ if (mAudioManagerIsPlaying != isPlaying) {
+ mAudioManagerIsPlaying = isPlaying;
+ updateCurrentMediaState();
+ }
+ }
+ }
+
+ private class MediaControllerListener extends MediaController.Callback {
+ @Override
+ public void onMetadataChanged(MediaMetadata metadata) {
+ if (DEBUG) {
+ Log.v(TAG, "onMetadataChanged");
+ }
+ updateCurrentMediaState();
+ }
+
+ @Override
+ public synchronized void onPlaybackStateChanged(PlaybackState state) {
+ if (DEBUG) {
+ Log.v(TAG, "onPlaybackStateChanged: state " + state.toString());
+ }
+
+ updateCurrentMediaState();
+ }
+
+ @Override
+ public void onSessionDestroyed() {
+ Log.v(TAG, "MediaController session destroyed");
+ synchronized (Avrcp.this) {
+ if (mMediaController != null) {
+ removeMediaController(mMediaController.getWrappedInstance());
+ }
+ }
+ }
+
+ @Override
+ public void onQueueChanged(List<MediaSession.QueueItem> queue) {
+ if (queue == null) {
+ Log.v(TAG, "onQueueChanged: received null queue");
+ return;
+ }
+
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "onQueueChanged: mHandler is already null");
+ return;
+ }
+
+ Log.v(TAG, "onQueueChanged: NowPlaying list changed, Queue Size = "
+ + queue.size());
+ handler.sendEmptyMessage(MSG_NOW_PLAYING_CHANGED_RSP);
+ }
+ }
+
+ /** Handles Avrcp messages. */
+ private final class AvrcpMessageHandler extends Handler {
+ private AvrcpMessageHandler(Looper looper) {
+ super(looper);
+ }
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case MSG_NATIVE_REQ_GET_RC_FEATURES: {
+ String address = (String) msg.obj;
+ mFeatures = msg.arg1;
+ mFeatures = modifyRcFeatureFromBlacklist(mFeatures, address);
+ if (DEBUG) {
+ Log.v(TAG,
+ "MSG_NATIVE_REQ_GET_RC_FEATURES: address=" + address + ", features="
+ + msg.arg1 + ", mFeatures=" + mFeatures);
+ }
+ mAudioManager.avrcpSupportsAbsoluteVolume(address, isAbsoluteVolumeSupported());
+ mLastLocalVolume = -1;
+ mRemoteVolume = -1;
+ mLocalVolume = -1;
+ mInitialRemoteVolume = -1;
+ mLastPassthroughcmd = KeyEvent.KEYCODE_UNKNOWN;
+ mAddress = address;
+ if (mVolumeMapping != null) {
+ mVolumeMapping.clear();
+ }
+
+ Log.d(TAG, "avrcpct-passthrough pts_test = " + pts_test);
+ if (pts_test) {
+ Log.v(TAG,"fake BTRC_FEAT_ABSOLUTE_VOL remote feat support for pts test");
+ mFeatures = mFeatures | BTRC_FEAT_ABSOLUTE_VOLUME;
+ }
+
+ if ((mFeatures & BTRC_FEAT_AVRC_UI_UPDATE) != 0) {
+ int NOTIFICATION_ID = android.R.drawable.stat_sys_data_bluetooth;
+ Notification notification = new Notification.Builder(mContext, AVRCP_NOTIFICATION_ID)
+ .setContentTitle(mContext.getString(R.string.bluetooth_rc_feat_title))
+ .setContentText(mContext.getString(R.string.bluetooth_rc_feat_content))
+ .setSubText(mContext.getString(R.string.bluetooth_rc_feat_subtext))
+ .setSmallIcon(android.R.drawable.stat_sys_data_bluetooth)
+ .setChannelId(AVRCP_NOTIFICATION_ID)
+ .build();
+
+ if (mNotificationManager != null )
+ mNotificationManager.notify(NOTIFICATION_ID, notification);
+ else
+ Log.e(TAG,"mNotificationManager is null");
+ Log.v(TAG," update notification manager on remote repair request");
+ }
+ break;
+ }
+
+ case MSG_NATIVE_REQ_GET_PLAY_STATUS: {
+ byte[] address = (byte[]) msg.obj;
+ int btstate = getBluetoothPlayState(mCurrentPlayState);
+ int length = (int) mMediaAttributes.getLength();
+ int position = (int) getPlayPosition();
+ if (DEBUG) {
+ Log.v(TAG,
+ "MSG_NATIVE_REQ_GET_PLAY_STATUS, responding with state " + btstate
+ + " len " + length + " pos " + position);
+ }
+ getPlayStatusRspNative(address, btstate, length, position);
+ break;
+ }
+
+ case MSG_NATIVE_REQ_GET_ELEM_ATTRS: {
+ String[] textArray;
+ AvrcpCmd.ElementAttrCmd elem = (AvrcpCmd.ElementAttrCmd) msg.obj;
+ byte numAttr = elem.mNumAttr;
+ int[] attrIds = elem.mAttrIDs;
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_GET_ELEM_ATTRS:numAttr=" + numAttr);
+ }
+ textArray = new String[numAttr];
+ StringBuilder responseDebug = new StringBuilder();
+ responseDebug.append("getElementAttr response: ");
+ for (int i = 0; i < numAttr; ++i) {
+ textArray[i] = mMediaAttributes.getString(attrIds[i]);
+ responseDebug.append("[" + attrIds[i] + "=");
+ if (attrIds[i] == AvrcpConstants.ATTRID_TITLE
+ || attrIds[i] == AvrcpConstants.ATTRID_ARTIST
+ || attrIds[i] == AvrcpConstants.ATTRID_ALBUM) {
+ responseDebug.append(Utils.ellipsize(textArray[i]) + "] ");
+ } else {
+ responseDebug.append(textArray[i] + "] ");
+ }
+ }
+ Log.v(TAG, responseDebug.toString());
+ byte[] bdaddr = elem.mAddress;
+ getElementAttrRspNative(bdaddr, numAttr, attrIds, textArray);
+ break;
+ }
+
+ case MSG_NATIVE_REQ_REGISTER_NOTIFICATION:
+ if (DEBUG) {
+ Log.v(TAG,
+ "MSG_NATIVE_REQ_REGISTER_NOTIFICATION:event=" + msg.arg1 + " param="
+ + msg.arg2);
+ }
+ processRegisterNotification((byte[]) msg.obj, msg.arg1, msg.arg2);
+ break;
+
+ case MSG_NOW_PLAYING_CHANGED_RSP:
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NOW_PLAYING_CHANGED_RSP");
+ }
+ removeMessages(MSG_NOW_PLAYING_CHANGED_RSP);
+ updateCurrentMediaState();
+ break;
+
+ case MSG_PLAY_INTERVAL_TIMEOUT:
+ sendPlayPosNotificationRsp(false);
+ break;
+
+ case MSG_NATIVE_REQ_VOLUME_CHANGE:
+ if (!isAbsoluteVolumeSupported()) {
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_VOLUME_CHANGE ignored, not supported");
+ }
+ break;
+ }
+ byte absVol = (byte) ((byte) msg.arg1 & 0x7f); // discard MSB as it is RFD
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_VOLUME_CHANGE: volume=" + absVol + " ctype="
+ + msg.arg2);
+ }
+
+ if (msg.arg2 == AVRC_RSP_ACCEPT || msg.arg2 == AVRC_RSP_REJ) {
+ if (!mVolCmdSetInProgress) {
+ Log.e(TAG, "Unsolicited response, ignored");
+ break;
+ }
+ removeMessages(MSG_ABS_VOL_TIMEOUT);
+
+ mVolCmdSetInProgress = false;
+ mAbsVolRetryTimes = 0;
+ }
+
+ // convert remote volume to local volume
+ int volIndex = convertToAudioStreamVolume(absVol);
+ boolean isShowUI = true;
+ if (mInitialRemoteVolume == -1) {
+ //Don't show media UI when device connected.
+ isShowUI = false;
+ mInitialRemoteVolume = absVol;
+ if (mAbsVolThreshold > 0 && mAbsVolThreshold < mAudioStreamMax
+ && volIndex > mAbsVolThreshold) {
+ if (DEBUG) {
+ Log.v(TAG, "remote inital volume too high " + volIndex + ">"
+ + mAbsVolThreshold);
+ }
+ Message msg1 = this.obtainMessage(MSG_SET_ABSOLUTE_VOLUME,
+ mAbsVolThreshold, 0);
+ this.sendMessage(msg1);
+ mRemoteVolume = absVol;
+ mLocalVolume = volIndex;
+ break;
+ }
+ }
+
+ if (mLocalVolume != volIndex && (msg.arg2 == AVRC_RSP_ACCEPT
+ || msg.arg2 == AVRC_RSP_CHANGED || msg.arg2 == AVRC_RSP_INTERIM)) {
+ if (msg.arg2 == AVRC_RSP_ACCEPT){
+ Log.d(TAG, "Don't show media UI when slide volume bar");
+ isShowUI = false;
+ }
+ /* If the volume has successfully changed */
+ mLocalVolume = volIndex;
+ if (mLastLocalVolume != -1 && msg.arg2 == AVRC_RSP_ACCEPT) {
+ if (mLastLocalVolume != volIndex) {
+ /* remote volume changed more than requested due to
+ * local and remote has different volume steps */
+ if (DEBUG) {
+ Log.d(TAG,
+ "Remote returned volume does not match desired volume "
+ + mLastLocalVolume + " vs " + volIndex);
+ }
+ mLastLocalVolume = mLocalVolume;
+ }
+ }
+
+ notifyVolumeChanged(mLocalVolume, isShowUI);
+ mRemoteVolume = absVol;
+ long pecentVolChanged = ((long) absVol * 100) / 0x7f;
+ Log.e(TAG, "percent volume changed: " + pecentVolChanged + "%");
+ } else if (msg.arg2 == AVRC_RSP_REJ) {
+ Log.e(TAG, "setAbsoluteVolume call rejected");
+ }
+ break;
+
+ case MSG_SET_ABSOLUTE_VOLUME:
+ if (!isAbsoluteVolumeSupported()) {
+ if (DEBUG) {
+ Log.v(TAG, "ignore MSG_SET_ABSOLUTE_VOLUME");
+ }
+ break;
+ }
+
+ if (DEBUG) {
+ Log.v(TAG, "MSG_SET_ABSOLUTE_VOLUME");
+ }
+
+ if (mVolCmdSetInProgress) {
+ if (DEBUG) {
+ Log.w(TAG, "There is already a volume command in progress.");
+ }
+ break;
+ }
+
+ // Remote device didn't set initial volume. Let's black list it
+ if (mInitialRemoteVolume == -1) {
+ if (DEBUG) {
+ Log.d(TAG, "remote " + mAddress
+ + " never tell us initial volume, black list it.");
+ }
+ blackListCurrentDevice("MSG_SET_ABSOLUTE_VOLUME");
+ break;
+ }
+
+ int avrcpVolume = convertToAvrcpVolume(msg.arg1);
+ avrcpVolume = Math.min(AVRCP_MAX_VOL, Math.max(0, avrcpVolume));
+ if (DEBUG) {
+ Log.d(TAG, "Setting volume to " + msg.arg1 + "-" + avrcpVolume);
+ }
+ if (setVolumeNative(avrcpVolume)) {
+ sendMessageDelayed(obtainMessage(MSG_ABS_VOL_TIMEOUT), CMD_TIMEOUT_DELAY);
+ mVolCmdSetInProgress = true;
+ mLastRemoteVolume = avrcpVolume;
+ mLastLocalVolume = msg.arg1;
+ } else {
+ if (DEBUG) {
+ Log.d(TAG, "setVolumeNative failed");
+ }
+ }
+ break;
+
+ case MSG_ABS_VOL_TIMEOUT:
+ if (DEBUG) {
+ Log.v(TAG, "MSG_ABS_VOL_TIMEOUT: Volume change cmd timed out.");
+ }
+ mVolCmdSetInProgress = false;
+ if (mAbsVolRetryTimes >= MAX_ERROR_RETRY_TIMES) {
+ mAbsVolRetryTimes = 0;
+ /* too many volume change failures, black list the device */
+ blackListCurrentDevice("MSG_ABS_VOL_TIMEOUT");
+ } else {
+ mAbsVolRetryTimes += 1;
+ if (setVolumeNative(mLastRemoteVolume)) {
+ sendMessageDelayed(obtainMessage(MSG_ABS_VOL_TIMEOUT),
+ CMD_TIMEOUT_DELAY);
+ mVolCmdSetInProgress = true;
+ }
+ }
+ break;
+
+ case MSG_SET_A2DP_AUDIO_STATE:
+ if (DEBUG) {
+ Log.v(TAG, "MSG_SET_A2DP_AUDIO_STATE:" + msg.arg1);
+ }
+ mA2dpState = msg.arg1;
+ updateCurrentMediaState();
+ break;
+
+ case MSG_NATIVE_REQ_GET_FOLDER_ITEMS: {
+ AvrcpCmd.FolderItemsCmd folderObj = (AvrcpCmd.FolderItemsCmd) msg.obj;
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_GET_FOLDER_ITEMS " + folderObj);
+ }
+ switch (folderObj.mScope) {
+ case AvrcpConstants.BTRC_SCOPE_PLAYER_LIST:
+ handleMediaPlayerListRsp(folderObj);
+ break;
+ case AvrcpConstants.BTRC_SCOPE_FILE_SYSTEM:
+ case AvrcpConstants.BTRC_SCOPE_NOW_PLAYING:
+ handleGetFolderItemBrowseResponse(folderObj, folderObj.mAddress);
+ break;
+ default:
+ Log.e(TAG, "unknown scope for getfolderitems. scope = "
+ + folderObj.mScope);
+ getFolderItemsRspNative(folderObj.mAddress,
+ AvrcpConstants.RSP_INV_SCOPE, (short) 0, (byte) 0, 0, null,
+ null, null, null, null, null, null, null);
+ }
+ break;
+ }
+
+ case MSG_NATIVE_REQ_SET_ADDR_PLAYER:
+ // object is bdaddr, argument 1 is the selected player id
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_SET_ADDR_PLAYER id=" + msg.arg1);
+ }
+ setAddressedPlayer((byte[]) msg.obj, msg.arg1);
+ break;
+
+ case MSG_NATIVE_REQ_GET_ITEM_ATTR:
+ // msg object contains the item attribute object
+ AvrcpCmd.ItemAttrCmd cmd = (AvrcpCmd.ItemAttrCmd) msg.obj;
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_GET_ITEM_ATTR " + cmd);
+ }
+ handleGetItemAttr(cmd);
+ break;
+
+ case MSG_NATIVE_REQ_SET_BR_PLAYER:
+ // argument 1 is the selected player id
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_SET_BR_PLAYER id=" + msg.arg1);
+ }
+ setBrowsedPlayer((byte[]) msg.obj, msg.arg1);
+ break;
+
+ case MSG_NATIVE_REQ_CHANGE_PATH: {
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_CHANGE_PATH");
+ }
+ Bundle data = msg.getData();
+ byte[] bdaddr = data.getByteArray("BdAddress");
+ byte[] folderUid = data.getByteArray("folderUid");
+ byte direction = data.getByte("direction");
+ if (mAvrcpBrowseManager.getBrowsedMediaPlayer(bdaddr) != null) {
+ mAvrcpBrowseManager.getBrowsedMediaPlayer(bdaddr)
+ .changePath(folderUid, direction);
+ } else {
+ Log.e(TAG, "Remote requesting change path before setbrowsedplayer");
+ changePathRspNative(bdaddr, AvrcpConstants.RSP_BAD_CMD, 0);
+ }
+ break;
+ }
+
+ case MSG_NATIVE_REQ_PLAY_ITEM: {
+ Bundle data = msg.getData();
+ byte[] bdaddr = data.getByteArray("BdAddress");
+ byte[] uid = data.getByteArray("uid");
+ byte scope = data.getByte("scope");
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_PLAY_ITEM scope=" + scope + " id="
+ + Utils.byteArrayToString(uid));
+ }
+ handlePlayItemResponse(bdaddr, uid, scope);
+ break;
+ }
+
+ case MSG_NATIVE_REQ_GET_TOTAL_NUM_OF_ITEMS:
+ if (DEBUG) {
+ Log.v(TAG, "MSG_NATIVE_REQ_GET_TOTAL_NUM_OF_ITEMS scope=" + msg.arg1);
+ }
+ // argument 1 is scope, object is bdaddr
+ handleGetTotalNumOfItemsResponse((byte[]) msg.obj, (byte) msg.arg1);
+ break;
+
+ case MSG_NATIVE_REQ_PASS_THROUGH:
+ if (DEBUG) {
+ Log.v(TAG,
+ "MSG_NATIVE_REQ_PASS_THROUGH: id=" + msg.arg1 + " st=" + msg.arg2);
+ }
+ // argument 1 is id, argument 2 is keyState
+ handlePassthroughCmd(msg.arg1, msg.arg2);
+ break;
+
+ case MESSAGE_SET_MEDIA_SESSION:
+ android.media.session.MediaController mMediaController =
+ (android.media.session.MediaController)msg.obj;
+ setActiveMediaSession(mMediaController);
+ break;
+
+ default:
+ Log.e(TAG, "unknown message! msg.what=" + msg.what);
+ break;
+ }
+ }
+ }
+
+ private PlaybackState updatePlaybackState() {
+ PlaybackState newState = new PlaybackState.Builder().setState(PlaybackState.STATE_NONE,
+ PlaybackState.PLAYBACK_POSITION_UNKNOWN, 0.0f).build();
+ synchronized (this) {
+ PlaybackState controllerState = null;
+ if (mMediaController != null) {
+ controllerState = mMediaController.getPlaybackState();
+ }
+
+ if (controllerState != null) {
+ newState = controllerState;
+ }
+ // Use the AudioManager to update the playback state.
+ // NOTE: We cannot use the
+ // (mA2dpState == BluetoothA2dp.STATE_PLAYING)
+ // check, because after Pause, the A2DP state remains in
+ // STATE_PLAYING for 3 more seconds.
+ // As a result of that, if we pause the music, on carkits the
+ // Play status indicator will continue to display "Playing"
+ // for 3 more seconds which can be confusing.
+ if ((mAudioManagerIsPlaying && newState.getState() != PlaybackState.STATE_PLAYING) || (
+ controllerState == null && mAudioManager != null
+ && mAudioManager.isMusicActive())) {
+ // Use AudioManager playback state if we don't have the state
+ // from MediaControlller
+ PlaybackState.Builder builder = new PlaybackState.Builder();
+ if (mAudioManagerIsPlaying) {
+ builder.setState(PlaybackState.STATE_PLAYING,
+ PlaybackState.PLAYBACK_POSITION_UNKNOWN, 1.0f);
+ } else {
+ builder.setState(PlaybackState.STATE_PAUSED,
+ PlaybackState.PLAYBACK_POSITION_UNKNOWN, 0.0f);
+ }
+ newState = builder.build();
+ }
+ }
+
+ byte newPlayStatus = getBluetoothPlayState(newState);
+
+ /* update play status in global media player list */
+ MediaPlayerInfo player = getAddressedPlayerInfo();
+ if (player != null) {
+ player.setPlayStatus(newPlayStatus);
+ }
+
+ if (DEBUG) {
+ Log.v(TAG, "updatePlaybackState (" + mPlayStatusChangedNT + "): " + mReportedPlayStatus
+ + "➡" + newPlayStatus + "(" + newState + ")");
+ }
+
+ if (newState != null) {
+ mCurrentPlayState = newState;
+ }
+
+ return mCurrentPlayState;
+ }
+
+ private void sendPlaybackStatus(int playStatusChangedNT, byte playbackState) {
+ registerNotificationRspPlayStatusNative(playStatusChangedNT, playbackState);
+ mPlayStatusChangedNT = playStatusChangedNT;
+ mReportedPlayStatus = playbackState;
+ }
+
+ private void updateTransportControls(int transportControlFlags) {
+ mTransportControlFlags = transportControlFlags;
+ }
+
+ class MediaAttributes {
+ private boolean mExists;
+ private String mTitle;
+ private String mArtistName;
+ private String mAlbumName;
+ private String mMediaNumber;
+ private String mMediaTotalNumber;
+ private String mGenre;
+ private long mPlayingTimeMs;
+ private String coverArt;
+
+ private static final int ATTR_TITLE = 1;
+ private static final int ATTR_ARTIST_NAME = 2;
+ private static final int ATTR_ALBUM_NAME = 3;
+ private static final int ATTR_MEDIA_NUMBER = 4;
+ private static final int ATTR_MEDIA_TOTAL_NUMBER = 5;
+ private static final int ATTR_GENRE = 6;
+ private static final int ATTR_PLAYING_TIME_MS = 7;
+ private static final int ATTR_COVER_ART = 8;
+
+
+ MediaAttributes(MediaMetadata data) {
+ mExists = data != null;
+ if (!mExists) {
+ return;
+ }
+
+ String CurrentPackageName = (mMediaController != null) ?
+ mMediaController.getPackageName():null;
+ mArtistName = stringOrBlank(data.getString(MediaMetadata.METADATA_KEY_ARTIST));
+ mAlbumName = stringOrBlank(data.getString(MediaMetadata.METADATA_KEY_ALBUM));
+ if (CurrentPackageName != null && !(CurrentPackageName.equals("com.android.music"))) {
+ mMediaNumber =
+ longStringOrBlank((data.getLong(MediaMetadata.METADATA_KEY_TRACK_NUMBER)));
+ } else {
+ /* playlist starts with 0 for default player*/
+ mMediaNumber =
+ longStringOrBlank((data.getLong(MediaMetadata.METADATA_KEY_TRACK_NUMBER) + 1L));
+ }
+ mMediaTotalNumber =
+ longStringOrBlank(data.getLong(MediaMetadata.METADATA_KEY_NUM_TRACKS));
+ mGenre = stringOrBlank(data.getString(MediaMetadata.METADATA_KEY_GENRE));
+ mPlayingTimeMs = data.getLong(MediaMetadata.METADATA_KEY_DURATION);
+ coverArt = stringOrBlank(null);
+
+ // Try harder for the title.
+ mTitle = data.getString(MediaMetadata.METADATA_KEY_TITLE);
+
+ if (mTitle == null) {
+ MediaDescription desc = data.getDescription();
+ if (desc != null) {
+ CharSequence val = desc.getDescription();
+ if (val != null) {
+ mTitle = val.toString();
+ }
+ }
+ }
+
+ if (mTitle != null && CurrentPackageName != null &&
+ CurrentPackageName.equals("com.tencent.qqmusic")) {
+ mTitle = mTitle.trim();
+ }
+
+ if (mTitle == null) {
+ mTitle = new String();
+ }
+ }
+
+ public long getLength() {
+ if (!mExists) {
+ return 0L;
+ }
+ return mPlayingTimeMs;
+ }
+
+ public boolean equals(MediaAttributes other) {
+ if (other == null) {
+ return false;
+ }
+
+ if (mExists != other.mExists) {
+ return false;
+ }
+
+ if (!mExists) {
+ return true;
+ }
+
+ return (mTitle.equals(other.mTitle)) && (mArtistName.equals(other.mArtistName))
+ && (mAlbumName.equals(other.mAlbumName)) && (mMediaNumber.equals(
+ other.mMediaNumber)) && (mMediaTotalNumber.equals(other.mMediaTotalNumber))
+ && (mGenre.equals(other.mGenre)) && (mPlayingTimeMs == other.mPlayingTimeMs)
+ && (coverArt.equals(other.coverArt));
+ }
+
+ public String getString(int attrId) {
+ if (!mExists) {
+ return new String();
+ }
+
+ switch (attrId) {
+ case ATTR_TITLE:
+ return mTitle;
+ case ATTR_ARTIST_NAME:
+ return mArtistName;
+ case ATTR_ALBUM_NAME:
+ return mAlbumName;
+ case ATTR_MEDIA_NUMBER:
+ return mMediaNumber;
+ case ATTR_MEDIA_TOTAL_NUMBER:
+ return mMediaTotalNumber;
+ case ATTR_GENRE:
+ return mGenre;
+ case ATTR_PLAYING_TIME_MS:
+ return Long.toString(mPlayingTimeMs);
+ case ATTR_COVER_ART:
+ return stringOrBlank(null);
+ default:
+ return new String();
+ }
+ }
+
+ private String stringOrBlank(String s) {
+ return s == null ? new String() : s;
+ }
+
+ private String longStringOrBlank(Long s) {
+ return s == null ? new String() : s.toString();
+ }
+
+ @Override
+ public String toString() {
+ if (!mExists) {
+ return "[MediaAttributes: none]";
+ }
+
+ return "[MediaAttributes: " + mTitle + " - " + mAlbumName + " by " + mArtistName + " ("
+ + mPlayingTimeMs + " " + mMediaNumber + "/" + mMediaTotalNumber + ") " + mGenre
+ + "- " + coverArt + "]";
+ }
+
+ public String toRedactedString() {
+ if (!mExists) {
+ return "[MediaAttributes: none]";
+ }
+
+ return "[MediaAttributes: " + Utils.ellipsize(mTitle) + " - " + Utils.ellipsize(
+ mAlbumName) + " by " + Utils.ellipsize(mArtistName) + " (" + mPlayingTimeMs
+ + " " + mMediaNumber + "/" + mMediaTotalNumber + ") " + mGenre + "]";
+ }
+ }
+
+ private void updateCurrentMediaState() {
+ // Only do player updates when we aren't registering for track changes.
+ MediaAttributes currentAttributes;
+ PlaybackState newState = updatePlaybackState();
+
+ synchronized (this) {
+ if (mMediaController == null) {
+ currentAttributes = new MediaAttributes(null);
+ } else {
+ currentAttributes = new MediaAttributes(mMediaController.getMetadata());
+ }
+ }
+
+ byte newPlayStatus = getBluetoothPlayState(newState);
+
+ if (newState != null && newState.getState() != PlaybackState.STATE_BUFFERING
+ && newState.getState() != PlaybackState.STATE_NONE) {
+ long newQueueId = MediaSession.QueueItem.UNKNOWN_ID;
+ if (newState != null) {
+ newQueueId = newState.getActiveQueueItemId();
+ }
+ if (DEBUG) {
+ Log.v(TAG,
+ "Media update: id " + mLastQueueId + "➡" + newQueueId + "? " + currentAttributes
+ .toRedactedString() + " : " + mMediaAttributes.toRedactedString());
+ }
+
+ if (mAvailablePlayerViewChanged) {
+ Log.v(TAG, "Sending response for available playerchanged:");
+ if (mAvailablePlayersChangedNT == AvrcpConstants.NOTIFICATION_TYPE_INTERIM) {
+ registerNotificationRspAvalPlayerChangedNative(
+ AvrcpConstants.NOTIFICATION_TYPE_CHANGED);
+ mAvailablePlayersChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ }
+ mAvailablePlayerViewChanged = false;
+ return;
+ }
+
+ if (mReportedPlayerID != mCurrAddrPlayerID) {
+ if (mAvailablePlayersChangedNT == AvrcpConstants.NOTIFICATION_TYPE_INTERIM) {
+ registerNotificationRspAvalPlayerChangedNative(
+ AvrcpConstants.NOTIFICATION_TYPE_CHANGED);
+ mAvailablePlayersChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ }
+ if (mAddrPlayerChangedNT == AvrcpConstants.NOTIFICATION_TYPE_INTERIM) {
+ registerNotificationRspAddrPlayerChangedNative(
+ AvrcpConstants.NOTIFICATION_TYPE_CHANGED,
+ mCurrAddrPlayerID, sUIDCounter);
+ }
+
+ mAvailablePlayerViewChanged = false;
+ mAddrPlayerChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ mReportedPlayerID = mCurrAddrPlayerID;
+
+ // Update the now playing list without sending the notification
+ mNowPlayingListChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ mAddressedMediaPlayer.updateNowPlayingList(mMediaController);
+ mNowPlayingListChangedNT = AvrcpConstants.NOTIFICATION_TYPE_INTERIM;
+ }
+
+ // Dont send now playing list changed if the player doesn't support browsing
+ MediaPlayerInfo info = getAddressedPlayerInfo();
+ if (info != null && info.isBrowseSupported()) {
+ if (DEBUG) {
+ Log.v(TAG, "Check if NowPlayingList is updated");
+ }
+ mAddressedMediaPlayer.updateNowPlayingList(mMediaController);
+ }
+
+ // Notify track changed if:
+ // - The CT is registered for the notification
+ // - Queue ID is UNKNOWN and MediaMetadata is different
+ // - Queue ID is valid and different from last Queue ID sent
+ if ((newQueueId == -1 || newQueueId != mLastQueueId)
+ && mTrackChangedNT == AvrcpConstants.NOTIFICATION_TYPE_INTERIM
+ && !currentAttributes.equals(mMediaAttributes)) {
+ Log.v(TAG, "Send track changed");
+ mMediaAttributes = currentAttributes;
+ mLastQueueId = newQueueId;
+ sendTrackChangedRsp(false);
+ }
+ } else {
+ Log.i(TAG, "Skipping update due to invalid playback state");
+ }
+
+ // still send the updated play state if the playback state is none or buffering
+ if (DEBUG) {
+ Log.v(TAG, "play status change " + mReportedPlayStatus + "➡" + newPlayStatus
+ + " mPlayStatusChangedNT: " + mPlayStatusChangedNT);
+ }
+ if (mPlayStatusChangedNT == AvrcpConstants.NOTIFICATION_TYPE_INTERIM || (mReportedPlayStatus
+ != newPlayStatus)) {
+ sendPlaybackStatus(AvrcpConstants.NOTIFICATION_TYPE_CHANGED, newPlayStatus);
+ mLastPassthroughcmd = KeyEvent.KEYCODE_UNKNOWN;
+ }
+
+ sendPlayPosNotificationRsp(false);
+ }
+
+ private void getRcFeaturesRequestFromNative(byte[] address, int features) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "getRcFeaturesRequestFromNative: mHandler is already null");
+ return;
+ }
+
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_GET_RC_FEATURES, features, 0,
+ Utils.getAddressStringFromByte(address));
+ handler.sendMessage(msg);
+ }
+
+ private void getPlayStatusRequestFromNative(byte[] address) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "getPlayStatusRequestFromNative: mHandler is already null");
+ return;
+ }
+
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_GET_PLAY_STATUS);
+ msg.obj = address;
+ handler.sendMessage(msg);
+ }
+
+ private void getElementAttrRequestFromNative(byte[] address, byte numAttr, int[] attrs) {
+ AvrcpCmd avrcpCmdobj = new AvrcpCmd();
+ AvrcpCmd.ElementAttrCmd elemAttr = avrcpCmdobj.new ElementAttrCmd(address, numAttr, attrs);
+ Message msg = mHandler.obtainMessage(MSG_NATIVE_REQ_GET_ELEM_ATTRS);
+ msg.obj = elemAttr;
+ mHandler.sendMessage(msg);
+ }
+
+ private void registerNotificationRequestFromNative(byte[] address, int eventId, int param) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) {
+ Log.d(TAG, "registerNotificationRequestFromNative: mHandler is already null");
+ }
+ return;
+ }
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_REGISTER_NOTIFICATION, eventId, param);
+ msg.obj = address;
+ handler.sendMessage(msg);
+ }
+
+ private void processRegisterNotification(byte[] address, int eventId, int param) {
+ switch (eventId) {
+ case EVT_PLAY_STATUS_CHANGED:
+ mPlayStatusChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ updatePlaybackState();
+ sendPlaybackStatus(AvrcpConstants.NOTIFICATION_TYPE_INTERIM, mReportedPlayStatus);
+ break;
+
+ case EVT_TRACK_CHANGED:
+ Log.v(TAG, "Track changed notification enabled");
+ mTrackChangedNT = AvrcpConstants.NOTIFICATION_TYPE_INTERIM;
+ sendTrackChangedRsp(true);
+ break;
+
+ case EVT_PLAY_POS_CHANGED:
+ if (param <= 0)
+ param = 1;
+
+ long update_interval = 0L;
+ // Split A2dp will be enabled by default
+ boolean isSplitA2dpEnabled = true;
+ AdapterService adapterService = AdapterService.getAdapterService();
+
+ if (adapterService != null){
+ isSplitA2dpEnabled = adapterService.isSplitA2dpEnabled();
+ Log.v(TAG,"isSplitA2dpEnabled: " + isSplitA2dpEnabled);
+ } else {
+ Log.e(TAG,"adapterService is null");
+ }
+
+ update_interval = (isSplitA2dpEnabled) ?
+ SystemProperties.getLong("persist.vendor.btstack.avrcp.pos_time", 3000L):
+ SystemProperties.getLong("persist.vendor.btstack.avrcp.pos_time", 1000L);
+
+ mPlayPosChangedNT = AvrcpConstants.NOTIFICATION_TYPE_INTERIM;
+ mPlaybackIntervalMs = Math.max((long)param * 1000L, update_interval);
+ sendPlayPosNotificationRsp(true);
+ break;
+
+ case EVT_AVBL_PLAYERS_CHANGED:
+ /* Notify remote available players changed */
+ if (DEBUG) {
+ Log.d(TAG, "Available Players notification enabled");
+ }
+ registerNotificationRspAvalPlayerChangedNative(
+ AvrcpConstants.NOTIFICATION_TYPE_INTERIM);
+ mAvailablePlayersChangedNT = AvrcpConstants.NOTIFICATION_TYPE_INTERIM;
+ break;
+
+ case EVT_ADDR_PLAYER_CHANGED:
+ /* Notify remote addressed players changed */
+ if (DEBUG) {
+ Log.d(TAG, "Addressed Player notification enabled");
+ }
+ registerNotificationRspAddrPlayerChangedNative(
+ AvrcpConstants.NOTIFICATION_TYPE_INTERIM, mCurrAddrPlayerID, sUIDCounter);
+ mAddrPlayerChangedNT = AvrcpConstants.NOTIFICATION_TYPE_INTERIM;
+ mReportedPlayerID = mCurrAddrPlayerID;
+ break;
+
+ case EVENT_UIDS_CHANGED:
+ if (DEBUG) {
+ Log.d(TAG, "UIDs changed notification enabled");
+ }
+ registerNotificationRspUIDsChangedNative(AvrcpConstants.NOTIFICATION_TYPE_INTERIM,
+ sUIDCounter);
+ break;
+
+ case EVENT_NOW_PLAYING_CONTENT_CHANGED:
+ if (DEBUG) {
+ Log.d(TAG, "Now Playing List changed notification enabled");
+ }
+ /* send interim response to remote device */
+ mNowPlayingListChangedNT = AvrcpConstants.NOTIFICATION_TYPE_INTERIM;
+ if (!registerNotificationRspNowPlayingChangedNative(
+ AvrcpConstants.NOTIFICATION_TYPE_INTERIM)) {
+ Log.e(TAG, "EVENT_NOW_PLAYING_CONTENT_CHANGED: "
+ + "registerNotificationRspNowPlayingChangedNative for Interim rsp "
+ + "failed!");
+ }
+ break;
+ }
+ }
+
+ private void handlePassthroughCmdRequestFromNative(byte[] address, int id, int keyState) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) {
+ Log.d(TAG, "handlePassthroughCmdRequestFromNative: mHandler is already null");
+ }
+ return;
+ }
+
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_PASS_THROUGH, id, keyState);
+ Bundle data = new Bundle();
+ data.putByteArray("BdAddress", address);
+ msg.setData(data);
+ handler.sendMessage(msg);
+ }
+
+ private void sendTrackChangedRsp(boolean registering) {
+ if (!registering && mTrackChangedNT != AvrcpConstants.NOTIFICATION_TYPE_INTERIM) {
+ if (DEBUG) {
+ Log.d(TAG, "sendTrackChangedRsp: Not registered or registering.");
+ }
+ return;
+ }
+
+ mTrackChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ if (registering) {
+ mTrackChangedNT = AvrcpConstants.NOTIFICATION_TYPE_INTERIM;
+ }
+
+ MediaPlayerInfo info = getAddressedPlayerInfo();
+ // for non-browsable players or no player
+ if ((info != null && !info.isBrowseSupported()) ||
+ (mFeatures & BTRC_FEAT_BROWSE) == 0) {
+ byte[] track = AvrcpConstants.TRACK_IS_SELECTED;
+ if (!mMediaAttributes.mExists) {
+ track = AvrcpConstants.NO_TRACK_SELECTED;
+ }
+ registerNotificationRspTrackChangeNative(mTrackChangedNT, track);
+ return;
+ }
+
+ mAddressedMediaPlayer.sendTrackChangeWithId(mTrackChangedNT, mMediaController);
+ }
+
+ private long getPlayPosition() {
+ long currPosition;
+ if (mCurrentPlayState == null) {
+ Log.d(TAG, "getPlayPosition, mCurrentPlayState is null");
+ return -1L;
+ }
+
+ if (mCurrentPlayState.getPosition() == PlaybackState.PLAYBACK_POSITION_UNKNOWN) {
+ Log.d(TAG, "getPlayPosition, currentPosition is unknown");
+ return (isPlayingState(mCurrentPlayState)) ? 0L : -1L;
+ }
+
+ if (isPlayingState(mCurrentPlayState)) {
+ long sinceUpdate =
+ (SystemClock.elapsedRealtime() - mCurrentPlayState.getLastPositionUpdateTime());
+ return sinceUpdate + mCurrentPlayState.getPosition();
+ }
+ currPosition = mCurrentPlayState.getPosition();
+ if (mMediaAttributes.mPlayingTimeMs >= 0 && currPosition > mMediaAttributes.mPlayingTimeMs) {
+ currPosition = mMediaAttributes.mPlayingTimeMs;
+ }
+ return currPosition;
+ }
+
+ private boolean isPlayingState(@Nullable PlaybackState state) {
+ if (state == null) {
+ return false;
+ }
+ return (state != null) && (state.getState() == PlaybackState.STATE_PLAYING);
+ }
+
+ /**
+ * Sends a play position notification, or schedules one to be
+ * sent later at an appropriate time. If |requested| is true,
+ * does both because this was called in reponse to a request from the
+ * TG.
+ */
+ private void sendPlayPosNotificationRsp(boolean requested) {
+ if (!requested && mPlayPosChangedNT != AvrcpConstants.NOTIFICATION_TYPE_INTERIM) {
+ if (DEBUG) {
+ Log.d(TAG, "sendPlayPosNotificationRsp: Not registered or requesting.");
+ }
+ return;
+ }
+
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "sendPlayPosNotificationRsp: handler is already null");
+ return;
+ }
+
+ long playPositionMs = getPlayPosition();
+ String debugLine = "sendPlayPosNotificationRsp: ";
+
+ // mNextPosMs is set to -1 when the previous position was invalid
+ // so this will be true if the new position is valid & old was invalid.
+ // mPlayPositionMs is set to -1 when the new position is invalid,
+ // and the old mPrevPosMs is >= 0 so this is true when the new is invalid
+ // and the old was valid.
+ if (DEBUG) {
+ debugLine += "(" + requested + ") " + mPrevPosMs + " <=? " + playPositionMs + " <=? "
+ + mNextPosMs;
+ if (isPlayingState(mCurrentPlayState)) {
+ debugLine += " Playing";
+ }
+ debugLine += " State: " + mCurrentPlayState.getState();
+ }
+ if (requested || ((mLastReportedPosition != playPositionMs) &&
+ ((playPositionMs >= mNextPosMs) || (playPositionMs <= mPrevPosMs)))) {
+ if (!requested) {
+ mPlayPosChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ }
+ registerNotificationRspPlayPosNative(mPlayPosChangedNT, (int) playPositionMs);
+ mLastReportedPosition = playPositionMs;
+ if (playPositionMs != PlaybackState.PLAYBACK_POSITION_UNKNOWN) {
+ mNextPosMs = playPositionMs + mPlaybackIntervalMs;
+ mPrevPosMs = playPositionMs - mPlaybackIntervalMs;
+ } else {
+ mNextPosMs = -1;
+ mPrevPosMs = -1;
+ }
+ }
+
+ handler.removeMessages(MSG_PLAY_INTERVAL_TIMEOUT);
+ if (mPlayPosChangedNT == AvrcpConstants.NOTIFICATION_TYPE_INTERIM && isPlayingState(
+ mCurrentPlayState)) {
+ Message msg = handler.obtainMessage(MSG_PLAY_INTERVAL_TIMEOUT);
+ long delay = mPlaybackIntervalMs;
+ if (mNextPosMs != -1) {
+ delay = mNextPosMs - (playPositionMs > 0 ? playPositionMs : 0);
+ }
+ if (DEBUG) {
+ debugLine += " Timeout " + delay + "ms";
+ }
+ handler.sendMessageDelayed(msg, delay);
+ }
+ if (DEBUG) {
+ Log.d(TAG, debugLine);
+ }
+ }
+
+ /**
+ * This is called from AudioService. It will return whether this device supports abs volume.
+ * NOT USED AT THE MOMENT.
+ */
+ public boolean isAbsoluteVolumeSupported() {
+ return ((mFeatures & BTRC_FEAT_ABSOLUTE_VOLUME) != 0);
+ }
+
+ /**
+ * We get this call from AudioService. This will send a message to our handler object,
+ * requesting our handler to call setVolumeNative()
+ */
+ public void setAbsoluteVolume(int volume) {
+ if (volume == mLocalVolume) {
+ if (DEBUG) {
+ Log.v(TAG, "setAbsoluteVolume is setting same index, ignore " + volume);
+ }
+ return;
+ }
+
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "setAbsoluteVolume: mHandler is already null");
+ return;
+ }
+
+ Message msg = handler.obtainMessage(MSG_SET_ABSOLUTE_VOLUME, volume, 0);
+ handler.sendMessage(msg);
+ Log.v(TAG, "Exit setAbsoluteVolume");
+ }
+
+ /* Called in the native layer as a btrc_callback to return the volume set on the carkit in the
+ * case when the volume is change locally on the carkit. This notification is not called when
+ * the volume is changed from the phone.
+ *
+ * This method will send a message to our handler to change the local stored volume and notify
+ * AudioService to update the UI
+ */
+ private void volumeChangeRequestFromNative(byte[] address, int volume, int ctype) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "volumeChangeRequestFromNative: mHandler is already null");
+ return;
+ }
+
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_VOLUME_CHANGE, volume, ctype);
+ Bundle data = new Bundle();
+ data.putByteArray("BdAddress", address);
+ msg.setData(data);
+ handler.sendMessage(msg);
+ }
+
+ private void getFolderItemsRequestFromNative(byte[] address, byte scope, long startItem,
+ long endItem, byte numAttr, int[] attrIds) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "getFolderItemsRequestFromNative: mHandler is already null");
+ return;
+ }
+ AvrcpCmd avrcpCmdobj = new AvrcpCmd();
+ AvrcpCmd.FolderItemsCmd folderObj =
+ avrcpCmdobj.new FolderItemsCmd(address, scope, startItem, endItem, numAttr,
+ attrIds);
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_GET_FOLDER_ITEMS, 0, 0);
+ msg.obj = folderObj;
+ handler.sendMessage(msg);
+ }
+
+ private void setAddressedPlayerRequestFromNative(byte[] address, int playerId) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "setAddressedPlayerRequestFromNative: mHandler is already null");
+ return;
+ }
+
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_SET_ADDR_PLAYER, playerId, 0);
+ msg.obj = address;
+ handler.sendMessage(msg);
+ }
+
+ private void setBrowsedPlayerRequestFromNative(byte[] address, int playerId) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "setBrowsedPlayerRequestFromNative: mHandler is already null");
+ return;
+ }
+
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_SET_BR_PLAYER, playerId, 0);
+ msg.obj = address;
+ handler.sendMessage(msg);
+ }
+
+ private void changePathRequestFromNative(byte[] address, byte direction, byte[] folderUid) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "changePathRequestFromNative: mHandler is already null");
+ return;
+ }
+
+ Bundle data = new Bundle();
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_CHANGE_PATH);
+ data.putByteArray("BdAddress", address);
+ data.putByteArray("folderUid", folderUid);
+ data.putByte("direction", direction);
+ msg.setData(data);
+ handler.sendMessage(msg);
+ }
+
+ private void getItemAttrRequestFromNative(byte[] address, byte scope, byte[] itemUid,
+ int uidCounter, byte numAttr, int[] attrs) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "getItemAttrRequestFromNative: mHandler is already null");
+ return;
+ }
+ AvrcpCmd avrcpCmdobj = new AvrcpCmd();
+ AvrcpCmd.ItemAttrCmd itemAttr =
+ avrcpCmdobj.new ItemAttrCmd(address, scope, itemUid, uidCounter, numAttr, attrs);
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_GET_ITEM_ATTR);
+ msg.obj = itemAttr;
+ handler.sendMessage(msg);
+ }
+
+ private void searchRequestFromNative(byte[] address, int charsetId, byte[] searchStr) {
+ /* Search is not supported */
+ Log.w(TAG, "searchRequestFromNative: search is not supported");
+ searchRspNative(address, AvrcpConstants.RSP_SRCH_NOT_SPRTD, 0, 0);
+ }
+
+ private void playItemRequestFromNative(byte[] address, byte scope, int uidCounter, byte[] uid) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "playItemRequestFromNative: mHandler is already null");
+ return;
+ }
+
+ Bundle data = new Bundle();
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_PLAY_ITEM);
+ data.putByteArray("BdAddress", address);
+ data.putByteArray("uid", uid);
+ data.putInt("uidCounter", uidCounter);
+ data.putByte("scope", scope);
+
+ msg.setData(data);
+ handler.sendMessage(msg);
+ }
+
+ private void addToPlayListRequestFromNative(byte[] address, byte scope, byte[] uid,
+ int uidCounter) {
+ /* add to NowPlaying not supported */
+ Log.w(TAG, "addToPlayListRequestFromNative: not supported! scope=" + scope);
+ addToNowPlayingRspNative(address, AvrcpConstants.RSP_INTERNAL_ERR);
+ }
+
+ private void getTotalNumOfItemsRequestFromNative(byte[] address, byte scope) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "getTotalNumOfItemsRequestFromNative: mHandler is already null");
+ return;
+ }
+
+ Bundle data = new Bundle();
+ Message msg = handler.obtainMessage(MSG_NATIVE_REQ_GET_TOTAL_NUM_OF_ITEMS);
+ msg.arg1 = scope;
+ msg.obj = address;
+ handler.sendMessage(msg);
+ }
+
+ private void notifyVolumeChanged(int volume, boolean isShowUI) {
+ if (isShowUI) {
+ mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, volume,
+ AudioManager.FLAG_SHOW_UI | AudioManager.FLAG_BLUETOOTH_ABS_VOLUME);
+ } else {
+ mAudioManager.setStreamVolume(AudioManager.STREAM_MUSIC, volume,
+ AudioManager.FLAG_BLUETOOTH_ABS_VOLUME);
+ }
+ }
+
+ private int convertToAudioStreamVolume(int volume) {
+ // Rescale volume to match AudioSystem's volume
+ return (int) Math.floor((double) volume * mAudioStreamMax / AVRCP_MAX_VOL);
+ }
+
+ private int convertToAvrcpVolume(int volume) {
+ return (int) Math.ceil((double) volume * AVRCP_MAX_VOL / mAudioStreamMax);
+ }
+
+ private void blackListCurrentDevice(String reason) {
+ mFeatures &= ~BTRC_FEAT_ABSOLUTE_VOLUME;
+ mAudioManager.avrcpSupportsAbsoluteVolume(mAddress, isAbsoluteVolumeSupported());
+
+ SharedPreferences pref =
+ mContext.getSharedPreferences(ABSOLUTE_VOLUME_BLACKLIST, Context.MODE_PRIVATE);
+ SharedPreferences.Editor editor = pref.edit();
+
+ StringBuilder sb = new StringBuilder();
+ sb.append("Time: ");
+ sb.append(android.text.format.DateFormat.format("yyyy/MM/dd HH:mm:ss",
+ System.currentTimeMillis()));
+ sb.append(" Reason: ");
+ sb.append(reason);
+ editor.putString(mAddress, sb.toString());
+ editor.apply();
+ }
+
+ private int modifyRcFeatureFromBlacklist(int feature, String address) {
+ SharedPreferences pref =
+ mContext.getSharedPreferences(ABSOLUTE_VOLUME_BLACKLIST, Context.MODE_PRIVATE);
+ if (!pref.contains(address)) {
+ return feature;
+ }
+ return feature & ~BTRC_FEAT_ABSOLUTE_VOLUME;
+ }
+
+ public void resetBlackList(String address) {
+ SharedPreferences pref =
+ mContext.getSharedPreferences(ABSOLUTE_VOLUME_BLACKLIST, Context.MODE_PRIVATE);
+ SharedPreferences.Editor editor = pref.edit();
+ editor.remove(address);
+ editor.apply();
+ }
+
+ /**
+ * This is called from A2dpStateMachine to set A2dp audio state.
+ */
+ public void setA2dpAudioState(int state) {
+ final AvrcpMessageHandler handler = mHandler;
+ if (handler == null) {
+ if (DEBUG) Log.d(TAG, "setA2dpAudioState: mHandler is already null");
+ return;
+ }
+
+ Message msg = handler.obtainMessage(MSG_SET_A2DP_AUDIO_STATE, state, 0);
+ handler.sendMessage(msg);
+ }
+
+ private class AvrcpServiceBootReceiver extends BroadcastReceiver {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ String action = intent.getAction();
+ if (action.equals(Intent.ACTION_USER_UNLOCKED)) {
+ if (DEBUG) {
+ Log.d(TAG, "User unlocked, initializing player lists");
+ }
+ /* initializing media player's list */
+ buildBrowsablePlayerList();
+ }
+ }
+ }
+
+ private class AvrcpServiceBroadcastReceiver extends BroadcastReceiver {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ String action = intent.getAction();
+ if (DEBUG) {
+ Log.d(TAG, "AvrcpServiceBroadcastReceiver-> Action: " + action);
+ }
+
+ if (action.equals(Intent.ACTION_PACKAGE_REMOVED) || action.equals(
+ Intent.ACTION_PACKAGE_DATA_CLEARED)) {
+ if (!intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) {
+ // a package is being removed, not replaced
+ String packageName = intent.getData().getSchemeSpecificPart();
+ if (packageName != null) {
+ handlePackageModified(packageName, true);
+ }
+ }
+
+ } else if (action.equals(Intent.ACTION_PACKAGE_ADDED) || action.equals(
+ Intent.ACTION_PACKAGE_CHANGED)) {
+ String packageName = intent.getData().getSchemeSpecificPart();
+ if (DEBUG) {
+ Log.d(TAG, "AvrcpServiceBroadcastReceiver-> packageName: " + packageName);
+ }
+ if (packageName != null) {
+ handlePackageModified(packageName, false);
+ }
+ }
+ }
+ }
+
+ private void handlePackageModified(String packageName, boolean removed) {
+ if (DEBUG) {
+ Log.d(TAG, "packageName: " + packageName + " removed: " + removed);
+ }
+
+ if (removed) {
+ removeMediaPlayerInfo(packageName);
+ // old package is removed, updating local browsable player's list
+ if (isBrowseSupported(packageName)) {
+ removePackageFromBrowseList(packageName);
+ }
+ } else {
+ // new package has been added.
+ if (isBrowsableListUpdated(packageName)) {
+ // Rebuilding browsable players list
+ buildBrowsablePlayerList();
+ }
+ }
+ }
+
+ private boolean isBrowsableListUpdated(String newPackageName) {
+ // getting the browsable media players list from package manager
+ Intent intent = new Intent("android.media.browse.MediaBrowserService");
+ List<ResolveInfo> resInfos =
+ mPackageManager.queryIntentServices(intent, PackageManager.MATCH_ALL);
+ for (ResolveInfo resolveInfo : resInfos) {
+ if (resolveInfo.serviceInfo.packageName.equals(newPackageName)) {
+ if (DEBUG) {
+ Log.d(TAG,
+ "isBrowsableListUpdated: package includes MediaBrowserService, true");
+ }
+ return true;
+ }
+ }
+
+ // if list has different size
+ if (resInfos.size() != mBrowsePlayerInfoList.size()) {
+ if (DEBUG) {
+ Log.d(TAG, "isBrowsableListUpdated: browsable list size mismatch, true");
+ }
+ return true;
+ }
+
+ Log.d(TAG, "isBrowsableListUpdated: false");
+ return false;
+ }
+
+ private void removePackageFromBrowseList(String packageName) {
+ if (DEBUG) {
+ Log.d(TAG, "removePackageFromBrowseList: " + packageName);
+ }
+ synchronized (mBrowsePlayerInfoList) {
+ int browseInfoID = getBrowseId(packageName);
+ if (browseInfoID != -1) {
+ mBrowsePlayerInfoList.remove(browseInfoID);
+ }
+ }
+ }
+
+ /*
+ * utility function to get the browse player index from global browsable
+ * list. It may return -1 if specified package name is not in the list.
+ */
+ private int getBrowseId(String packageName) {
+ boolean response = false;
+ int browseInfoID = 0;
+ synchronized (mBrowsePlayerInfoList) {
+ for (BrowsePlayerInfo info : mBrowsePlayerInfoList) {
+ if (info.packageName.equals(packageName)) {
+ response = true;
+ break;
+ }
+ browseInfoID++;
+ }
+ }
+
+ if (!response) {
+ browseInfoID = -1;
+ }
+
+ if (DEBUG) {
+ Log.d(TAG, "getBrowseId for packageName: " + packageName + " , browseInfoID: "
+ + browseInfoID);
+ }
+ return browseInfoID;
+ }
+
+ private void setAddressedPlayer(byte[] bdaddr, int selectedId) {
+ String functionTag = "setAddressedPlayer(" + selectedId + "): ";
+
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ if (mMediaPlayerInfoList.isEmpty()) {
+ Log.w(TAG, functionTag + "no players, send no available players");
+ setAddressedPlayerRspNative(bdaddr, AvrcpConstants.RSP_NO_AVBL_PLAY);
+ return;
+ }
+ if (selectedId == NO_PLAYER_ID) {
+ Log.w(TAG, functionTag + "Respond dummy pass response ");
+ setAddressedPlayerRspNative(bdaddr, AvrcpConstants.RSP_NO_ERROR);
+ return;
+ }
+ if (!mMediaPlayerInfoList.containsKey(selectedId)) {
+ Log.w(TAG, functionTag + "invalid id, sending response back ");
+ setAddressedPlayerRspNative(bdaddr, AvrcpConstants.RSP_INV_PLAYER);
+ return;
+ }
+
+ if (isPlayerAlreadyAddressed(selectedId)) {
+ MediaPlayerInfo info = getAddressedPlayerInfo();
+ Log.i(TAG, functionTag + "player already addressed: " + info);
+ setAddressedPlayerRspNative(bdaddr, AvrcpConstants.RSP_NO_ERROR);
+ return;
+ }
+ // register new Media Controller Callback and update the current IDs
+ if (!updateCurrentController(selectedId, mCurrBrowsePlayerID)) {
+ Log.e(TAG, functionTag + "updateCurrentController failed!");
+ setAddressedPlayerRspNative(bdaddr, AvrcpConstants.RSP_INTERNAL_ERR);
+ return;
+ }
+ // If we don't have a controller, try to launch the player
+ MediaPlayerInfo info = getAddressedPlayerInfo();
+ if (info.getMediaController() == null) {
+ Intent launch = mPackageManager.getLaunchIntentForPackage(info.getPackageName());
+ Log.i(TAG, functionTag + "launching player " + launch);
+ mContext.startActivity(launch);
+ }
+ }
+ }
+ setAddressedPlayerRspNative(bdaddr, AvrcpConstants.RSP_NO_ERROR);
+ }
+
+ private void setBrowsedPlayer(byte[] bdaddr, int selectedId) {
+ int status = AvrcpConstants.RSP_NO_ERROR;
+
+ // checking for error cases
+ if (mMediaPlayerInfoList.isEmpty()) {
+ status = AvrcpConstants.RSP_NO_AVBL_PLAY;
+ Log.w(TAG, "setBrowsedPlayer: No available players! ");
+ } else {
+ // Workaround for broken controllers selecting ID 0
+ // Seen at least on Ford, Chevrolet MyLink
+ if (selectedId == 0) {
+ Log.w(TAG, "setBrowsedPlayer: workaround invalid id 0");
+ selectedId = mCurrAddrPlayerID;
+ }
+
+ // update current browse player id and start browsing service
+ updateNewIds(mCurrAddrPlayerID, selectedId);
+ String browsedPackage = getPackageName(selectedId);
+
+ if (!isPackageNameValid(browsedPackage)) {
+ Log.w(TAG, " Invalid package for id:" + mCurrBrowsePlayerID);
+ status = AvrcpConstants.RSP_INV_PLAYER;
+ } else if (!isBrowseSupported(browsedPackage)) {
+ Log.w(TAG, "Browse unsupported for id:" + mCurrBrowsePlayerID + ", packagename : "
+ + browsedPackage);
+ status = AvrcpConstants.RSP_PLAY_NOT_BROW;
+ } else if (!startBrowseService(bdaddr, browsedPackage)) {
+ Log.e(TAG, "service cannot be started for browse player id:" + mCurrBrowsePlayerID
+ + ", packagename : " + browsedPackage);
+ status = AvrcpConstants.RSP_INTERNAL_ERR;
+ }
+ }
+
+ if (status != AvrcpConstants.RSP_NO_ERROR) {
+ setBrowsedPlayerRspNative(bdaddr, status, (byte) 0x00, 0, null);
+ }
+
+ if (DEBUG) {
+ Log.d(TAG, "setBrowsedPlayer for selectedId: " + selectedId + " , status: " + status);
+ }
+ }
+
+ private MediaSessionManager.OnActiveSessionsChangedListener mActiveSessionListener =
+ new MediaSessionManager.OnActiveSessionsChangedListener() {
+
+ @Override
+ public void onActiveSessionsChanged(
+ List<android.media.session.MediaController> newControllers) {
+ if (newControllers.size() > 0) {
+ HeadsetService mService = HeadsetService.getHeadsetService();
+ if (mService != null && mService.isScoOrCallActive()) {
+ Log.d(TAG, "Ignoring session changed update because of MT call in progress");
+ return;
+ }
+ }
+ Set<String> updatedPackages = new HashSet<String>();
+ // Update the current players
+ synchronized (Avrcp.this) {
+ for (android.media.session.MediaController controller : newControllers) {
+ String packageName = controller.getPackageName();
+ if (DEBUG) {
+ Log.v(TAG, "ActiveSession: " + MediaControllerFactory.wrap(controller));
+ }
+ // Only use the first (highest priority) controller from each package
+ if (updatedPackages.contains(packageName)) {
+ continue;
+ }
+ addMediaPlayerController(controller);
+ updatedPackages.add(packageName);
+ }
+ }
+
+ if (newControllers.size() > 0 && getAddressedPlayerInfo() == null) {
+ if (DEBUG) {
+ Log.v(TAG, "No addressed player but active sessions, taking first.");
+ }
+ setAddressedMediaSessionPackage(newControllers.get(0).getPackageName());
+ }
+ updateCurrentMediaState();
+ }
+ };
+
+ private void setAddressedMediaSessionPackage(@Nullable String packageName) {
+ if (packageName == null) {
+ // Should only happen when there's no media players, reset to no available player.
+ updateCurrentController(0, mCurrBrowsePlayerID);
+ return;
+ }
+ if (packageName.equals("com.android.server.telecom")) {
+ Log.d(TAG, "Ignore addressed media session change to telecom");
+ return;
+ }
+ // No change.
+ if (getPackageName(mCurrAddrPlayerID).equals(packageName)) {
+ return;
+ }
+ if (DEBUG) {
+ Log.v(TAG, "Changing addressed media session to " + packageName);
+ }
+ // If the player doesn't exist, we need to add it.
+ if (getMediaPlayerInfo(packageName) == null) {
+ addMediaPlayerPackage(packageName);
+ updateCurrentMediaState();
+ }
+
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ for (Map.Entry<Integer, MediaPlayerInfo> entry : mMediaPlayerInfoList.entrySet()) {
+ if (entry.getValue().getPackageName().equals(packageName)) {
+ int newAddrID = entry.getKey();
+ if (DEBUG) {
+ Log.v(TAG, "Set addressed #" + newAddrID + " " + entry.getValue());
+ }
+ updateCurrentController(newAddrID, mCurrBrowsePlayerID);
+ updateCurrentMediaState();
+ return;
+ }
+ }
+ }
+ }
+ // We shouldn't ever get here.
+ Log.e(TAG, "Player info for " + packageName + " doesn't exist!");
+ }
+
+ private void setActiveMediaSession(MediaSession.Token token) {
+ android.media.session.MediaController activeController =
+ new android.media.session.MediaController(mContext, token);
+ if (activeController.getPackageName().contains("telecom")) {
+ Log.d(TAG, "Ignore active media session change to telecom");
+ return;
+ }
+ HeadsetService mService = HeadsetService.getHeadsetService();
+ if (mService != null && mService.isScoOrCallActive()) {
+ Log.v(TAG,"Ignore setActiveMediaSession for telecom, call in progress");
+ return;
+ }
+
+
+ if (mHandler.hasMessages(MESSAGE_SET_MEDIA_SESSION))
+ mHandler.removeMessages(MESSAGE_SET_MEDIA_SESSION);
+ if (DEBUG) {
+ Log.v(TAG, "Set active media session " + activeController.getPackageName());
+ }
+ synchronized (Avrcp.this) {
+ addMediaPlayerController(activeController);
+ setAddressedMediaSessionPackage(activeController.getPackageName());
+ }
+ }
+
+ private void setActiveMediaSession(android.media.session.MediaController mController) {
+ HeadsetService mService = HeadsetService.getHeadsetService();
+ if ((mService != null && mService.isScoOrCallActive())) {
+ Log.w(TAG, "Ignore media session during call");
+ return;
+ }
+ addMediaPlayerController(mController);
+ setAddressedMediaSessionPackage(mController.getPackageName());
+ }
+
+ private boolean startBrowseService(byte[] bdaddr, String packageName) {
+ boolean status = true;
+
+ /* creating new instance for Browse Media Player */
+ String browseService = getBrowseServiceName(packageName);
+ if (!browseService.isEmpty()) {
+ mAvrcpBrowseManager.getBrowsedMediaPlayer(bdaddr)
+ .setBrowsed(packageName, browseService);
+ } else {
+ Log.w(TAG, "No Browser service available for " + packageName);
+ status = false;
+ }
+
+ if (DEBUG) {
+ Log.d(TAG,
+ "startBrowseService for packageName: " + packageName + ", status = " + status);
+ }
+ return status;
+ }
+
+ private String getBrowseServiceName(String packageName) {
+ String browseServiceName = "";
+
+ // getting the browse service name from browse player info
+ synchronized (mBrowsePlayerInfoList) {
+ int browseInfoID = getBrowseId(packageName);
+ if (browseInfoID != -1) {
+ browseServiceName = mBrowsePlayerInfoList.get(browseInfoID).serviceClass;
+ }
+ }
+
+ if (DEBUG) {
+ Log.d(TAG, "getBrowseServiceName for packageName: " + packageName
+ + ", browseServiceName = " + browseServiceName);
+ }
+ return browseServiceName;
+ }
+
+ void buildBrowsablePlayerList() {
+ synchronized (mBrowsePlayerInfoList) {
+ mBrowsePlayerInfoList.clear();
+ Intent intent = new Intent(android.service.media.MediaBrowserService.SERVICE_INTERFACE);
+ List<ResolveInfo> playerList =
+ mPackageManager.queryIntentServices(intent, PackageManager.MATCH_ALL);
+
+ for (ResolveInfo info : playerList) {
+ String displayableName = info.loadLabel(mPackageManager).toString();
+ String serviceName = info.serviceInfo.name;
+ String packageName = info.serviceInfo.packageName;
+
+ if (DEBUG) {
+ Log.d(TAG, "Adding " + serviceName + " to list of browsable players");
+ }
+ BrowsePlayerInfo currentPlayer =
+ new BrowsePlayerInfo(packageName, displayableName, serviceName);
+ mBrowsePlayerInfoList.add(currentPlayer);
+ MediaPlayerInfo playerInfo = getMediaPlayerInfo(packageName);
+ MediaController controller =
+ (playerInfo == null) ? null : playerInfo.getMediaController();
+ // Refresh the media player entry so it notices we can browse
+ if (controller != null) {
+ addMediaPlayerController(controller.getWrappedInstance());
+ } else {
+ addMediaPlayerPackage(packageName);
+ }
+ }
+ updateCurrentMediaState();
+ }
+ }
+
+ /* Initializes list of media players identified from session manager active sessions */
+ private void initMediaPlayersList() {
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ // Clearing old browsable player's list
+ mMediaPlayerInfoList.clear();
+
+ if (mMediaSessionManager == null) {
+ if (DEBUG) {
+ Log.w(TAG, "initMediaPlayersList: no media session manager!");
+ }
+ return;
+ }
+
+ List<android.media.session.MediaController> controllers =
+ mMediaSessionManager.getActiveSessions(null);
+ if (DEBUG) {
+ Log.v(TAG, "initMediaPlayerInfoList: " + controllers.size() + " controllers");
+ }
+ /* Initializing all media players */
+ for (android.media.session.MediaController controller : controllers) {
+ addMediaPlayerController(controller);
+ }
+
+ updateCurrentMediaState();
+
+ if (mMediaPlayerInfoList.size() > 0) {
+ // Set the first one as the Addressed Player
+ updateCurrentController(mMediaPlayerInfoList.firstKey(), -1);
+ }
+ }
+ }
+ }
+
+ private List<android.media.session.MediaController> getMediaControllers() {
+ List<android.media.session.MediaController> controllers =
+ new ArrayList<android.media.session.MediaController>();
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ for (MediaPlayerInfo info : mMediaPlayerInfoList.values()) {
+ MediaController controller = info.getMediaController();
+ if (controller != null) {
+ controllers.add(controller.getWrappedInstance());
+ }
+ }
+ }
+ }
+ return controllers;
+ }
+
+ /** Add (or update) a player to the media player list without a controller */
+ private boolean addMediaPlayerPackage(String packageName) {
+ MediaPlayerInfo info = new MediaPlayerInfo(null, AvrcpConstants.PLAYER_TYPE_AUDIO,
+ AvrcpConstants.PLAYER_SUBTYPE_NONE, PLAYSTATUS_STOPPED,
+ getFeatureBitMask(packageName), packageName, getAppLabel(packageName));
+ return addMediaPlayerInfo(info);
+ }
+
+ /** Add (or update) a player to the media player list given an active controller */
+ private boolean addMediaPlayerController(android.media.session.MediaController controller) {
+ String packageName = controller.getPackageName();
+ MediaPlayerInfo info = new MediaPlayerInfo(MediaControllerFactory.wrap(controller),
+ AvrcpConstants.PLAYER_TYPE_AUDIO, AvrcpConstants.PLAYER_SUBTYPE_NONE,
+ getBluetoothPlayState(controller.getPlaybackState()),
+ getFeatureBitMask(packageName), controller.getPackageName(),
+ getAppLabel(packageName));
+ return addMediaPlayerInfo(info);
+ }
+
+ /** Add or update a player to the media player list given the MediaPlayerInfo object.
+ * @return true if an item was updated, false if it was added instead
+ */
+ private boolean addMediaPlayerInfo(MediaPlayerInfo info) {
+ int updateId = -1;
+ boolean updated = false;
+ boolean currentRemoved = false;
+ if (info.getPackageName().equals("com.android.server.telecom")) {
+ Log.d(TAG, "Skip adding telecom to the media player info list");
+ return updated;
+ }
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ for (Map.Entry<Integer, MediaPlayerInfo> entry : mMediaPlayerInfoList.entrySet()) {
+ MediaPlayerInfo current = entry.getValue();
+ int id = entry.getKey();
+ if (info.getPackageName().equals(current.getPackageName())) {
+ if (!current.equalView(info)) {
+ // If we would present a different player, make it a new player
+ // so that controllers know whether a player is browsable or not.
+ mMediaPlayerInfoList.remove(id);
+ currentRemoved = (mCurrAddrPlayerID == id);
+ break;
+ }
+ updateId = id;
+ updated = true;
+ break;
+ }
+ }
+ if (updateId == -1) {
+ // New player
+ mLastUsedPlayerID++;
+ updateId = mLastUsedPlayerID;
+ mAvailablePlayerViewChanged = true;
+ }
+ mMediaPlayerInfoList.put(updateId, info);
+ }
+ }
+ if (DEBUG) {
+ Log.d(TAG, (updated ? "update #" : "add #") + updateId + ":" + info.toString());
+ }
+ if (currentRemoved || updateId == mCurrAddrPlayerID) {
+ updateCurrentController(updateId, mCurrBrowsePlayerID);
+ }
+ return updated;
+ }
+
+ /** Remove all players related to |packageName| from the media player info list */
+ private MediaPlayerInfo removeMediaPlayerInfo(String packageName) {
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ int removeKey = -1;
+ for (Map.Entry<Integer, MediaPlayerInfo> entry : mMediaPlayerInfoList.entrySet()) {
+ if (entry.getValue().getPackageName().equals(packageName)) {
+ removeKey = entry.getKey();
+ break;
+ }
+ }
+ if (removeKey != -1) {
+ if (DEBUG) {
+ Log.d(TAG, "remove #" + removeKey + ":"
+ + mMediaPlayerInfoList.get(removeKey));
+ }
+ mAvailablePlayerViewChanged = true;
+ return mMediaPlayerInfoList.remove(removeKey);
+ }
+
+ return null;
+ }
+ }
+ }
+
+ /** Remove the controller referenced by |controller| from any player in the list */
+ private void removeMediaController(@Nullable android.media.session.MediaController controller) {
+ if (controller == null) {
+ return;
+ }
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ for (Map.Entry<Integer, MediaPlayerInfo> entry : mMediaPlayerInfoList.entrySet()) {
+ MediaPlayerInfo info = entry.getValue();
+ MediaController c = info.getMediaController();
+ if (c != null && c.equals(controller)) {
+ info.setMediaController(null);
+ if (entry.getKey() == mCurrAddrPlayerID) {
+ updateCurrentController(mCurrAddrPlayerID, mCurrBrowsePlayerID);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /*
+ * utility function to get the playback state of any media player through
+ * media controller APIs.
+ */
+ private byte getBluetoothPlayState(PlaybackState pbState) {
+ if (pbState == null) {
+ Log.w(TAG, "playState object null, sending STOPPED");
+ return PLAYSTATUS_STOPPED;
+ }
+
+ switch (pbState.getState()) {
+ case PlaybackState.STATE_PLAYING:
+ return PLAYSTATUS_PLAYING;
+
+ case PlaybackState.STATE_STOPPED:
+ case PlaybackState.STATE_NONE:
+ case PlaybackState.STATE_CONNECTING:
+ return PLAYSTATUS_STOPPED;
+
+ case PlaybackState.STATE_PAUSED:
+ case PlaybackState.STATE_BUFFERING:
+ return PLAYSTATUS_PAUSED;
+
+ case PlaybackState.STATE_FAST_FORWARDING:
+ case PlaybackState.STATE_SKIPPING_TO_NEXT:
+ case PlaybackState.STATE_SKIPPING_TO_QUEUE_ITEM:
+ return PLAYSTATUS_FWD_SEEK;
+
+ case PlaybackState.STATE_REWINDING:
+ case PlaybackState.STATE_SKIPPING_TO_PREVIOUS:
+ return PLAYSTATUS_REV_SEEK;
+
+ case PlaybackState.STATE_ERROR:
+ default:
+ return PLAYSTATUS_ERROR;
+ }
+ }
+
+ /*
+ * utility function to get the feature bit mask of any media player through
+ * package name
+ */
+ private short[] getFeatureBitMask(String packageName) {
+
+ ArrayList<Short> featureBitsList = new ArrayList<Short>();
+
+ /* adding default feature bits */
+ featureBitsList.add(AvrcpConstants.AVRC_PF_PLAY_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_STOP_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_PAUSE_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_REWIND_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_FAST_FWD_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_FORWARD_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_BACKWARD_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_ADV_CTRL_BIT_NO);
+
+ /* Add/Modify browse player supported features. */
+ if (isBrowseSupported(packageName)) {
+ featureBitsList.add(AvrcpConstants.AVRC_PF_BROWSE_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_UID_UNIQUE_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_NOW_PLAY_BIT_NO);
+ featureBitsList.add(AvrcpConstants.AVRC_PF_GET_NUM_OF_ITEMS_BIT_NO);
+ }
+
+ // converting arraylist to array for response
+ short[] featureBitsArray = new short[featureBitsList.size()];
+
+ for (int i = 0; i < featureBitsList.size(); i++) {
+ featureBitsArray[i] = featureBitsList.get(i).shortValue();
+ }
+
+ return featureBitsArray;
+ }
+
+ /**
+ * Checks the Package name if it supports Browsing or not.
+ *
+ * @param packageName - name of the package to get the Id.
+ * @return true if it supports browsing, else false.
+ */
+ private boolean isBrowseSupported(String packageName) {
+ synchronized (mBrowsePlayerInfoList) {
+ /* check if Browsable Player's list contains this package name */
+ for (BrowsePlayerInfo info : mBrowsePlayerInfoList) {
+ if (info.packageName.equals(packageName)) {
+ if (DEBUG) {
+ Log.v(TAG, "isBrowseSupported for " + packageName + ": true");
+ }
+ return true;
+ }
+ }
+ }
+
+ if (DEBUG) {
+ Log.v(TAG, "isBrowseSupported for " + packageName + ": false");
+ }
+ return false;
+ }
+
+ private String getPackageName(int id) {
+ MediaPlayerInfo player = null;
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ player = mMediaPlayerInfoList.getOrDefault(id, null);
+ }
+ }
+
+ if (player == null) {
+ Log.w(TAG, "No package name for player (" + id + " not valid)");
+ return "";
+ }
+
+ String packageName = player.getPackageName();
+ if (DEBUG) {
+ Log.v(TAG, "Player " + id + " package: " + packageName);
+ }
+ return packageName;
+ }
+
+ /* from the global object, getting the current browsed player's package name */
+ private String getCurrentBrowsedPlayer(byte[] bdaddr) {
+ String browsedPlayerPackage = "";
+
+ Map<String, BrowsedMediaPlayer> connList = mAvrcpBrowseManager.getConnList();
+ String bdaddrStr = new String(bdaddr);
+ if (connList.containsKey(bdaddrStr)) {
+ browsedPlayerPackage = connList.get(bdaddrStr).getPackageName();
+ }
+ if (DEBUG) {
+ Log.v(TAG, "getCurrentBrowsedPlayerPackage: " + browsedPlayerPackage);
+ }
+ return browsedPlayerPackage;
+ }
+
+ /* Returns the MediaPlayerInfo for the currently addressed media player */
+ private MediaPlayerInfo getAddressedPlayerInfo() {
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ return mMediaPlayerInfoList.getOrDefault(mCurrAddrPlayerID, null);
+ }
+ }
+ }
+
+ /*
+ * Utility function to get the Media player info from package name returns
+ * null if package name not found in media players list
+ */
+ private MediaPlayerInfo getMediaPlayerInfo(String packageName) {
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ if (mMediaPlayerInfoList.isEmpty()) {
+ if (DEBUG) {
+ Log.v(TAG, "getMediaPlayerInfo: Media players list empty");
+ }
+ return null;
+ }
+
+ for (MediaPlayerInfo info : mMediaPlayerInfoList.values()) {
+ if (packageName.equals(info.getPackageName())) {
+ if (DEBUG) {
+ Log.v(TAG, "getMediaPlayerInfo: Found " + packageName);
+ }
+ return info;
+ }
+ }
+ if (DEBUG) {
+ Log.w(TAG, "getMediaPlayerInfo: " + packageName + " not found");
+ }
+ return null;
+ }
+ }
+ }
+
+ /* prepare media list & return the media player list response object */
+ private MediaPlayerListRsp prepareMediaPlayerRspObj() {
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ // TODO(apanicke): This hack will go away as soon as a developer
+ // option to enable or disable player selection is created. Right
+ // now this is needed to fix BMW i3 carkits and any other carkits
+ // that might try to connect to a player that isnt the current
+ // player based on this list
+ int numPlayers = 1;
+
+ int[] playerIds = new int[numPlayers];
+ byte[] playerTypes = new byte[numPlayers];
+ int[] playerSubTypes = new int[numPlayers];
+ String[] displayableNameArray = new String[numPlayers];
+ byte[] playStatusValues = new byte[numPlayers];
+ short[] featureBitMaskValues =
+ new short[numPlayers * AvrcpConstants.AVRC_FEATURE_MASK_SIZE];
+
+ // Reserve the first spot for the currently addressed player if
+ // we have one
+ int players = mMediaPlayerInfoList.containsKey(mCurrAddrPlayerID) ? 1 : 0;
+ for (Map.Entry<Integer, MediaPlayerInfo> entry : mMediaPlayerInfoList.entrySet()) {
+ int idx = players;
+ if (entry.getKey() == mCurrAddrPlayerID) {
+ idx = 0;
+ } else {
+ continue; // TODO(apanicke): Remove, see above note
+ }
+ MediaPlayerInfo info = entry.getValue();
+ playerIds[idx] = entry.getKey();
+ playerTypes[idx] = info.getMajorType();
+ playerSubTypes[idx] = info.getSubType();
+ displayableNameArray[idx] = info.getDisplayableName();
+ playStatusValues[idx] = info.getPlayStatus();
+
+ short[] featureBits = info.getFeatureBitMask();
+ for (int numBit = 0; numBit < featureBits.length; numBit++) {
+ /* gives which octet this belongs to */
+ byte octet = (byte) (featureBits[numBit] / 8);
+ /* gives the bit position within the octet */
+ byte bit = (byte) (featureBits[numBit] % 8);
+ featureBitMaskValues[(idx * AvrcpConstants.AVRC_FEATURE_MASK_SIZE) + octet]
+ |= (1 << bit);
+ }
+
+ /* printLogs */
+ if (DEBUG) {
+ Log.d(TAG, "Player " + playerIds[idx] + ": " + displayableNameArray[idx]
+ + " type: " + playerTypes[idx] + ", " + playerSubTypes[idx]
+ + " status: " + playStatusValues[idx]);
+ }
+
+ if (idx != 0) {
+ players++;
+ }
+ }
+
+ if (DEBUG) {
+ Log.d(TAG, "prepareMediaPlayerRspObj: numPlayers = " + numPlayers);
+ }
+
+ return new MediaPlayerListRsp(AvrcpConstants.RSP_NO_ERROR, sUIDCounter, numPlayers,
+ AvrcpConstants.BTRC_ITEM_PLAYER, playerIds, playerTypes, playerSubTypes,
+ playStatusValues, featureBitMaskValues, displayableNameArray);
+ }
+ }
+ }
+
+ /* build media player list and send it to remote. */
+ private void handleMediaPlayerListRsp(AvrcpCmd.FolderItemsCmd folderObj) {
+ MediaPlayerListRsp rspObj = null;
+ synchronized (this) {
+ synchronized (mMediaPlayerInfoList) {
+ int numPlayers = mMediaPlayerInfoList.size();
+ if (numPlayers == 0) {
+ mediaPlayerListRspNative(folderObj.mAddress, AvrcpConstants.RSP_NO_AVBL_PLAY,
+ (short) 0, (byte) 0, 0, null, null, null, null, null, null);
+ return;
+ }
+ if (folderObj.mStartItem >= numPlayers || folderObj.mStartItem >= 1) {
+ Log.i(TAG, "handleMediaPlayerListRsp: start = " + folderObj.mStartItem
+ + " > num of items = " + numPlayers);
+ mediaPlayerListRspNative(folderObj.mAddress, AvrcpConstants.RSP_INV_RANGE,
+ (short) 0, (byte) 0, 0, null, null, null, null, null, null);
+ return;
+ }
+ if (mCurrAddrPlayerID == NO_PLAYER_ID) {
+ short[] featureBitsArray = {0x00, 0x00, 0x00, 0x00, 0x00, 0xb7, 0x01, 0x04,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+ Log.i(TAG, "handleMediaPlayerListRsp: Send dummy player response");
+ mediaPlayerListRspNative(folderObj.mAddress, (int)AvrcpConstants.RSP_NO_ERROR,
+ (int)sUIDCounter, AvrcpConstants.BTRC_ITEM_PLAYER, 1, new int[] {0},
+ new byte[] {AvrcpConstants.PLAYER_TYPE_AUDIO}, new int[] {1},
+ new byte[] {PLAYSTATUS_STOPPED}, featureBitsArray,
+ new String[] {"Dummy Player"});
+ return;
+ }
+ rspObj = prepareMediaPlayerRspObj();
+ }
+ }
+ if (DEBUG) {
+ Log.d(TAG, "handleMediaPlayerListRsp: sending " + rspObj.mNumItems + " players");
+ }
+ mediaPlayerListRspNative(folderObj.mAddress, rspObj.mStatus, rspObj.mUIDCounter,
+ rspObj.mItemType, rspObj.mNumItems, rspObj.mPlayerIds, rspObj.mPlayerTypes,
+ rspObj.mPlayerSubTypes, rspObj.mPlayStatusValues, rspObj.mFeatureBitMaskValues,
+ rspObj.mPlayerNameList);
+ }
+
+ /* unregister to the old controller, update new IDs and register to the new controller */
+ private boolean updateCurrentController(int addrId, int browseId) {
+ boolean registerRsp = true;
+ int preAddrId = mCurrAddrPlayerID;
+ int preBrowseId = mCurrBrowsePlayerID;
+
+ updateNewIds(addrId, browseId);
+
+ MediaController newController = null;
+ MediaPlayerInfo info = getAddressedPlayerInfo();
+ if (info != null) {
+ newController = info.getMediaController();
+ }
+
+ if (DEBUG) {
+ Log.d(TAG, "updateCurrentController: " + mMediaController + " to " + newController);
+ }
+ synchronized (this) {
+ if (mMediaController == null || (!mMediaController.equals(newController))) {
+ if (mMediaController != null) {
+ mMediaController.unregisterCallback(mMediaControllerCb);
+ }
+ mMediaController = newController;
+ if (mMediaController != null) {
+ mMediaController.registerCallback(mMediaControllerCb, mHandler);
+ } else {
+ registerRsp = false;
+ updateNewIds(preAddrId, preBrowseId);
+ }
+ }
+ }
+ updateCurrentMediaState();
+ return registerRsp;
+ }
+
+ /* Handle getfolderitems for scope = VFS, Search, NowPlayingList */
+ private void handleGetFolderItemBrowseResponse(AvrcpCmd.FolderItemsCmd folderObj,
+ byte[] bdaddr) {
+ int status = AvrcpConstants.RSP_NO_ERROR;
+
+ /* Browsed player is already set */
+ if (folderObj.mScope == AvrcpConstants.BTRC_SCOPE_FILE_SYSTEM) {
+ if (mAvrcpBrowseManager.getBrowsedMediaPlayer(bdaddr) == null) {
+ Log.e(TAG, "handleGetFolderItemBrowseResponse: no browsed player set for "
+ + Utils.getAddressStringFromByte(bdaddr));
+ getFolderItemsRspNative(bdaddr, AvrcpConstants.RSP_INTERNAL_ERR, (short) 0,
+ (byte) 0x00, 0, null, null, null, null, null, null, null, null);
+ return;
+ }
+ mAvrcpBrowseManager.getBrowsedMediaPlayer(bdaddr).getFolderItemsVFS(folderObj);
+ return;
+ }
+ if (folderObj.mScope == AvrcpConstants.BTRC_SCOPE_NOW_PLAYING) {
+ mAddressedMediaPlayer.getFolderItemsNowPlaying(bdaddr, folderObj, mMediaController);
+ return;
+ }
+
+ /* invalid scope */
+ Log.e(TAG, "handleGetFolderItemBrowseResponse: unknown scope " + folderObj.mScope);
+ getFolderItemsRspNative(bdaddr, AvrcpConstants.RSP_INV_SCOPE, (short) 0, (byte) 0x00, 0,
+ null, null, null, null, null, null, null, null);
+ }
+
+ /* utility function to update the global values of current Addressed and browsed player */
+ private void updateNewIds(int addrId, int browseId) {
+ if (DEBUG) {
+ Log.v(TAG,
+ "updateNewIds: Addressed:" + mCurrAddrPlayerID + " to " + addrId + ", Browse:"
+ + mCurrBrowsePlayerID + " to " + browseId);
+ }
+ mCurrAddrPlayerID = addrId;
+ mCurrBrowsePlayerID = browseId;
+ }
+
+ /* Getting the application's displayable name from package name */
+ private String getAppLabel(String packageName) {
+ ApplicationInfo appInfo = null;
+ try {
+ appInfo = mPackageManager.getApplicationInfo(packageName, 0);
+ } catch (NameNotFoundException e) {
+ e.printStackTrace();
+ }
+
+ return (String) (appInfo != null ? mPackageManager.getApplicationLabel(appInfo)
+ : "Unknown");
+ }
+
+ private void handlePlayItemResponse(byte[] bdaddr, byte[] uid, byte scope) {
+ HeadsetService mService = HeadsetService.getHeadsetService();
+ if ((mService != null) && mService.isScoOrCallActive()) {
+ Log.w(TAG, "Remote requesting play item while call is active");
+ playItemRspNative(bdaddr, AvrcpConstants.RSP_MEDIA_IN_USE);
+ return;
+ }
+
+ if (scope == AvrcpConstants.BTRC_SCOPE_NOW_PLAYING) {
+ mAddressedMediaPlayer.playItem(bdaddr, uid, mMediaController);
+ } else {
+ if (!isAddrPlayerSameAsBrowsed(bdaddr)) {
+ Log.w(TAG, "Remote requesting play item on uid which may not be recognized by"
+ + "current addressed player");
+ playItemRspNative(bdaddr, AvrcpConstants.RSP_INV_ITEM);
+ }
+
+ if (mAvrcpBrowseManager.getBrowsedMediaPlayer(bdaddr) != null) {
+ mAvrcpBrowseManager.getBrowsedMediaPlayer(bdaddr).playItem(uid, scope);
+ } else {
+ Log.e(TAG, "handlePlayItemResponse: Remote requested playitem "
+ + "before setbrowsedplayer");
+ playItemRspNative(bdaddr, AvrcpConstants.RSP_INTERNAL_ERR);
+ }
+ }
+ }
+
+ private void handleGetItemAttr(AvrcpCmd.ItemAttrCmd itemAttr) {
+ if (itemAttr.mUidCounter != sUIDCounter) {
+ itemAttr.mUidCounter = sUIDCounter;
+ Log.e(TAG, "handleGetItemAttr: invalid uid counter, assign new value = "
+ + itemAttr.mUidCounter);
+ }
+ if (itemAttr.mScope == AvrcpConstants.BTRC_SCOPE_NOW_PLAYING) {
+ if (mCurrAddrPlayerID == NO_PLAYER_ID) {
+ getItemAttrRspNative(itemAttr.mAddress, AvrcpConstants.RSP_NO_AVBL_PLAY, (byte) 0,
+ null, null);
+ return;
+ }
+ mAddressedMediaPlayer.getItemAttr(itemAttr.mAddress, itemAttr, mMediaController);
+ return;
+ }
+ // All other scopes use browsed player
+ if (mAvrcpBrowseManager.getBrowsedMediaPlayer(itemAttr.mAddress) != null) {
+ mAvrcpBrowseManager.getBrowsedMediaPlayer(itemAttr.mAddress).getItemAttr(itemAttr);
+ } else {
+ Log.e(TAG, "Could not get attributes. mBrowsedMediaPlayer is null");
+ getItemAttrRspNative(itemAttr.mAddress, AvrcpConstants.RSP_INTERNAL_ERR, (byte) 0, null,
+ null);
+ }
+ }
+
+ private void handleGetTotalNumOfItemsResponse(byte[] bdaddr, byte scope) {
+ // for scope as media player list
+ if (scope == AvrcpConstants.BTRC_SCOPE_PLAYER_LIST) {
+ int numPlayers = 0;
+ synchronized(this) {
+ synchronized (mMediaPlayerInfoList) {
+ numPlayers = mMediaPlayerInfoList.containsKey(mCurrAddrPlayerID) ? 1 : 0;
+ }
+ }
+ if (DEBUG) {
+ Log.d(TAG, "handleGetTotalNumOfItemsResponse: " + numPlayers + " players.");
+ }
+ getTotalNumOfItemsRspNative(bdaddr, AvrcpConstants.RSP_NO_ERROR, 0, numPlayers);
+ } else if (scope == AvrcpConstants.BTRC_SCOPE_NOW_PLAYING) {
+ mAddressedMediaPlayer.getTotalNumOfItems(bdaddr, mMediaController);
+ } else {
+ // for FileSystem browsing scopes as VFS, Now Playing
+ if (mAvrcpBrowseManager.getBrowsedMediaPlayer(bdaddr) != null) {
+ mAvrcpBrowseManager.getBrowsedMediaPlayer(bdaddr).getTotalNumOfItems(scope);
+ } else {
+ Log.e(TAG, "Could not get Total NumOfItems. mBrowsedMediaPlayer is null");
+ getTotalNumOfItemsRspNative(bdaddr, AvrcpConstants.RSP_INTERNAL_ERR, 0, 0);
+ }
+ }
+
+ }
+
+ /* check if browsed player and addressed player are same */
+ private boolean isAddrPlayerSameAsBrowsed(byte[] bdaddr) {
+ String browsedPlayer = getCurrentBrowsedPlayer(bdaddr);
+
+ if (!isPackageNameValid(browsedPlayer)) {
+ Log.w(TAG, "Browsed player name empty");
+ return false;
+ }
+
+ MediaPlayerInfo info = getAddressedPlayerInfo();
+ String packageName = (info == null) ? "<none>" : info.getPackageName();
+ if (info == null || !packageName.equals(browsedPlayer)) {
+ if (DEBUG) {
+ Log.d(TAG, browsedPlayer + " is not addressed player " + packageName);
+ }
+ return false;
+ }
+ return true;
+ }
+
+ /* checks if package name is not null or empty */
+ private boolean isPackageNameValid(String browsedPackage) {
+ boolean isValid = (browsedPackage != null && browsedPackage.length() > 0);
+ if (DEBUG) {
+ Log.d(TAG, "isPackageNameValid: browsedPackage = " + browsedPackage + "isValid = "
+ + isValid);
+ }
+ return isValid;
+ }
+
+ /* checks if selected addressed player is already addressed */
+ private boolean isPlayerAlreadyAddressed(int selectedId) {
+ // checking if selected ID is same as the current addressed player id
+ boolean isAddressed = (mCurrAddrPlayerID == selectedId);
+ if (DEBUG) {
+ Log.d(TAG, "isPlayerAlreadyAddressed: isAddressed = " + isAddressed);
+ }
+ return isAddressed;
+ }
+
+ public void dump(StringBuilder sb) {
+ sb.append("AVRCP:\n");
+ ProfileService.println(sb, "mMediaAttributes: " + mMediaAttributes.toRedactedString());
+ ProfileService.println(sb, "mTransportControlFlags: " + mTransportControlFlags);
+ ProfileService.println(sb, "mCurrentPlayState: " + mCurrentPlayState);
+ ProfileService.println(sb, "mPlayStatusChangedNT: " + mPlayStatusChangedNT);
+ ProfileService.println(sb, "mTrackChangedNT: " + mTrackChangedNT);
+ ProfileService.println(sb, "mPlaybackIntervalMs: " + mPlaybackIntervalMs);
+ ProfileService.println(sb, "mPlayPosChangedNT: " + mPlayPosChangedNT);
+ ProfileService.println(sb, "mNextPosMs: " + mNextPosMs);
+ ProfileService.println(sb, "mPrevPosMs: " + mPrevPosMs);
+ ProfileService.println(sb, "mFeatures: " + mFeatures);
+ ProfileService.println(sb, "mRemoteVolume: " + mRemoteVolume);
+ ProfileService.println(sb, "mLastRemoteVolume: " + mLastRemoteVolume);
+ ProfileService.println(sb, "mLastDirection: " + mLastDirection);
+ ProfileService.println(sb, "mVolumeStep: " + mVolumeStep);
+ ProfileService.println(sb, "mAudioStreamMax: " + mAudioStreamMax);
+ ProfileService.println(sb, "mVolCmdSetInProgress: " + mVolCmdSetInProgress);
+ ProfileService.println(sb, "mAbsVolRetryTimes: " + mAbsVolRetryTimes);
+ ProfileService.println(sb, "mVolumeMapping: " + mVolumeMapping.toString());
+ synchronized (this) {
+ if (mMediaController != null) {
+ ProfileService.println(sb,
+ "mMediaController: " + mMediaController.getWrappedInstance() + " pkg "
+ + mMediaController.getPackageName());
+ }
+ }
+ ProfileService.println(sb, "");
+ ProfileService.println(sb, "Media Players:");
+ synchronized(this) {
+ synchronized (mMediaPlayerInfoList) {
+ for (Map.Entry<Integer, MediaPlayerInfo> entry : mMediaPlayerInfoList.entrySet()) {
+ int key = entry.getKey();
+ ProfileService.println(sb,
+ ((mCurrAddrPlayerID == key) ? " *#" : " #") + entry.getKey() + ": "
+ + entry.getValue());
+ }
+ }
+ }
+
+ ProfileService.println(sb, "");
+ mAddressedMediaPlayer.dump(sb, mMediaController);
+
+ ProfileService.println(sb, "");
+ ProfileService.println(sb, mPassthroughDispatched + " passthrough operations: ");
+ if (mPassthroughDispatched > mPassthroughLogs.size()) {
+ ProfileService.println(sb, " (last " + mPassthroughLogs.size() + ")");
+ }
+ synchronized (mPassthroughLogs) {
+ for (MediaKeyLog log : mPassthroughLogs) {
+ ProfileService.println(sb, " " + log);
+ }
+ }
+ synchronized (mPassthroughPending) {
+ for (MediaKeyLog log : mPassthroughPending) {
+ ProfileService.println(sb, " " + log);
+ }
+ }
+
+ // Print the blacklisted devices (for absolute volume control)
+ SharedPreferences pref =
+ mContext.getSharedPreferences(ABSOLUTE_VOLUME_BLACKLIST, Context.MODE_PRIVATE);
+ Map<String, ?> allKeys = pref.getAll();
+ ProfileService.println(sb, "");
+ ProfileService.println(sb, "Runtime Blacklisted Devices (absolute volume):");
+ if (allKeys.isEmpty()) {
+ ProfileService.println(sb, " None");
+ } else {
+ for (Map.Entry<String, ?> entry : allKeys.entrySet()) {
+ String key = entry.getKey();
+ Object value = entry.getValue();
+ if (value instanceof String) {
+ ProfileService.println(sb, " " + key + " " + value);
+ } else {
+ ProfileService.println(sb, " " + key + " Reason: Unknown");
+ }
+ }
+ }
+ }
+
+ public class AvrcpBrowseManager {
+ public Map<String, BrowsedMediaPlayer> connList = new HashMap<String, BrowsedMediaPlayer>();
+ private AvrcpMediaRspInterface mMediaInterface;
+ private Context mContext;
+
+ public AvrcpBrowseManager(Context context, AvrcpMediaRspInterface mediaInterface) {
+ mContext = context;
+ mMediaInterface = mediaInterface;
+ }
+
+ public void cleanup() {
+ Iterator entries = connList.entrySet().iterator();
+ while (entries.hasNext()) {
+ Map.Entry entry = (Map.Entry) entries.next();
+ BrowsedMediaPlayer browsedMediaPlayer = (BrowsedMediaPlayer) entry.getValue();
+ if (browsedMediaPlayer != null) {
+ browsedMediaPlayer.cleanup();
+ }
+ }
+ // clean up the map
+ connList.clear();
+ }
+
+ // get the a free media player interface based on the passed bd address
+ // if the no items is found for the passed media player then it assignes a
+ // available media player interface
+ public BrowsedMediaPlayer getBrowsedMediaPlayer(byte[] bdaddr) {
+ BrowsedMediaPlayer mediaPlayer;
+ String bdaddrStr = new String(bdaddr);
+ if (connList.containsKey(bdaddrStr)) {
+ mediaPlayer = connList.get(bdaddrStr);
+ } else {
+ mediaPlayer = new BrowsedMediaPlayer(bdaddr, mContext, mMediaInterface);
+ connList.put(bdaddrStr, mediaPlayer);
+ }
+ return mediaPlayer;
+ }
+
+ // clears the details pertaining to passed bdaddres
+ public boolean clearBrowsedMediaPlayer(byte[] bdaddr) {
+ String bdaddrStr = new String(bdaddr);
+ if (connList.containsKey(bdaddrStr)) {
+ connList.remove(bdaddrStr);
+ return true;
+ }
+ return false;
+ }
+
+ public Map<String, BrowsedMediaPlayer> getConnList() {
+ return connList;
+ }
+
+ /* Helper function to convert colon separated bdaddr to byte string */
+ private byte[] hexStringToByteArray(String s) {
+ int len = s.length();
+ byte[] data = new byte[len / 2];
+ for (int i = 0; i < len; i += 2) {
+ data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(
+ s.charAt(i + 1), 16));
+ }
+ return data;
+ }
+ }
+
+ /*
+ * private class which handles responses from AvrcpMediaManager. Maps responses to native
+ * responses. This class implements the AvrcpMediaRspInterface interface.
+ */
+ private class AvrcpMediaRsp implements AvrcpMediaRspInterface {
+ private static final String TAG = "AvrcpMediaRsp";
+
+ @Override
+ public void setAddrPlayerRsp(byte[] address, int rspStatus) {
+ if (!setAddressedPlayerRspNative(address, rspStatus)) {
+ Log.e(TAG, "setAddrPlayerRsp failed!");
+ }
+ }
+
+ @Override
+ public void setBrowsedPlayerRsp(byte[] address, int rspStatus, byte depth, int numItems,
+ String[] textArray) {
+ if (!setBrowsedPlayerRspNative(address, rspStatus, depth, numItems, textArray)) {
+ Log.e(TAG, "setBrowsedPlayerRsp failed!");
+ }
+ }
+
+ @Override
+ public void mediaPlayerListRsp(byte[] address, int rspStatus, MediaPlayerListRsp rspObj) {
+ if (rspObj != null && rspStatus == AvrcpConstants.RSP_NO_ERROR) {
+ if (!mediaPlayerListRspNative(address, rspStatus, sUIDCounter, rspObj.mItemType,
+ rspObj.mNumItems, rspObj.mPlayerIds, rspObj.mPlayerTypes,
+ rspObj.mPlayerSubTypes, rspObj.mPlayStatusValues,
+ rspObj.mFeatureBitMaskValues, rspObj.mPlayerNameList)) {
+ Log.e(TAG, "mediaPlayerListRsp failed!");
+ }
+ } else {
+ Log.e(TAG, "mediaPlayerListRsp: rspObj is null");
+ if (!mediaPlayerListRspNative(address, rspStatus, sUIDCounter, (byte) 0x00, 0, null,
+ null, null, null, null, null)) {
+ Log.e(TAG, "mediaPlayerListRsp failed!");
+ }
+ }
+ }
+
+ @Override
+ public void folderItemsRsp(byte[] address, int rspStatus, FolderItemsRsp rspObj) {
+ if (rspObj != null && rspStatus == AvrcpConstants.RSP_NO_ERROR) {
+ if (!getFolderItemsRspNative(address, rspStatus, sUIDCounter, rspObj.mScope,
+ rspObj.mNumItems, rspObj.mFolderTypes, rspObj.mPlayable, rspObj.mItemTypes,
+ rspObj.mItemUid, rspObj.mDisplayNames, rspObj.mAttributesNum,
+ rspObj.mAttrIds, rspObj.mAttrValues)) {
+ Log.e(TAG, "getFolderItemsRspNative failed!");
+ }
+ } else {
+ Log.e(TAG, "folderItemsRsp: rspObj is null or rspStatus is error:" + rspStatus);
+ if (!getFolderItemsRspNative(address, rspStatus, sUIDCounter, (byte) 0x00, 0, null,
+ null, null, null, null, null, null, null)) {
+ Log.e(TAG, "getFolderItemsRspNative failed!");
+ }
+ }
+
+ }
+
+ @Override
+ public void changePathRsp(byte[] address, int rspStatus, int numItems) {
+ if (!changePathRspNative(address, rspStatus, numItems)) {
+ Log.e(TAG, "changePathRspNative failed!");
+ }
+ }
+
+ @Override
+ public void getItemAttrRsp(byte[] address, int rspStatus, ItemAttrRsp rspObj) {
+ if (rspObj != null && rspStatus == AvrcpConstants.RSP_NO_ERROR) {
+ if (!getItemAttrRspNative(address, rspStatus, rspObj.mNumAttr,
+ rspObj.mAttributesIds, rspObj.mAttributesArray)) {
+ Log.e(TAG, "getItemAttrRspNative failed!");
+ }
+ } else {
+ Log.e(TAG, "getItemAttrRsp: rspObj is null or rspStatus is error:" + rspStatus);
+ if (!getItemAttrRspNative(address, rspStatus, (byte) 0x00, null, null)) {
+ Log.e(TAG, "getItemAttrRspNative failed!");
+ }
+ }
+ }
+
+ @Override
+ public void playItemRsp(byte[] address, int rspStatus) {
+ if (!playItemRspNative(address, rspStatus)) {
+ Log.e(TAG, "playItemRspNative failed!");
+ }
+ }
+
+ @Override
+ public void getTotalNumOfItemsRsp(byte[] address, int rspStatus, int uidCounter,
+ int numItems) {
+ if (!getTotalNumOfItemsRspNative(address, rspStatus, sUIDCounter, numItems)) {
+ Log.e(TAG, "getTotalNumOfItemsRspNative failed!");
+ }
+ }
+
+ @Override
+ public void addrPlayerChangedRsp(int type, int playerId, int uidCounter) {
+ if (!registerNotificationRspAddrPlayerChangedNative(type, playerId, sUIDCounter)) {
+ Log.e(TAG, "registerNotificationRspAddrPlayerChangedNative failed!");
+ }
+ }
+
+ @Override
+ public void avalPlayerChangedRsp(byte[] address, int type) {
+ if (!registerNotificationRspAvalPlayerChangedNative(type)) {
+ Log.e(TAG, "registerNotificationRspAvalPlayerChangedNative failed!");
+ }
+ }
+
+ @Override
+ public void uidsChangedRsp(int type) {
+ if (!registerNotificationRspUIDsChangedNative(type, sUIDCounter)) {
+ Log.e(TAG, "registerNotificationRspUIDsChangedNative failed!");
+ }
+ }
+
+ @Override
+ public void nowPlayingChangedRsp(int type) {
+ if (mNowPlayingListChangedNT != AvrcpConstants.NOTIFICATION_TYPE_INTERIM) {
+ if (DEBUG) {
+ Log.d(TAG, "NowPlayingListChanged: Not registered or requesting.");
+ }
+ return;
+ }
+
+ if (!registerNotificationRspNowPlayingChangedNative(type)) {
+ Log.e(TAG, "registerNotificationRspNowPlayingChangedNative failed!");
+ }
+ mNowPlayingListChangedNT = AvrcpConstants.NOTIFICATION_TYPE_CHANGED;
+ }
+
+ @Override
+ public void trackChangedRsp(int type, byte[] uid) {
+ if (!registerNotificationRspTrackChangeNative(type, uid)) {
+ Log.e(TAG, "registerNotificationRspTrackChangeNative failed!");
+ }
+ }
+ }
+
+ /* getters for some private variables */
+ public AvrcpBrowseManager getAvrcpBrowseManager() {
+ return mAvrcpBrowseManager;
+ }
+
+ /* PASSTHROUGH COMMAND MANAGEMENT */
+
+ void handlePassthroughCmd(int op, int state) {
+ int code = avrcpPassthroughToKeyCode(op);
+ if (code == KeyEvent.KEYCODE_UNKNOWN) {
+ Log.w(TAG, "Ignoring passthrough of unknown key " + op + " state " + state);
+ return;
+ }
+ int action = KeyEvent.ACTION_DOWN;
+ if (state == AvrcpConstants.KEY_STATE_RELEASE) {
+ action = KeyEvent.ACTION_UP;
+ }
+
+ if (mLastPassthroughcmd == KeyEvent.KEYCODE_UNKNOWN) {
+ if (isPlayingState(mCurrentPlayState) && mAudioManager.isMusicActive() &&
+ (mA2dpState == BluetoothA2dp.STATE_PLAYING) &&
+ (code == KeyEvent.KEYCODE_MEDIA_PLAY)) {
+ Log.w(TAG, "Ignoring passthrough command play" + op + " state " + state +
+ "in music playing");
+ return;
+ }
+ if (!isPlayingState(mCurrentPlayState) && (!mAudioManager.isMusicActive())
+ && (mA2dpState == BluetoothA2dp.STATE_NOT_PLAYING) &&
+ (code == KeyEvent.KEYCODE_MEDIA_PAUSE)) {
+ Log.w(TAG, "Ignoring passthrough command pause" + op + " state " + state +
+ "in music playing");
+ return;
+ }
+ }
+
+ KeyEvent event = new KeyEvent(action, code);
+ if (!KeyEvent.isMediaSessionKey(code)) {
+ Log.w(TAG, "Passthrough non-media key " + op + " (code " + code + ") state " + state);
+ } else {
+ if (code == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD) {
+ if (action == KeyEvent.ACTION_DOWN) {
+ mFastforward = true;
+ } else {
+ mFastforward = false;
+ }
+ } else if (code == KeyEvent.KEYCODE_MEDIA_REWIND) {
+ if (action == KeyEvent.ACTION_DOWN) {
+ mRewind = true;
+ } else {
+ mRewind = false;
+ }
+ } else {
+ mRewind = false;
+ mFastforward = false;
+ }
+ }
+ /* IOT Fix as some remote recognise FF/Rewind state as non-playing hence send
+ * changed response at the time of Release of Fast-Forward/Rewind Button */
+ if ((code == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD || code == KeyEvent.KEYCODE_MEDIA_REWIND)
+ && (mPlayStatusChangedNT == AvrcpConstants.NOTIFICATION_TYPE_INTERIM)
+ && (action == KeyEvent.ACTION_UP)) {
+ sendPlaybackStatus(AvrcpConstants.NOTIFICATION_TYPE_CHANGED, mReportedPlayStatus);
+ Log.d(TAG, "Sending playback status CHANGED rsp on FF/Rewind key release");
+ mLastPassthroughcmd = KeyEvent.KEYCODE_UNKNOWN;
+ }
+
+ Log.d(TAG, "cached passthrough: " + mLastPassthroughcmd + "current passthrough: " + code);
+ if ((mLastPassthroughcmd != KeyEvent.KEYCODE_UNKNOWN) && (mLastPassthroughcmd != code)) {
+ mLastPassthroughcmd = KeyEvent.KEYCODE_UNKNOWN;
+ } else {
+ mLastPassthroughcmd = code;
+ }
+
+ mMediaSessionManager.dispatchMediaKeyEvent(event);
+ addKeyPending(event);
+ }
+
+ private int avrcpPassthroughToKeyCode(int operation) {
+ switch (operation) {
+ case BluetoothAvrcp.PASSTHROUGH_ID_UP:
+ return KeyEvent.KEYCODE_DPAD_UP;
+ case BluetoothAvrcp.PASSTHROUGH_ID_DOWN:
+ return KeyEvent.KEYCODE_DPAD_DOWN;
+ case BluetoothAvrcp.PASSTHROUGH_ID_LEFT:
+ return KeyEvent.KEYCODE_DPAD_LEFT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_RIGHT:
+ return KeyEvent.KEYCODE_DPAD_RIGHT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_RIGHT_UP:
+ return KeyEvent.KEYCODE_DPAD_UP_RIGHT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_RIGHT_DOWN:
+ return KeyEvent.KEYCODE_DPAD_DOWN_RIGHT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_LEFT_UP:
+ return KeyEvent.KEYCODE_DPAD_UP_LEFT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_LEFT_DOWN:
+ return KeyEvent.KEYCODE_DPAD_DOWN_LEFT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_0:
+ return KeyEvent.KEYCODE_NUMPAD_0;
+ case BluetoothAvrcp.PASSTHROUGH_ID_1:
+ return KeyEvent.KEYCODE_NUMPAD_1;
+ case BluetoothAvrcp.PASSTHROUGH_ID_2:
+ return KeyEvent.KEYCODE_NUMPAD_2;
+ case BluetoothAvrcp.PASSTHROUGH_ID_3:
+ return KeyEvent.KEYCODE_NUMPAD_3;
+ case BluetoothAvrcp.PASSTHROUGH_ID_4:
+ return KeyEvent.KEYCODE_NUMPAD_4;
+ case BluetoothAvrcp.PASSTHROUGH_ID_5:
+ return KeyEvent.KEYCODE_NUMPAD_5;
+ case BluetoothAvrcp.PASSTHROUGH_ID_6:
+ return KeyEvent.KEYCODE_NUMPAD_6;
+ case BluetoothAvrcp.PASSTHROUGH_ID_7:
+ return KeyEvent.KEYCODE_NUMPAD_7;
+ case BluetoothAvrcp.PASSTHROUGH_ID_8:
+ return KeyEvent.KEYCODE_NUMPAD_8;
+ case BluetoothAvrcp.PASSTHROUGH_ID_9:
+ return KeyEvent.KEYCODE_NUMPAD_9;
+ case BluetoothAvrcp.PASSTHROUGH_ID_DOT:
+ return KeyEvent.KEYCODE_NUMPAD_DOT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_ENTER:
+ return KeyEvent.KEYCODE_NUMPAD_ENTER;
+ case BluetoothAvrcp.PASSTHROUGH_ID_CLEAR:
+ return KeyEvent.KEYCODE_CLEAR;
+ case BluetoothAvrcp.PASSTHROUGH_ID_CHAN_UP:
+ return KeyEvent.KEYCODE_CHANNEL_UP;
+ case BluetoothAvrcp.PASSTHROUGH_ID_CHAN_DOWN:
+ return KeyEvent.KEYCODE_CHANNEL_DOWN;
+ case BluetoothAvrcp.PASSTHROUGH_ID_PREV_CHAN:
+ return KeyEvent.KEYCODE_LAST_CHANNEL;
+ case BluetoothAvrcp.PASSTHROUGH_ID_INPUT_SEL:
+ return KeyEvent.KEYCODE_TV_INPUT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_DISP_INFO:
+ return KeyEvent.KEYCODE_INFO;
+ case BluetoothAvrcp.PASSTHROUGH_ID_HELP:
+ return KeyEvent.KEYCODE_HELP;
+ case BluetoothAvrcp.PASSTHROUGH_ID_PAGE_UP:
+ return KeyEvent.KEYCODE_PAGE_UP;
+ case BluetoothAvrcp.PASSTHROUGH_ID_PAGE_DOWN:
+ return KeyEvent.KEYCODE_PAGE_DOWN;
+ case BluetoothAvrcp.PASSTHROUGH_ID_POWER:
+ return KeyEvent.KEYCODE_POWER;
+ case BluetoothAvrcp.PASSTHROUGH_ID_VOL_UP:
+ return KeyEvent.KEYCODE_VOLUME_UP;
+ case BluetoothAvrcp.PASSTHROUGH_ID_VOL_DOWN:
+ return KeyEvent.KEYCODE_VOLUME_DOWN;
+ case BluetoothAvrcp.PASSTHROUGH_ID_MUTE:
+ return KeyEvent.KEYCODE_MUTE;
+ case BluetoothAvrcp.PASSTHROUGH_ID_PLAY:
+ return KeyEvent.KEYCODE_MEDIA_PLAY;
+ case BluetoothAvrcp.PASSTHROUGH_ID_STOP:
+ return KeyEvent.KEYCODE_MEDIA_STOP;
+ case BluetoothAvrcp.PASSTHROUGH_ID_PAUSE:
+ return KeyEvent.KEYCODE_MEDIA_PAUSE;
+ case BluetoothAvrcp.PASSTHROUGH_ID_RECORD:
+ return KeyEvent.KEYCODE_MEDIA_RECORD;
+ case BluetoothAvrcp.PASSTHROUGH_ID_REWIND:
+ return KeyEvent.KEYCODE_MEDIA_REWIND;
+ case BluetoothAvrcp.PASSTHROUGH_ID_FAST_FOR:
+ return KeyEvent.KEYCODE_MEDIA_FAST_FORWARD;
+ case BluetoothAvrcp.PASSTHROUGH_ID_EJECT:
+ return KeyEvent.KEYCODE_MEDIA_EJECT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_FORWARD:
+ return KeyEvent.KEYCODE_MEDIA_NEXT;
+ case BluetoothAvrcp.PASSTHROUGH_ID_BACKWARD:
+ return KeyEvent.KEYCODE_MEDIA_PREVIOUS;
+ case BluetoothAvrcp.PASSTHROUGH_ID_F1:
+ return KeyEvent.KEYCODE_F1;
+ case BluetoothAvrcp.PASSTHROUGH_ID_F2:
+ return KeyEvent.KEYCODE_F2;
+ case BluetoothAvrcp.PASSTHROUGH_ID_F3:
+ return KeyEvent.KEYCODE_F3;
+ case BluetoothAvrcp.PASSTHROUGH_ID_F4:
+ return KeyEvent.KEYCODE_F4;
+ case BluetoothAvrcp.PASSTHROUGH_ID_F5:
+ return KeyEvent.KEYCODE_F5;
+ // Fallthrough for all unknown key mappings
+ case BluetoothAvrcp.PASSTHROUGH_ID_SELECT:
+ case BluetoothAvrcp.PASSTHROUGH_ID_ROOT_MENU:
+ case BluetoothAvrcp.PASSTHROUGH_ID_SETUP_MENU:
+ case BluetoothAvrcp.PASSTHROUGH_ID_CONT_MENU:
+ case BluetoothAvrcp.PASSTHROUGH_ID_FAV_MENU:
+ case BluetoothAvrcp.PASSTHROUGH_ID_EXIT:
+ case BluetoothAvrcp.PASSTHROUGH_ID_SOUND_SEL:
+ case BluetoothAvrcp.PASSTHROUGH_ID_ANGLE:
+ case BluetoothAvrcp.PASSTHROUGH_ID_SUBPICT:
+ case BluetoothAvrcp.PASSTHROUGH_ID_VENDOR:
+ default:
+ return KeyEvent.KEYCODE_UNKNOWN;
+ }
+ }
+
+ private void addKeyPending(KeyEvent event) {
+ mPassthroughPending.add(new MediaKeyLog(System.currentTimeMillis(), event));
+ }
+
+ private void recordKeyDispatched(KeyEvent event, String packageName) {
+ long time = System.currentTimeMillis();
+ Log.v(TAG, "recordKeyDispatched: " + event + " dispatched to " + packageName);
+ setAddressedMediaSessionPackage(packageName);
+ synchronized (mPassthroughPending) {
+ Iterator<MediaKeyLog> pending = mPassthroughPending.iterator();
+ while (pending.hasNext()) {
+ MediaKeyLog log = pending.next();
+ if (log.addDispatch(time, event, packageName)) {
+ mPassthroughDispatched++;
+ mPassthroughLogs.add(log);
+ pending.remove();
+ return;
+ }
+ }
+ Log.w(TAG, "recordKeyDispatch: can't find matching log!");
+ }
+ }
+
+ private final MediaSessionManager.Callback mButtonDispatchCallback =
+ new MediaSessionManager.Callback() {
+ @Override
+ public void onMediaKeyEventDispatched(KeyEvent event, MediaSession.Token token) {
+ // Get the package name
+ android.media.session.MediaController controller =
+ new android.media.session.MediaController(mContext, token);
+ String targetPackage = controller.getPackageName();
+ recordKeyDispatched(event, targetPackage);
+ }
+
+ @Override
+ public void onMediaKeyEventDispatched(KeyEvent event, ComponentName receiver) {
+ recordKeyDispatched(event, receiver.getPackageName());
+ }
+
+ @Override
+ public void onAddressedPlayerChanged(MediaSession.Token token) {
+ setActiveMediaSession(token);
+ }
+
+ @Override
+ public void onAddressedPlayerChanged(ComponentName receiver) {
+ if (receiver == null) {
+ // No active sessions, and no session to revive, give up.
+ setAddressedMediaSessionPackage(null);
+ return;
+ }
+ // We can still get a passthrough which will revive this player.
+ setAddressedMediaSessionPackage(receiver.getPackageName());
+ }
+ };
+
+ // Do not modify without updating the HAL bt_rc.h files.
+
+ // match up with btrc_play_status_t enum of bt_rc.h
+ static final byte PLAYSTATUS_STOPPED = 0;
+ static final byte PLAYSTATUS_PLAYING = 1;
+ static final byte PLAYSTATUS_PAUSED = 2;
+ static final byte PLAYSTATUS_FWD_SEEK = 3;
+ static final byte PLAYSTATUS_REV_SEEK = 4;
+ static final byte PLAYSTATUS_ERROR = (byte) 255;
+
+ // match up with btrc_media_attr_t enum of bt_rc.h
+ static final int MEDIA_ATTR_TITLE = 1;
+ static final int MEDIA_ATTR_ARTIST = 2;
+ static final int MEDIA_ATTR_ALBUM = 3;
+ static final int MEDIA_ATTR_TRACK_NUM = 4;
+ static final int MEDIA_ATTR_NUM_TRACKS = 5;
+ static final int MEDIA_ATTR_GENRE = 6;
+ static final int MEDIA_ATTR_PLAYING_TIME = 7;
+
+ // match up with btrc_event_id_t enum of bt_rc.h
+ static final int EVT_PLAY_STATUS_CHANGED = 1;
+ static final int EVT_TRACK_CHANGED = 2;
+ static final int EVT_TRACK_REACHED_END = 3;
+ static final int EVT_TRACK_REACHED_START = 4;
+ static final int EVT_PLAY_POS_CHANGED = 5;
+ static final int EVT_BATT_STATUS_CHANGED = 6;
+ static final int EVT_SYSTEM_STATUS_CHANGED = 7;
+ static final int EVT_APP_SETTINGS_CHANGED = 8;
+ static final int EVENT_NOW_PLAYING_CONTENT_CHANGED = 9;
+ static final int EVT_AVBL_PLAYERS_CHANGED = 0xa;
+ static final int EVT_ADDR_PLAYER_CHANGED = 0xb;
+ static final int EVENT_UIDS_CHANGED = 0x0c;
+
+ private static native void classInitNative();
+
+ private native void initNative();
+
+ private native void cleanupNative();
+
+ private native boolean getPlayStatusRspNative(byte[] address, int playStatus, int songLen,
+ int songPos);
+
+ private native boolean getElementAttrRspNative(byte[] address, byte numAttr, int[] attrIds,
+ String[] textArray);
+
+ private native boolean registerNotificationRspPlayStatusNative(int type, int playStatus);
+
+ private native boolean registerNotificationRspTrackChangeNative(int type, byte[] track);
+
+ private native boolean registerNotificationRspPlayPosNative(int type, int playPos);
+
+ private native boolean setVolumeNative(int volume);
+
+ private native boolean sendPassThroughCommandNative(int keyCode, int keyState);
+
+ private native boolean setAddressedPlayerRspNative(byte[] address, int rspStatus);
+
+ private native boolean setBrowsedPlayerRspNative(byte[] address, int rspStatus, byte depth,
+ int numItems, String[] textArray);
+
+ private native boolean mediaPlayerListRspNative(byte[] address, int rsStatus, int uidCounter,
+ byte itemType, int numItems, int[] playerIds, byte[] playerTypes, int[] playerSubTypes,
+ byte[] playStatusValues, short[] featureBitMaskValues, String[] textArray);
+
+ private native boolean getFolderItemsRspNative(byte[] address, int rspStatus, short uidCounter,
+ byte scope, int numItems, byte[] folderTypes, byte[] playable, byte[] itemTypes,
+ byte[] itemUidArray, String[] textArray, int[] attributesNum, int[] attributesIds,
+ String[] attributesArray);
+
+ private native boolean changePathRspNative(byte[] address, int rspStatus, int numItems);
+
+ private native boolean getItemAttrRspNative(byte[] address, int rspStatus, byte numAttr,
+ int[] attrIds, String[] textArray);
+
+ private native boolean playItemRspNative(byte[] address, int rspStatus);
+
+ private native boolean getTotalNumOfItemsRspNative(byte[] address, int rspStatus,
+ int uidCounter, int numItems);
+
+ private native boolean searchRspNative(byte[] address, int rspStatus, int uidCounter,
+ int numItems);
+
+ private native boolean addToNowPlayingRspNative(byte[] address, int rspStatus);
+
+ private native boolean registerNotificationRspAddrPlayerChangedNative(int type, int playerId,
+ int uidCounter);
+
+ private native boolean registerNotificationRspAvalPlayerChangedNative(int type);
+
+ private native boolean registerNotificationRspUIDsChangedNative(int type, int uidCounter);
+
+ private native boolean registerNotificationRspNowPlayingChangedNative(int type);
+
+}
diff --git a/src/com/android/bluetooth/avrcp/AvrcpConstants.java b/src/com/android/bluetooth/avrcp/AvrcpConstants.java
new file mode 100644
index 0000000..94419ae
--- /dev/null
+++ b/src/com/android/bluetooth/avrcp/AvrcpConstants.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2016 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.bluetooth.avrcp;
+
+import android.util.Log;
+
+/*************************************************************************************************
+ * Grouped all HAL constants into a file to be consistent with the stack.
+ * Moved the constants used in Avrcp to this new file to be used across multiple files.
+ * Helps in easier modifications and future enhancements in the constants.
+ ************************************************************************************************/
+
+/*
+ * @hide
+ */
+final class AvrcpConstants {
+
+ /* Do not modify without upating the HAL bt_rc.h file */
+ /** Response Error codes **/
+ static final byte RSP_BAD_CMD = 0x00; /* Invalid command */
+ static final byte RSP_BAD_PARAM = 0x01; /* Invalid parameter */
+ static final byte RSP_NOT_FOUND = 0x02; /* Specified parameter is
+ * wrong or not found */
+ static final byte RSP_INTERNAL_ERR = 0x03; /* Internal Error */
+ static final byte RSP_NO_ERROR = 0x04; /* Operation Success */
+ static final byte RSP_UID_CHANGED = 0x05; /* UIDs changed */
+ static final byte RSP_RESERVED = 0x06; /* Reserved */
+ static final byte RSP_INV_DIRN = 0x07; /* Invalid direction */
+ static final byte RSP_INV_DIRECTORY = 0x08; /* Invalid directory */
+ static final byte RSP_INV_ITEM = 0x09; /* Invalid Item */
+ static final byte RSP_INV_SCOPE = 0x0a; /* Invalid scope */
+ static final byte RSP_INV_RANGE = 0x0b; /* Invalid range */
+ static final byte RSP_DIRECTORY = 0x0c; /* UID is a directory */
+ static final byte RSP_MEDIA_IN_USE = 0x0d; /* Media in use */
+ static final byte RSP_PLAY_LIST_FULL = 0x0e; /* Playing list full */
+ static final byte RSP_SRCH_NOT_SPRTD = 0x0f; /* Search not supported */
+ static final byte RSP_SRCH_IN_PROG = 0x10; /* Search in progress */
+ static final byte RSP_INV_PLAYER = 0x11; /* Invalid player */
+ static final byte RSP_PLAY_NOT_BROW = 0x12; /* Player not browsable */
+ static final byte RSP_PLAY_NOT_ADDR = 0x13; /* Player not addressed */
+ static final byte RSP_INV_RESULTS = 0x14; /* Invalid results */
+ static final byte RSP_NO_AVBL_PLAY = 0x15; /* No available players */
+ static final byte RSP_ADDR_PLAY_CHGD = 0x16; /* Addressed player changed */
+
+ /* valid scopes for get_folder_items */
+ static final byte BTRC_SCOPE_PLAYER_LIST = 0x00; /* Media Player List */
+ static final byte BTRC_SCOPE_FILE_SYSTEM = 0x01; /* Virtual File System */
+ static final byte BTRC_SCOPE_SEARCH = 0x02; /* Search */
+ static final byte BTRC_SCOPE_NOW_PLAYING = 0x03; /* Now Playing */
+
+ /* valid directions for change path */
+ static final byte DIR_UP = 0x00;
+ static final byte DIR_DOWN = 0x01;
+
+ /* item type to browse */
+ static final byte BTRC_ITEM_PLAYER = 0x01;
+ static final byte BTRC_ITEM_FOLDER = 0x02;
+ static final byte BTRC_ITEM_MEDIA = 0x03;
+
+ /* valid folder types */
+ static final byte FOLDER_TYPE_MIXED = 0x00;
+ static final byte FOLDER_TYPE_TITLES = 0x01;
+ static final byte FOLDER_TYPE_ALBUMS = 0x02;
+ static final byte FOLDER_TYPE_ARTISTS = 0x03;
+ static final byte FOLDER_TYPE_GENRES = 0x04;
+ static final byte FOLDER_TYPE_PLAYLISTS = 0x05;
+ static final byte FOLDER_TYPE_YEARS = 0x06;
+
+ /* valid playable flags */
+ static final byte ITEM_NOT_PLAYABLE = 0x00;
+ static final byte ITEM_PLAYABLE = 0x01;
+
+ /* valid Attribute ids for media elements */
+ static final int ATTRID_TITLE = 0x01;
+ static final int ATTRID_ARTIST = 0x02;
+ static final int ATTRID_ALBUM = 0x03;
+ static final int ATTRID_TRACK_NUM = 0x04;
+ static final int ATTRID_NUM_TRACKS = 0x05;
+ static final int ATTRID_GENRE = 0x06;
+ static final int ATTRID_PLAY_TIME = 0x07;
+ static final int ATTRID_COVER_ART = 0x08;
+
+ /* constants to send in Track change response */
+ static final byte[] NO_TRACK_SELECTED = {
+ (byte) 0xFF,
+ (byte) 0xFF,
+ (byte) 0xFF,
+ (byte) 0xFF,
+ (byte) 0xFF,
+ (byte) 0xFF,
+ (byte) 0xFF,
+ (byte) 0xFF
+ };
+ static final byte[] TRACK_IS_SELECTED = {
+ (byte) 0x00,
+ (byte) 0x00,
+ (byte) 0x00,
+ (byte) 0x00,
+ (byte) 0x00,
+ (byte) 0x00,
+ (byte) 0x00,
+ (byte) 0x00
+ };
+
+ /* UID size */
+ static final int UID_SIZE = 8;
+
+ static final short DEFAULT_UID_COUNTER = 0x0000;
+
+ /* Bitmask size for Media Players */
+ static final int AVRC_FEATURE_MASK_SIZE = 16;
+
+ /* Maximum attributes for media item */
+ static final int MAX_NUM_ATTR = 8;
+
+ /* notification types for remote device */
+ static final int NOTIFICATION_TYPE_INTERIM = 0;
+ static final int NOTIFICATION_TYPE_CHANGED = 1;
+
+ static final int TRACK_ID_SIZE = 8;
+
+ /* player feature bit mask constants */
+ static final short AVRC_PF_PLAY_BIT_NO = 40;
+ static final short AVRC_PF_STOP_BIT_NO = 41;
+ static final short AVRC_PF_PAUSE_BIT_NO = 42;
+ static final short AVRC_PF_REWIND_BIT_NO = 44;
+ static final short AVRC_PF_FAST_FWD_BIT_NO = 45;
+ static final short AVRC_PF_FORWARD_BIT_NO = 47;
+ static final short AVRC_PF_BACKWARD_BIT_NO = 48;
+ static final short AVRC_PF_ADV_CTRL_BIT_NO = 58;
+ static final short AVRC_PF_BROWSE_BIT_NO = 59;
+ static final short AVRC_PF_ADD2NOWPLAY_BIT_NO = 61;
+ static final short AVRC_PF_UID_UNIQUE_BIT_NO = 62;
+ static final short AVRC_PF_NOW_PLAY_BIT_NO = 65;
+ static final short AVRC_PF_GET_NUM_OF_ITEMS_BIT_NO = 67;
+ static final short AVRC_PF_COVER_ART_BIT_NO = 68;
+ static final byte PLAYER_TYPE_AUDIO = 1;
+ static final int PLAYER_SUBTYPE_NONE = 0;
+
+ // match up with btrc_play_status_t enum of bt_rc.h
+ static final int PLAYSTATUS_STOPPED = 0;
+ static final int PLAYSTATUS_PLAYING = 1;
+ static final int PLAYSTATUS_PAUSED = 2;
+ static final int PLAYSTATUS_FWD_SEEK = 3;
+ static final int PLAYSTATUS_REV_SEEK = 4;
+ static final int PLAYSTATUS_ERROR = 255;
+
+ static final byte NUM_ATTR_ALL = (byte) 0x00;
+ static final byte NUM_ATTR_NONE = (byte) 0xFF;
+
+ static final int KEY_STATE_PRESS = 1;
+ static final int KEY_STATE_RELEASE = 0;
+
+ static final int GET_ATTRIBUTE_IDS = 0;
+ static final int GET_VALUE_IDS = 1;
+ static final int GET_ATTRIBUTE_TEXT = 2;
+ static final int GET_VALUE_TEXT = 3;
+ static final int GET_ATTRIBUTE_VALUES = 4;
+ static final int NOTIFY_ATTRIBUTE_VALUES = 5;
+ static final int SET_ATTRIBUTE_VALUES = 6;
+ static final int GET_INVALID = 0xff;
+
+ public static final String TAG = "Avrcp";
+ public static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);
+}
diff --git a/src/com/android/bluetooth/avrcp/AvrcpHelperClasses.java b/src/com/android/bluetooth/avrcp/AvrcpHelperClasses.java
new file mode 100644
index 0000000..ea6d7b8
--- /dev/null
+++ b/src/com/android/bluetooth/avrcp/AvrcpHelperClasses.java
@@ -0,0 +1,451 @@
+/*
+ * Copyright (C) 2016 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.bluetooth.avrcp;
+
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+
+import com.android.bluetooth.Utils;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Collection;
+
+/*************************************************************************************************
+ * Helper classes used for callback/response of browsing commands:-
+ * 1) To bundle parameters for native callbacks/response.
+ * 2) Stores information of Addressed and Browsed Media Players.
+ ************************************************************************************************/
+
+class AvrcpCmd {
+
+ AvrcpCmd() {}
+
+ /* Helper classes to pass parameters from callbacks to Avrcp handler */
+ class FolderItemsCmd {
+ byte mScope;
+ long mStartItem;
+ long mEndItem;
+ byte mNumAttr;
+ int[] mAttrIDs;
+ public byte[] mAddress;
+
+ FolderItemsCmd(byte[] address, byte scope, long startItem, long endItem, byte numAttr,
+ int[] attrIds) {
+ mAddress = address;
+ this.mScope = scope;
+ this.mStartItem = startItem;
+ this.mEndItem = endItem;
+ this.mNumAttr = numAttr;
+ this.mAttrIDs = attrIds;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("[FolderItemCmd: scope " + mScope);
+ sb.append(" start " + mStartItem);
+ sb.append(" end " + mEndItem);
+ sb.append(" numAttr " + mNumAttr);
+ sb.append(" attrs: ");
+ for (int i = 0; i < mNumAttr; i++) {
+ sb.append(mAttrIDs[i] + " ");
+ }
+ return sb.toString();
+ }
+ }
+
+ class ItemAttrCmd {
+ byte mScope;
+ byte[] mUid;
+ int mUidCounter;
+ byte mNumAttr;
+ int[] mAttrIDs;
+ public byte[] mAddress;
+
+ ItemAttrCmd(byte[] address, byte scope, byte[] uid, int uidCounter, byte numAttr,
+ int[] attrIDs) {
+ mAddress = address;
+ mScope = scope;
+ mUid = uid;
+ mUidCounter = uidCounter;
+ mNumAttr = numAttr;
+ mAttrIDs = attrIDs;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("[ItemAttrCmd: scope " + mScope);
+ sb.append(" uid " + Utils.byteArrayToString(mUid));
+ sb.append(" numAttr " + mNumAttr);
+ sb.append(" attrs: ");
+ for (int i = 0; i < mNumAttr; i++) {
+ sb.append(mAttrIDs[i] + " ");
+ }
+ return sb.toString();
+ }
+ }
+
+ class ElementAttrCmd {
+ byte mNumAttr;
+ int[] mAttrIDs;
+ public byte[] mAddress;
+
+ ElementAttrCmd(byte[] address, byte numAttr, int[] attrIDs) {
+ mAddress = address;
+ mNumAttr = numAttr;
+ mAttrIDs = attrIDs;
+ }
+ }
+}
+
+/* Helper classes to pass parameters to native response */
+class MediaPlayerListRsp {
+ byte mStatus;
+ short mUIDCounter;
+ byte mItemType;
+ int[] mPlayerIds;
+ byte[] mPlayerTypes;
+ int[] mPlayerSubTypes;
+ byte[] mPlayStatusValues;
+ short[] mFeatureBitMaskValues;
+ String[] mPlayerNameList;
+ int mNumItems;
+
+ MediaPlayerListRsp(byte status, short uidCounter, int numItems, byte itemType, int[] playerIds,
+ byte[] playerTypes, int[] playerSubTypes, byte[] playStatusValues,
+ short[] featureBitMaskValues, String[] playerNameList) {
+ this.mStatus = status;
+ this.mUIDCounter = uidCounter;
+ this.mNumItems = numItems;
+ this.mItemType = itemType;
+ this.mPlayerIds = playerIds;
+ this.mPlayerTypes = playerTypes;
+ this.mPlayerSubTypes = new int[numItems];
+ this.mPlayerSubTypes = playerSubTypes;
+ this.mPlayStatusValues = new byte[numItems];
+ this.mPlayStatusValues = playStatusValues;
+ int bitMaskSize = AvrcpConstants.AVRC_FEATURE_MASK_SIZE;
+ this.mFeatureBitMaskValues = new short[numItems * bitMaskSize];
+ for (int bitMaskIndex = 0; bitMaskIndex < (numItems * bitMaskSize); bitMaskIndex++) {
+ this.mFeatureBitMaskValues[bitMaskIndex] = featureBitMaskValues[bitMaskIndex];
+ }
+ this.mPlayerNameList = playerNameList;
+ }
+}
+
+class FolderItemsRsp {
+ byte mStatus;
+ short mUIDCounter;
+ byte mScope;
+ int mNumItems;
+ byte[] mFolderTypes;
+ byte[] mPlayable;
+ byte[] mItemTypes;
+ byte[] mItemUid;
+ String[] mDisplayNames; /* display name of the item. Eg: Folder name or song name */
+ int[] mAttributesNum;
+ int[] mAttrIds;
+ String[] mAttrValues;
+
+ FolderItemsRsp(byte status, short uidCounter, byte scope, int numItems, byte[] folderTypes,
+ byte[] playable, byte[] itemTypes, byte[] itemsUid, String[] displayNameArray,
+ int[] attributesNum, int[] attrIds, String[] attrValues) {
+ this.mStatus = status;
+ this.mUIDCounter = uidCounter;
+ this.mScope = scope;
+ this.mNumItems = numItems;
+ this.mFolderTypes = folderTypes;
+ this.mPlayable = playable;
+ this.mItemTypes = itemTypes;
+ this.mItemUid = itemsUid;
+ this.mDisplayNames = displayNameArray;
+ this.mAttributesNum = attributesNum;
+ this.mAttrIds = attrIds;
+ this.mAttrValues = attrValues;
+ }
+}
+
+class ItemAttrRsp {
+ byte mStatus;
+ byte mNumAttr;
+ int[] mAttributesIds;
+ String[] mAttributesArray;
+
+ ItemAttrRsp(byte status, int[] attributesIds, String[] attributesArray) {
+ mStatus = status;
+ mNumAttr = (byte) attributesIds.length;
+ mAttributesIds = attributesIds;
+ mAttributesArray = attributesArray;
+ }
+}
+
+/* stores information of Media Players in the system */
+class MediaPlayerInfo {
+
+ private byte mMajorType;
+ private int mSubType;
+ private byte mPlayStatus;
+ private short[] mFeatureBitMask;
+ @NonNull private String mPackageName;
+ @NonNull private String mDisplayableName;
+ @Nullable private MediaController mMediaController;
+
+ MediaPlayerInfo(@Nullable MediaController controller, byte majorType, int subType,
+ byte playStatus, short[] featureBitMask, @NonNull String packageName,
+ @Nullable String displayableName) {
+ this.setMajorType(majorType);
+ this.setSubType(subType);
+ this.mPlayStatus = playStatus;
+ // store a copy the FeatureBitMask array
+ this.mFeatureBitMask = Arrays.copyOf(featureBitMask, featureBitMask.length);
+ Arrays.sort(this.mFeatureBitMask);
+ this.setPackageName(packageName);
+ this.setDisplayableName(displayableName);
+ this.setMediaController(controller);
+ }
+
+ /* getters and setters */
+ byte getPlayStatus() {
+ return mPlayStatus;
+ }
+
+ void setPlayStatus(byte playStatus) {
+ this.mPlayStatus = playStatus;
+ }
+
+ MediaController getMediaController() {
+ return mMediaController;
+ }
+
+ void setMediaController(MediaController mediaController) {
+ if (mediaController != null) {
+ this.mPackageName = mediaController.getPackageName();
+ }
+ this.mMediaController = mediaController;
+ }
+
+ void setPackageName(@NonNull String name) {
+ // Controller determines package name when it is set.
+ if (mMediaController != null) {
+ return;
+ }
+ this.mPackageName = name;
+ }
+
+ String getPackageName() {
+ if (mMediaController != null) {
+ return mMediaController.getPackageName();
+ } else if (mPackageName != null) {
+ return mPackageName;
+ }
+ return null;
+ }
+
+ byte getMajorType() {
+ return mMajorType;
+ }
+
+ void setMajorType(byte majorType) {
+ this.mMajorType = majorType;
+ }
+
+ int getSubType() {
+ return mSubType;
+ }
+
+ void setSubType(int subType) {
+ this.mSubType = subType;
+ }
+
+ String getDisplayableName() {
+ return mDisplayableName;
+ }
+
+ void setDisplayableName(@Nullable String displayableName) {
+ if (displayableName == null) {
+ displayableName = "";
+ }
+ this.mDisplayableName = displayableName;
+ }
+
+ short[] getFeatureBitMask() {
+ return mFeatureBitMask;
+ }
+
+ void setFeatureBitMask(short[] featureBitMask) {
+ synchronized (this) {
+ this.mFeatureBitMask = Arrays.copyOf(featureBitMask, featureBitMask.length);
+ Arrays.sort(this.mFeatureBitMask);
+ }
+ }
+
+ boolean isBrowseSupported() {
+ synchronized (this) {
+ if (this.mFeatureBitMask == null) {
+ return false;
+ }
+ for (short bit : this.mFeatureBitMask) {
+ if (bit == AvrcpConstants.AVRC_PF_BROWSE_BIT_NO) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /** Tests if the view of this player presented to the controller is different enough to
+ * justify sending an Available Players Changed update */
+ public boolean equalView(MediaPlayerInfo other) {
+ return (this.mMajorType == other.getMajorType()) && (this.mSubType == other.getSubType())
+ && Arrays.equals(this.mFeatureBitMask, other.getFeatureBitMask())
+ && this.mDisplayableName.equals(other.getDisplayableName());
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("MediaPlayerInfo ");
+ sb.append(getPackageName());
+ sb.append(" (as '" + getDisplayableName() + "')");
+ sb.append(" Type = " + getMajorType());
+ sb.append(", SubType = " + getSubType());
+ sb.append(", Status = " + mPlayStatus);
+ sb.append(" Feature Bits [");
+ short[] bits = getFeatureBitMask();
+ for (int i = 0; i < bits.length; i++) {
+ if (i != 0) {
+ sb.append(" ");
+ }
+ sb.append(bits[i]);
+ }
+ sb.append("] Controller: ");
+ sb.append(getMediaController());
+ return sb.toString();
+ }
+}
+
+/* stores information for browsable Media Players available in the system */
+class BrowsePlayerInfo {
+ public String packageName;
+ public String displayableName;
+ public String serviceClass;
+
+ BrowsePlayerInfo(String packageName, String displayableName, String serviceClass) {
+ this.packageName = packageName;
+ this.displayableName = displayableName;
+ this.serviceClass = serviceClass;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("BrowsePlayerInfo ");
+ sb.append(packageName);
+ sb.append(" ( as '" + displayableName + "')");
+ sb.append(" service " + serviceClass);
+ return sb.toString();
+ }
+}
+
+class FolderItemsData {
+ /* initialize sizes for rsp parameters */ int mNumItems;
+ int[] mAttributesNum;
+ byte[] mFolderTypes;
+ byte[] mItemTypes;
+ byte[] mPlayable;
+ byte[] mItemUid;
+ String[] mDisplayNames;
+ int[] mAttrIds;
+ String[] mAttrValues;
+ int mAttrCounter;
+
+ FolderItemsData(int size) {
+ mNumItems = size;
+ mAttributesNum = new int[size];
+
+ mFolderTypes = new byte[size]; /* folderTypes */
+ mItemTypes = new byte[size]; /* folder or media item */
+ mPlayable = new byte[size];
+ Arrays.fill(mFolderTypes, AvrcpConstants.FOLDER_TYPE_MIXED);
+ Arrays.fill(mItemTypes, AvrcpConstants.BTRC_ITEM_MEDIA);
+ Arrays.fill(mPlayable, AvrcpConstants.ITEM_PLAYABLE);
+
+ mItemUid = new byte[size * AvrcpConstants.UID_SIZE];
+ mDisplayNames = new String[size];
+
+ mAttrIds = null; /* array of attr ids */
+ mAttrValues = null; /* array of attr values */
+ }
+}
+
+/** A queue that evicts the first element when you add an element to the end when it reaches a
+ * maximum size.
+ * This is useful for keeping a FIFO queue of items where the items drop off the front, i.e. a log
+ * with a maximum size.
+ */
+class EvictingQueue<E> extends ArrayDeque<E> {
+ private int mMaxSize;
+
+ EvictingQueue(int maxSize) {
+ super();
+ mMaxSize = maxSize;
+ }
+
+ EvictingQueue(int maxSize, int initialElements) {
+ super(initialElements);
+ mMaxSize = maxSize;
+ }
+
+ EvictingQueue(int maxSize, Collection<? extends E> c) {
+ super(c);
+ mMaxSize = maxSize;
+ }
+
+ @Override
+ public void addFirst(E e) {
+ if (super.size() == mMaxSize) {
+ return;
+ }
+ super.addFirst(e);
+ }
+
+ @Override
+ public void addLast(E e) {
+ if (super.size() == mMaxSize) {
+ super.remove();
+ }
+ super.addLast(e);
+ }
+
+ @Override
+ public boolean offerFirst(E e) {
+ if (super.size() == mMaxSize) {
+ return false;
+ }
+ return super.offerFirst(e);
+ }
+
+ @Override
+ public boolean offerLast(E e) {
+ if (super.size() == mMaxSize) {
+ super.remove();
+ }
+ return super.offerLast(e);
+ }
+}
diff --git a/src/com/android/bluetooth/avrcp/AvrcpMediaRspInterface.java b/src/com/android/bluetooth/avrcp/AvrcpMediaRspInterface.java
new file mode 100644
index 0000000..8cab68e
--- /dev/null
+++ b/src/com/android/bluetooth/avrcp/AvrcpMediaRspInterface.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2016 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.bluetooth.avrcp;
+
+
+/*************************************************************************************************
+ * Interface for classes which handle callbacks from AvrcpMediaManager.
+ * These callbacks should map to native responses and used to communicate with the native layer.
+ ************************************************************************************************/
+
+public interface AvrcpMediaRspInterface {
+ void setAddrPlayerRsp(byte[] address, int rspStatus);
+
+ void setBrowsedPlayerRsp(byte[] address, int rspStatus, byte depth, int numItems,
+ String[] textArray);
+
+ void mediaPlayerListRsp(byte[] address, int rspStatus, MediaPlayerListRsp rspObj);
+
+ void folderItemsRsp(byte[] address, int rspStatus, FolderItemsRsp rspObj);
+
+ void changePathRsp(byte[] address, int rspStatus, int numItems);
+
+ void getItemAttrRsp(byte[] address, int rspStatus, ItemAttrRsp rspObj);
+
+ void playItemRsp(byte[] address, int rspStatus);
+
+ void getTotalNumOfItemsRsp(byte[] address, int rspStatus, int uidCounter, int numItems);
+
+ void addrPlayerChangedRsp(int type, int playerId, int uidCounter);
+
+ void avalPlayerChangedRsp(byte[] address, int type);
+
+ void uidsChangedRsp(int type);
+
+ void nowPlayingChangedRsp(int type);
+
+ void trackChangedRsp(int type, byte[] uid);
+}
+
diff --git a/src/com/android/bluetooth/avrcp/AvrcpTargetService.java b/src/com/android/bluetooth/avrcp/AvrcpTargetService.java
index e2ae494..bdc930b 100644
--- a/src/com/android/bluetooth/avrcp/AvrcpTargetService.java
+++ b/src/com/android/bluetooth/avrcp/AvrcpTargetService.java
@@ -32,6 +32,7 @@
import com.android.bluetooth.BluetoothMetricsProto;
import com.android.bluetooth.Utils;
+import com.android.bluetooth.btservice.AdapterService;
import com.android.bluetooth.a2dp.A2dpService;
import com.android.bluetooth.btservice.MetricsLogger;
import com.android.bluetooth.btservice.ProfileService;
@@ -52,6 +53,7 @@
private static final int AVRCP_MAX_VOL = 127;
private static int sDeviceMaxVolume = 0;
+ private AdapterService mAdapterService;
private MediaPlayerList mMediaPlayerList;
private AudioManager mAudioManager;
private AvrcpBroadcastReceiver mReceiver;
@@ -155,6 +157,13 @@
Log.i(TAG, "Starting the AVRCP Target Service");
mCurrentData = new MediaData(null, null, null);
+ mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(),
+ "AdapterService cannot be null when A2dpService starts");
+
+ if(mAdapterService.isVendorIntfEnabled()) {
+ Log.i(TAG, "Vendor Stack is enabled, using legacy implementation");
+ SystemProperties.set(AVRCP_ENABLE_PROPERTY, "false");
+ }
if (!SystemProperties.getBoolean(AVRCP_ENABLE_PROPERTY, true)) {
Log.w(TAG, "Skipping initialization of the new AVRCP Target Service");
diff --git a/src/com/android/bluetooth/avrcp/BrowsedMediaPlayer.java b/src/com/android/bluetooth/avrcp/BrowsedMediaPlayer.java
new file mode 100644
index 0000000..9a3a240
--- /dev/null
+++ b/src/com/android/bluetooth/avrcp/BrowsedMediaPlayer.java
@@ -0,0 +1,1075 @@
+/*
+ * Copyright (C) 2016 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.bluetooth.avrcp;
+
+import android.annotation.NonNull;
+import android.content.ComponentName;
+import android.content.Context;
+import android.media.MediaDescription;
+import android.media.MediaMetadata;
+import android.media.browse.MediaBrowser;
+import android.media.browse.MediaBrowser.MediaItem;
+import android.media.session.MediaSession;
+import android.os.Bundle;
+import android.util.Log;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Stack;
+
+/*************************************************************************************************
+ * Provides functionality required for Browsed Media Player like browsing Virtual File System, get
+ * Item Attributes, play item from the file system, etc.
+ * Acts as an Interface to communicate with Media Browsing APIs for browsing FileSystem.
+ ************************************************************************************************/
+
+class BrowsedMediaPlayer {
+ private static final boolean DEBUG = true;
+ private static final String TAG = "BrowsedMediaPlayer";
+
+ /* connection state with MediaBrowseService */
+ private static final int DISCONNECTED = 0;
+ private static final int CONNECTED = 1;
+ private static final int SUSPENDED = 2;
+
+ private static final int BROWSED_ITEM_ID_INDEX = 2;
+ private static final int BROWSED_FOLDER_ID_INDEX = 4;
+ private static final String[] ROOT_FOLDER = {"root"};
+ private static boolean mPlayerRoot = false;
+ /* package and service name of target Media Player which is set for browsing */
+ private String mPackageName;
+ private String mConnectingPackageName;
+ private String mClassName;
+ private Context mContext;
+ private AvrcpMediaRspInterface mMediaInterface;
+ private byte[] mBDAddr;
+
+ private String mCurrentBrowsePackage;
+ private String mCurrentBrowseClass;
+
+ /* Object used to connect to MediaBrowseService of Media Player */
+ private MediaBrowser mMediaBrowser = null;
+ private MediaController mMediaController = null;
+
+ /* The mediaId to be used for subscribing for children using the MediaBrowser */
+ private String mMediaId = null;
+ private String mRootFolderUid = null;
+ private int mConnState = DISCONNECTED;
+
+ /* stores the path trail during changePath */
+ private Stack<String> mPathStack = null;
+ private Stack<String> mLocalPathCache = null;
+ /* Number of items in current folder */
+ private int mCurrFolderNumItems = 0;
+
+ /* store mapping between uid(Avrcp) and mediaId(Media Player) for Media Item */
+ private HashMap<Integer, String> mMediaHmap = new HashMap<Integer, String>();
+
+ /* store mapping between uid(Avrcp) and mediaId(Media Player) for Folder Item */
+ private HashMap<Integer, String> mFolderHmap = new HashMap<Integer, String>();
+
+ /* command objects from avrcp handler */
+ private AvrcpCmd.FolderItemsCmd mFolderItemsReqObj;
+
+ /* store result of getfolderitems with scope="vfs" */
+ private List<MediaBrowser.MediaItem> mFolderItems = null;
+
+ /* Connection state callback handler */
+ class MediaConnectionCallback extends MediaBrowser.ConnectionCallback {
+ private String mCallbackPackageName;
+ private MediaBrowser mBrowser;
+
+ MediaConnectionCallback(String packageName) {
+ this.mCallbackPackageName = packageName;
+ }
+
+ public void setBrowser(MediaBrowser b) {
+ mBrowser = b;
+ }
+
+ @Override
+ public void onConnected() {
+ mConnState = CONNECTED;
+ if (DEBUG) {
+ Log.d(TAG, "mediaBrowser CONNECTED to " + mPackageName);
+ }
+ /* perform init tasks and set player as browsed player on successful connection */
+ onBrowseConnect(mCallbackPackageName, mBrowser);
+
+ // Remove what could be a circular dependency causing GC to never happen on this object
+ mBrowser = null;
+ }
+
+ @Override
+ public void onConnectionFailed() {
+ mConnState = DISCONNECTED;
+ // Remove what could be a circular dependency causing GC to never happen on this object
+ mBrowser = null;
+ Log.e(TAG, "mediaBrowser Connection failed with " + mPackageName
+ + ", Sending fail response!");
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR,
+ (byte) 0x00, 0, null);
+ }
+
+ @Override
+ public void onConnectionSuspended() {
+ mBrowser = null;
+ mConnState = SUSPENDED;
+ Log.e(TAG, "mediaBrowser SUSPENDED connection with " + mPackageName);
+ }
+ }
+
+ /* Subscription callback handler. Subscribe to a folder to get its contents */
+ private MediaBrowser.SubscriptionCallback mFolderItemsCb =
+ new MediaBrowser.SubscriptionCallback() {
+
+ @Override
+ public void onChildrenLoaded(String parentId,
+ List<MediaBrowser.MediaItem> children) {
+ if (DEBUG) {
+ Log.d(TAG, "OnChildren Loaded folder items: childrens= " + children.size());
+ }
+
+ /*
+ * cache current folder items and send as rsp when remote requests
+ * get_folder_items (scope = vfs)
+ */
+ if (mFolderItems == null) {
+ if (DEBUG) {
+ Log.d(TAG, "sending setbrowsed player rsp");
+ }
+ Log.w(TAG, "sending setbrowsed player rsp");
+ mFolderItems = children;
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, AvrcpConstants.RSP_NO_ERROR,
+ (byte) 0x00, children.size(), ROOT_FOLDER);
+ } else {
+ mFolderItems = children;
+ mCurrFolderNumItems = mFolderItems.size();
+ mMediaInterface.changePathRsp(mBDAddr, AvrcpConstants.RSP_NO_ERROR,
+ mCurrFolderNumItems);
+ }
+ refreshFolderItems(mFolderItems);
+ mMediaBrowser.unsubscribe(parentId);
+ }
+
+ /* UID is invalid */
+ @Override
+ public void onError(String id) {
+ Log.e(TAG, "set browsed player rsp. Could not get root folder items");
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR,
+ (byte) 0x00, 0, null);
+ }
+ };
+
+ /* callback from media player in response to getitemAttr request */
+ private class ItemAttribSubscriber extends MediaBrowser.SubscriptionCallback {
+ private String mMediaId;
+ private AvrcpCmd.ItemAttrCmd mAttrReq;
+
+ ItemAttribSubscriber(@NonNull AvrcpCmd.ItemAttrCmd attrReq, @NonNull String mediaId) {
+ mAttrReq = attrReq;
+ mMediaId = mediaId;
+ }
+
+ @Override
+ public void onChildrenLoaded(String parentId, List<MediaBrowser.MediaItem> children) {
+ String logprefix = "ItemAttribSubscriber(" + mMediaId + "): ";
+ if (DEBUG) {
+ Log.d(TAG, logprefix + "OnChildren Loaded");
+ }
+ int status = AvrcpConstants.RSP_INV_ITEM;
+
+ if (children == null) {
+ Log.w(TAG, logprefix + "children list is null parentId: " + parentId);
+ } else {
+ /* find the item in the folder */
+ for (MediaBrowser.MediaItem item : children) {
+ if (item.getMediaId().equals(mMediaId)) {
+ if (DEBUG) {
+ Log.d(TAG, logprefix + "found item");
+ }
+ getItemAttrFilterAttr(item);
+ status = AvrcpConstants.RSP_NO_ERROR;
+ break;
+ }
+ }
+ }
+ /* Send only error from here, in case of success, getItemAttrFilterAttr sends */
+ if (status != AvrcpConstants.RSP_NO_ERROR) {
+ Log.e(TAG, logprefix + "not able to find item from " + parentId);
+ mMediaInterface.getItemAttrRsp(mBDAddr, status, null);
+ }
+ mMediaBrowser.unsubscribe(parentId);
+ }
+
+ @Override
+ public void onError(String id) {
+ Log.e(TAG, "Could not get attributes from media player id: " + id);
+ mMediaInterface.getItemAttrRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR, null);
+ }
+
+ /* helper method to filter required attibuteand send GetItemAttr response */
+ private void getItemAttrFilterAttr(@NonNull MediaBrowser.MediaItem mediaItem) {
+ /* Response parameters */
+ int[] attrIds = null; /* array of attr ids */
+ String[] attrValues = null; /* array of attr values */
+
+ /* variables to temperorily add attrs */
+ ArrayList<Integer> attrIdArray = new ArrayList<Integer>();
+ ArrayList<String> attrValueArray = new ArrayList<String>();
+ ArrayList<Integer> attrReqIds = new ArrayList<Integer>();
+
+ if (mAttrReq.mNumAttr == AvrcpConstants.NUM_ATTR_NONE) {
+ // Note(jamuraa): the stack should never send this, remove?
+ Log.i(TAG, "getItemAttrFilterAttr: No attributes requested");
+ mMediaInterface.getItemAttrRsp(mBDAddr, AvrcpConstants.RSP_BAD_PARAM, null);
+ return;
+ }
+
+ /* check if remote device has requested all attributes */
+ if (mAttrReq.mNumAttr == AvrcpConstants.NUM_ATTR_ALL
+ || mAttrReq.mNumAttr == AvrcpConstants.MAX_NUM_ATTR) {
+ for (int idx = 1; idx <= AvrcpConstants.MAX_NUM_ATTR; idx++) {
+ attrReqIds.add(idx); /* attr id 0x00 is unused */
+ }
+ } else {
+ /* get only the requested attribute ids from the request */
+ for (int idx = 0; idx < mAttrReq.mNumAttr; idx++) {
+ attrReqIds.add(mAttrReq.mAttrIDs[idx]);
+ }
+ }
+
+ /* lookup and copy values of attributes for ids requested above */
+ for (int attrId : attrReqIds) {
+ /* check if media player provided requested attributes */
+ String value = getAttrValue(mBDAddr, attrId, mediaItem);
+ if (value != null) {
+ attrIdArray.add(attrId);
+ attrValueArray.add(value);
+ }
+ }
+
+ /* copy filtered attr ids and attr values to response parameters */
+ attrIds = new int[attrIdArray.size()];
+ for (int i = 0; i < attrIdArray.size(); i++) {
+ attrIds[i] = attrIdArray.get(i);
+ }
+
+ attrValues = attrValueArray.toArray(new String[attrIdArray.size()]);
+
+ /* create rsp object and send response */
+ ItemAttrRsp rspObj = new ItemAttrRsp(AvrcpConstants.RSP_NO_ERROR, attrIds, attrValues);
+ mMediaInterface.getItemAttrRsp(mBDAddr, AvrcpConstants.RSP_NO_ERROR, rspObj);
+ }
+ }
+
+ /* Constructor */
+ BrowsedMediaPlayer(byte[] address, Context context,
+ AvrcpMediaRspInterface mAvrcpMediaRspInterface) {
+ mContext = context;
+ mMediaInterface = mAvrcpMediaRspInterface;
+ mBDAddr = address;
+ }
+
+ /* initialize mediacontroller in order to communicate with media player. */
+ private void onBrowseConnect(String connectedPackage, MediaBrowser browser) {
+ if (!connectedPackage.equals(mConnectingPackageName)) {
+ Log.w(TAG, "onBrowseConnect: recieved callback for package" + mConnectingPackageName +
+ "we aren't connecting to " + connectedPackage);
+ mMediaInterface.setBrowsedPlayerRsp(
+ mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR, (byte) 0x00, 0, null);
+ return;
+ }
+ mConnectingPackageName = null;
+
+ if (browser == null) {
+ Log.e(TAG, "onBrowseConnect: received a null browser for " + connectedPackage);
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR,
+ (byte) 0x00, 0, null);
+ return;
+ }
+
+ MediaSession.Token token = null;
+ try {
+ if (!browser.isConnected()) {
+ Log.e(TAG, "setBrowsedPlayer: " + mPackageName + "not connected");
+ } else if ((token = browser.getSessionToken()) == null) {
+ Log.e(TAG, "setBrowsedPlayer: " + mPackageName + "no Session token");
+ } else {
+ /* update to the new MediaBrowser */
+ if (mMediaBrowser != null) {
+ mMediaBrowser.disconnect();
+ }
+ mMediaBrowser = browser;
+ mPackageName = connectedPackage;
+
+ /* get rootfolder uid from media player */
+ if (mMediaId == null) {
+ mMediaId = mMediaBrowser.getRoot();
+ Log.d(TAG, "media browser root = " + mMediaId);
+
+ if (mMediaId == null || mMediaId.length() == 0) {
+ Log.e(TAG, "onBrowseConnect: root value is empty or null");
+ mMediaInterface.setBrowsedPlayerRsp(
+ mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR, (byte) 0x00, 0, null);
+ return;
+ }
+
+ /*
+ * assuming that root folder uid will not change on uids changed
+ */
+ mRootFolderUid = mMediaId;
+ /* store root folder uid to stack */
+ mPathStack.push(mMediaId);
+ String [] ExternalPath = mMediaId.split("/");
+ if (ExternalPath != null) {
+ Log.d(TAG,"external path length: " + ExternalPath.length);
+ if (ExternalPath.length == 1) {
+ mLocalPathCache.push(mMediaId);
+ } else if (ExternalPath.length == 0 && mMediaId.equals("/")) {
+ mPlayerRoot = true;
+ mLocalPathCache.push(mMediaId);
+ } else {
+ //to trim the root in GMP which comes as "com.google.android.music.generic/root"
+ mLocalPathCache.push(ExternalPath[ExternalPath.length - 1]);
+ }
+ }
+ /* get root folder items */
+ Log.e(TAG, "onBrowseConnect: subscribe event for FolderCb");
+ mMediaBrowser.subscribe(mRootFolderUid, mFolderItemsCb);
+ }
+
+ mMediaController = MediaControllerFactory.make(mContext, token);
+ return;
+ }
+ } catch (NullPointerException ex) {
+ Log.e(TAG, "setBrowsedPlayer : Null pointer during init");
+ ex.printStackTrace();
+ }
+
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR, (byte) 0x00,
+ 0, null);
+ }
+
+ public void setBrowsed(String packageName, String cls) {
+ Log.w(TAG, "!! In setBrowse function !!" + mFolderItems);
+ if ((mPackageName != null && packageName != null
+ && !mPackageName.equals(packageName)) || (mFolderItems == null)) {
+ Log.d(TAG, "setBrowse for packageName = " + packageName);
+ mConnectingPackageName = packageName;
+ mPackageName = packageName;
+ mClassName = cls;
+
+ /* cleanup variables from previous browsed calls */
+ mFolderItems = null;
+ mMediaId = null;
+ mRootFolderUid = null;
+ mPlayerRoot = false;
+ /*
+ * create stack to store the navigation trail (current folder ID). This
+ * will be required while navigating up the folder
+ */
+ mPathStack = new Stack<String>();
+ mLocalPathCache = new Stack<String>();
+ /* Bind to MediaBrowseService of MediaPlayer */
+ MediaConnectionCallback callback = new MediaConnectionCallback(packageName);
+ MediaBrowser tempBrowser = new MediaBrowser(
+ mContext, new ComponentName(packageName, mClassName), callback, null);
+ callback.setBrowser(tempBrowser);
+ tempBrowser.connect();
+ } else if (mFolderItems != null) {
+ mPackageName = packageName;
+ mClassName = cls;
+ int rsp_status = AvrcpConstants.RSP_NO_ERROR;
+ int folder_depth = (mPathStack.size() > 0) ? (mPathStack.size() - 1) : 0;
+ if (!mPathStack.empty()) {
+ Log.d(TAG, "~~current Path = " + mPathStack.peek());
+ if (mPathStack.size() > 1) {
+ String top = mPathStack.peek();
+ mPathStack.pop();
+ String path = mPathStack.peek();
+ mPathStack.push(top);
+ String [] ExternalPath = path.split("/");
+ if (!mPlayerRoot && ExternalPath != null && ExternalPath.length > 1) {
+ Log.d(TAG,"external path length: " + ExternalPath.length);
+ String [] folderPath = new String[ExternalPath.length - 1];
+ for (int i = 0; i < (ExternalPath.length - 1); i++) {
+ folderPath[i] = ExternalPath[i + 1];
+ Log.d(TAG,"folderPath[" + i + "] = " + folderPath[i]);
+ }
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, rsp_status,
+ (byte)folder_depth, mFolderItems.size(), folderPath);
+ } else if (!mPlayerRoot && mLocalPathCache.size() > 1 && ExternalPath.length == 1) {
+ String [] folderPath = new String[mLocalPathCache.size() - 1];
+ folderPath = mLocalPathCache.toArray(folderPath);
+ for (int i = 0; i < mLocalPathCache.size() - 1; i++) {
+ Log.d(TAG,"folderPath[" + i + "] = " + folderPath[i]);
+ }
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, rsp_status,
+ (byte)folder_depth, mFolderItems.size(), folderPath);
+ } else if (mPlayerRoot && mLocalPathCache.size() > 1) {
+ String [] folderPath = new String[mLocalPathCache.size() - 1];
+ folderPath = mLocalPathCache.toArray(folderPath);
+ for (int i = 0; i < mLocalPathCache.size() - 1; i++) {
+ Log.d(TAG,"folderPath[" + i + "] = " + folderPath[i]);
+ }
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, rsp_status,
+ (byte)folder_depth, mFolderItems.size(), folderPath);
+ } else {
+ Log.e(TAG, "sending internal error !!!");
+ rsp_status = AvrcpConstants.RSP_INTERNAL_ERR;
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, rsp_status, (byte)0x00, 0, null);
+ }
+ } else if (mPathStack.size() == 1) {
+ Log.d(TAG, "On root send SetBrowse response with root properties");
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, rsp_status, (byte)folder_depth,
+ mFolderItems.size(), ROOT_FOLDER);
+ }
+ } else {
+ Log.e(TAG, "Path Stack empty sending internal error !!!");
+ rsp_status = AvrcpConstants.RSP_INTERNAL_ERR;
+ mMediaInterface.setBrowsedPlayerRsp(mBDAddr, rsp_status, (byte)0x00, 0, null);
+ }
+ Log.d(TAG, "send setbrowse rsp status=" + rsp_status + " folder_depth=" + folder_depth);
+ }
+ }
+
+ public void TryReconnectBrowse(String packageName, String cls) {
+ Log.w(TAG, "Try reconnection with Browser service for package = " + packageName);
+ mConnectingPackageName = packageName;
+ mPackageName = packageName;
+ mClassName = cls;
+
+ /* cleanup variables from previous browsed calls */
+ mFolderItems = null;
+ mMediaId = null;
+ mRootFolderUid = null;
+ mPlayerRoot = false;
+
+ if (mPathStack != null)
+ mPathStack = null;
+ mPathStack = new Stack<String>();
+
+ if (mLocalPathCache != null)
+ mLocalPathCache = null;
+ mLocalPathCache = new Stack<String>();
+
+ MediaConnectionCallback callback = new MediaConnectionCallback(packageName);
+ MediaBrowser tempBrowser = new MediaBrowser(
+ mContext, new ComponentName(packageName, cls), callback, null);
+ callback.setBrowser(tempBrowser);
+ tempBrowser.connect();
+ Log.w(TAG, "Reconnected with Browser service");
+ }
+
+ public void setCurrentPackage(String packageName, String cls) {
+ Log.w(TAG, "Set current Browse based on Addr Player as " + packageName);
+ mCurrentBrowsePackage = packageName;
+ mCurrentBrowseClass = cls;
+ }
+
+ /* called when connection to media player is closed */
+ public void cleanup() {
+ if (DEBUG) {
+ Log.d(TAG, "cleanup");
+ }
+
+ if (mConnState != DISCONNECTED) {
+ if (mMediaBrowser != null) mMediaBrowser.disconnect();
+ }
+
+ mMediaHmap = null;
+ mFolderHmap = null;
+ mMediaController = null;
+ mMediaBrowser = null;
+ mPathStack = null;
+ mLocalPathCache = null;
+ mPlayerRoot = false;
+ }
+
+ public boolean isPlayerConnected() {
+ if (mMediaBrowser == null) {
+ if (DEBUG) {
+ Log.d(TAG, "isPlayerConnected: mMediaBrowser = null!");
+ }
+ return false;
+ }
+
+ return mMediaBrowser.isConnected();
+ }
+
+ /* returns number of items in new path as reponse */
+ public void changePath(byte[] folderUid, byte direction) {
+ if (DEBUG) {
+ Log.d(TAG, "changePath.direction = " + direction);
+ }
+ String newPath = "";
+
+ if (!isPlayerConnected()) {
+ Log.w(TAG, "changePath: disconnected from player service, sending internal error");
+ mMediaInterface.changePathRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR, 0);
+ return;
+ }
+
+ if (mMediaBrowser == null) {
+ Log.e(TAG, "Media browser is null, sending internal error");
+ mMediaInterface.changePathRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR, 0);
+ return;
+ }
+
+ /* check direction and change the path */
+ if (direction == AvrcpConstants.DIR_DOWN) { /* move down */
+ if ((newPath = byteToStringFolder(folderUid)) == null) {
+ Log.e(TAG, "Could not get media item from folder Uid, sending err response");
+ mMediaInterface.changePathRsp(mBDAddr, AvrcpConstants.RSP_INV_ITEM, 0);
+ } else if (!isBrowsableFolderDn(newPath)) {
+ /* new path is not browsable */
+ Log.e(TAG, "ItemUid received from changePath cmd is not browsable");
+ mMediaInterface.changePathRsp(mBDAddr, AvrcpConstants.RSP_INV_DIRECTORY, 0);
+ } else if (mPathStack.peek().equals(newPath)) {
+ /* new_folder is same as current folder */
+ Log.e(TAG, "new_folder is same as current folder, Invalid direction!");
+ mMediaInterface.changePathRsp(mBDAddr, AvrcpConstants.RSP_INV_DIRN, 0);
+ } else {
+ mMediaBrowser.subscribe(newPath, mFolderItemsCb);
+ String [] ExternalPath = newPath.split("/");
+ if (ExternalPath != null) {
+ Log.d(TAG,"external path length: " + ExternalPath.length);
+ if (ExternalPath.length == 1) {
+ //when external path length is 1 then extract the folder name from index 4
+ String folder_name = parseQueueId(newPath, BROWSED_FOLDER_ID_INDEX);
+ Log.d(TAG,"folder path: " + folder_name);
+ if (folder_name != null) {
+ mLocalPathCache.push(folder_name);
+ } else {
+ mLocalPathCache.push(newPath);
+ }
+ } else {
+ String folderPath = ExternalPath[ExternalPath.length - 1];
+ if (folderPath != null) {
+ Log.d(TAG,"folder path: " + folderPath);
+ mLocalPathCache.push(folderPath);
+ }
+ }
+ }
+ /* assume that call is success and update stack with new folder path */
+ mPathStack.push(newPath);
+ }
+ } else if (direction == AvrcpConstants.DIR_UP) { /* move up */
+ if (!isBrowsableFolderUp()) {
+ /* Already on the root, cannot allow up: PTS: test case TC_TG_MCN_CB_BI_02_C
+ * This is required, otherwise some CT will keep on sending change path up
+ * until they receive error */
+ Log.w(TAG, "Cannot go up from now, already in the root, Invalid direction!");
+ mMediaInterface.changePathRsp(mBDAddr, AvrcpConstants.RSP_INV_DIRN, 0);
+ } else {
+ /* move folder up */
+ mPathStack.pop();
+ mLocalPathCache.pop();
+ newPath = mPathStack.peek();
+ mMediaBrowser.subscribe(newPath, mFolderItemsCb);
+ }
+ } else { /* invalid direction */
+ Log.w(TAG, "changePath : Invalid direction " + direction);
+ mMediaInterface.changePathRsp(mBDAddr, AvrcpConstants.RSP_INV_DIRN, 0);
+ }
+ }
+
+ public void getItemAttr(AvrcpCmd.ItemAttrCmd itemAttr) {
+ String mediaID;
+ if (DEBUG) {
+ Log.d(TAG, "getItemAttr");
+ }
+
+ /* check if uid is valid by doing a lookup in hashmap */
+ mediaID = byteToStringMedia(itemAttr.mUid);
+ if (mediaID == null) {
+ Log.e(TAG, "uid is invalid");
+ mMediaInterface.getItemAttrRsp(mBDAddr, AvrcpConstants.RSP_INV_ITEM, null);
+ return;
+ }
+
+ /* check scope */
+ if (itemAttr.mScope != AvrcpConstants.BTRC_SCOPE_FILE_SYSTEM) {
+ Log.e(TAG, "invalid scope");
+ mMediaInterface.getItemAttrRsp(mBDAddr, AvrcpConstants.RSP_INV_SCOPE, null);
+ return;
+ }
+
+ if (mMediaBrowser == null) {
+ Log.e(TAG, "mMediaBrowser is null");
+ mMediaInterface.getItemAttrRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR, null);
+ return;
+ }
+
+ /* Subscribe to the parent to list items and retrieve the right one */
+ mMediaBrowser.subscribe(mPathStack.peek(), new ItemAttribSubscriber(itemAttr, mediaID));
+ }
+
+ public void getTotalNumOfItems(byte scope) {
+ if (DEBUG) {
+ Log.d(TAG, "getTotalNumOfItems scope = " + scope);
+ }
+ if (scope != AvrcpConstants.BTRC_SCOPE_FILE_SYSTEM) {
+ Log.e(TAG, "getTotalNumOfItems error" + scope);
+ mMediaInterface.getTotalNumOfItemsRsp(mBDAddr, AvrcpConstants.RSP_INV_SCOPE, 0, 0);
+ return;
+ }
+
+ if (mFolderItems == null) {
+ Log.e(TAG, "mFolderItems is null, sending internal error");
+ /* folderitems were not fetched during change path */
+ mMediaInterface.getTotalNumOfItemsRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR, 0, 0);
+ return;
+ }
+
+ /* find num items using size of already cached folder items */
+ mMediaInterface.getTotalNumOfItemsRsp(mBDAddr, AvrcpConstants.RSP_NO_ERROR, 0,
+ mFolderItems.size());
+ }
+
+ public void getFolderItemsVFS(AvrcpCmd.FolderItemsCmd reqObj) {
+ if (DEBUG) {
+ Log.d(TAG, "getFolderItemsVFS");
+ }
+ mFolderItemsReqObj = reqObj;
+
+ if ((mCurrentBrowsePackage != null) && (!mCurrentBrowsePackage.equals(mPackageName))) {
+ Log.w(TAG, "Try reconnection with Browser service as addressed pkg is changed = "
+ + mCurrentBrowsePackage + "from " + mPackageName);
+ TryReconnectBrowse(mCurrentBrowsePackage, mCurrentBrowseClass);
+ }
+
+ if (mFolderItems == null) {
+ /* Failed to fetch folder items from media player. Send error to remote device */
+ Log.e(TAG, "Failed to fetch folder items during getFolderItemsVFS");
+ mMediaInterface.folderItemsRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR, null);
+ return;
+ }
+
+ /* Filter attributes based on the request and send response to remote device */
+ getFolderItemsFilterAttr(mBDAddr, reqObj, mFolderItems,
+ AvrcpConstants.BTRC_SCOPE_FILE_SYSTEM, mFolderItemsReqObj.mStartItem,
+ mFolderItemsReqObj.mEndItem);
+ }
+
+ /* Instructs media player to play particular media item */
+ public void playItem(byte[] uid, byte scope) {
+ String folderUid;
+
+ if (isPlayerConnected()) {
+ /* check if uid is valid */
+ if ((folderUid = byteToStringMedia(uid)) == null) {
+ Log.e(TAG, "uid is invalid!");
+ mMediaInterface.playItemRsp(mBDAddr, AvrcpConstants.RSP_INV_ITEM);
+ return;
+ }
+
+ if (mMediaController != null) {
+ MediaController.TransportControls mediaControllerCntrl =
+ mMediaController.getTransportControls();
+ if (DEBUG) {
+ Log.d(TAG, "Sending playID: " + folderUid);
+ }
+
+ if (scope == AvrcpConstants.BTRC_SCOPE_FILE_SYSTEM) {
+ mediaControllerCntrl.playFromMediaId(folderUid, null);
+ mMediaInterface.playItemRsp(mBDAddr, AvrcpConstants.RSP_NO_ERROR);
+ } else {
+ Log.e(TAG, "playItem received for invalid scope!");
+ mMediaInterface.playItemRsp(mBDAddr, AvrcpConstants.RSP_INV_SCOPE);
+ }
+ } else {
+ Log.e(TAG, "mediaController is null");
+ mMediaInterface.playItemRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR);
+ }
+ } else {
+ Log.e(TAG, "playItem: Not connected to media player");
+ mMediaInterface.playItemRsp(mBDAddr, AvrcpConstants.RSP_INTERNAL_ERR);
+ }
+ }
+
+ /*
+ * helper method to check if startItem and endItem index is with range of
+ * MediaItem list. (Resultset containing all items in current path)
+ */
+ private List<MediaBrowser.MediaItem> checkIndexOutofBounds(byte[] bdaddr,
+ List<MediaBrowser.MediaItem> children, long startItem, long endItem) {
+ if (endItem >= children.size()) {
+ endItem = children.size() - 1;
+ }
+ if (startItem >= Integer.MAX_VALUE) {
+ startItem = Integer.MAX_VALUE;
+ }
+ try {
+ List<MediaBrowser.MediaItem> childrenSubList =
+ children.subList((int) startItem, (int) endItem + 1);
+ if (childrenSubList.isEmpty()) {
+ Log.i(TAG, "childrenSubList is empty.");
+ throw new IndexOutOfBoundsException();
+ }
+ return childrenSubList;
+ } catch (IndexOutOfBoundsException ex) {
+ Log.w(TAG, "Index out of bounds start item =" + startItem + " end item = " + Math.min(
+ children.size(), endItem + 1));
+ return null;
+ } catch (IllegalArgumentException ex) {
+ Log.i(TAG, "Index out of bounds start item =" + startItem + " > size");
+ return null;
+ }
+ }
+
+
+ /*
+ * helper method to filter required attibutes before sending GetFolderItems response
+ */
+ public void getFolderItemsFilterAttr(byte[] bdaddr, AvrcpCmd.FolderItemsCmd mFolderItemsReqObj,
+ List<MediaBrowser.MediaItem> children, byte scope, long startItem, long endItem) {
+ if (DEBUG) {
+ Log.d(TAG,
+ "getFolderItemsFilterAttr: startItem =" + startItem + ", endItem = " + endItem);
+ }
+
+ List<MediaBrowser.MediaItem> resultItems = new ArrayList<MediaBrowser.MediaItem>();
+
+ if (children == null) {
+ Log.e(TAG, "Error: children are null in getFolderItemsFilterAttr");
+ mMediaInterface.folderItemsRsp(bdaddr, AvrcpConstants.RSP_INV_RANGE, null);
+ return;
+ }
+
+ /* check for index out of bound errors */
+ resultItems = checkIndexOutofBounds(bdaddr, children, startItem, endItem);
+ if (resultItems == null) {
+ Log.w(TAG, "resultItems is null.");
+ mMediaInterface.folderItemsRsp(bdaddr, AvrcpConstants.RSP_INV_RANGE, null);
+ return;
+ }
+ FolderItemsData folderDataNative = new FolderItemsData(resultItems.size());
+
+ /* variables to temperorily add attrs */
+ ArrayList<String> attrArray = new ArrayList<String>();
+ ArrayList<Integer> attrId = new ArrayList<Integer>();
+
+ for (int itemIndex = 0; itemIndex < resultItems.size(); itemIndex++) {
+ /* item type. Needs to be set by media player */
+ MediaBrowser.MediaItem item = resultItems.get(itemIndex);
+ int flags = item.getFlags();
+ if ((flags & MediaBrowser.MediaItem.FLAG_BROWSABLE) != 0) {
+ folderDataNative.mItemTypes[itemIndex] = AvrcpConstants.BTRC_ITEM_FOLDER;
+ } else {
+ folderDataNative.mItemTypes[itemIndex] = AvrcpConstants.BTRC_ITEM_MEDIA;
+ }
+
+ /* set playable */
+ if ((flags & MediaBrowser.MediaItem.FLAG_PLAYABLE) != 0) {
+ folderDataNative.mPlayable[itemIndex] = AvrcpConstants.ITEM_PLAYABLE;
+ } else {
+ folderDataNative.mPlayable[itemIndex] = AvrcpConstants.ITEM_NOT_PLAYABLE;
+ }
+ /* set uid for current item */
+ byte[] uid;
+ if (folderDataNative.mItemTypes[itemIndex] == AvrcpConstants.BTRC_ITEM_MEDIA)
+ uid = stringToByteMedia(item.getDescription().getMediaId(), BROWSED_ITEM_ID_INDEX);
+ else
+ uid = stringToByteFolder(item.getDescription().getMediaId());
+
+ for (int idx = 0; idx < AvrcpConstants.UID_SIZE; idx++) {
+ folderDataNative.mItemUid[itemIndex * AvrcpConstants.UID_SIZE + idx] = uid[idx];
+ }
+
+ /* Set display name for current item */
+ folderDataNative.mDisplayNames[itemIndex] =
+ getAttrValue(bdaddr, AvrcpConstants.ATTRID_TITLE, item);
+
+ int maxAttributesRequested = 0;
+ boolean isAllAttribRequested = false;
+ /* check if remote requested for attributes */
+ if (mFolderItemsReqObj.mNumAttr != AvrcpConstants.NUM_ATTR_NONE) {
+ int attrCnt = 0;
+
+ /* add requested attr ids to a temp array */
+ if (mFolderItemsReqObj.mNumAttr == AvrcpConstants.NUM_ATTR_ALL) {
+ isAllAttribRequested = true;
+ maxAttributesRequested = AvrcpConstants.MAX_NUM_ATTR;
+ } else {
+ /* get only the requested attribute ids from the request */
+ maxAttributesRequested = mFolderItemsReqObj.mNumAttr;
+ }
+
+ /* lookup and copy values of attributes for ids requested above */
+ for (int idx = 0; idx < maxAttributesRequested; idx++) {
+ /* check if media player provided requested attributes */
+ String value = null;
+
+ int attribId =
+ isAllAttribRequested ? (idx + 1) : mFolderItemsReqObj.mAttrIDs[idx];
+ value = getAttrValue(bdaddr, attribId, resultItems.get(itemIndex));
+ if (value != null) {
+ attrArray.add(value);
+ attrId.add(attribId);
+ attrCnt++;
+ }
+ }
+ /* add num attr actually received from media player for a particular item */
+ folderDataNative.mAttributesNum[itemIndex] = attrCnt;
+ }
+ }
+
+ /* copy filtered attr ids and attr values to response parameters */
+ if (attrId.size() > 0) {
+ folderDataNative.mAttrIds = new int[attrId.size()];
+ for (int attrIndex = 0; attrIndex < attrId.size(); attrIndex++) {
+ folderDataNative.mAttrIds[attrIndex] = attrId.get(attrIndex);
+ }
+ folderDataNative.mAttrValues = attrArray.toArray(new String[attrArray.size()]);
+ }
+
+ /* create rsp object and send response to remote device */
+ FolderItemsRsp rspObj =
+ new FolderItemsRsp(AvrcpConstants.RSP_NO_ERROR, Avrcp.sUIDCounter, scope,
+ folderDataNative.mNumItems, folderDataNative.mFolderTypes,
+ folderDataNative.mPlayable, folderDataNative.mItemTypes,
+ folderDataNative.mItemUid, folderDataNative.mDisplayNames,
+ folderDataNative.mAttributesNum, folderDataNative.mAttrIds,
+ folderDataNative.mAttrValues);
+ mMediaInterface.folderItemsRsp(bdaddr, AvrcpConstants.RSP_NO_ERROR, rspObj);
+ }
+
+ public String getAttrValue(byte []bdaddr, int attr, MediaBrowser.MediaItem item) {
+ String attrValue = null;
+ try {
+ MediaDescription desc = item.getDescription();
+ Bundle extras = desc.getExtras();
+ switch (attr) {
+ /* Title is mandatory attribute */
+ case AvrcpConstants.ATTRID_TITLE:
+ attrValue = desc.getTitle().toString();
+ break;
+
+ case AvrcpConstants.ATTRID_ARTIST:
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_ARTIST);
+ break;
+
+ case AvrcpConstants.ATTRID_ALBUM:
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_ALBUM);
+ break;
+
+ case AvrcpConstants.ATTRID_TRACK_NUM:
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_TRACK_NUMBER);
+ break;
+
+ case AvrcpConstants.ATTRID_NUM_TRACKS:
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_NUM_TRACKS);
+ break;
+
+ case AvrcpConstants.ATTRID_GENRE:
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_GENRE);
+ break;
+
+ case AvrcpConstants.ATTRID_PLAY_TIME:
+ attrValue = extras.getString(MediaMetadata.METADATA_KEY_DURATION);
+ break;
+
+ case AvrcpConstants.ATTRID_COVER_ART:
+ attrValue = Avrcp_ext.getImgHandleFromTitle(bdaddr,
+ desc.getTitle().toString());
+ break;
+
+ default:
+ Log.e(TAG, "getAttrValue: Unknown attribute ID requested: " + attr);
+ return null;
+ }
+ } catch (NullPointerException ex) {
+ Log.w(TAG, "getAttrValue: attr id not found in result");
+ /* checking if attribute is title, then it is mandatory and cannot send null */
+ if (attr == AvrcpConstants.ATTRID_TITLE) {
+ attrValue = "<Unknown Title>";
+ } else {
+ return null;
+ }
+ }
+ if (DEBUG) {
+ Log.d(TAG, "getAttrValue: attrvalue = " + attrValue + " attr id: " + attr);
+ }
+ return attrValue;
+ }
+
+
+ public String getPackageName() {
+ return mPackageName;
+ }
+
+ /* Helper methods */
+
+ /* check if item is browsable Down*/
+ private boolean isBrowsableFolderDn(String uid) {
+ for (MediaBrowser.MediaItem item : mFolderItems) {
+ if (item.getMediaId().equals(uid) && (
+ (item.getFlags() & MediaBrowser.MediaItem.FLAG_BROWSABLE)
+ == MediaBrowser.MediaItem.FLAG_BROWSABLE)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /* check if browsable Up*/
+ private boolean isBrowsableFolderUp() {
+ if (mPathStack.peek().equals(mRootFolderUid)) {
+ /* Already on the root, cannot go up */
+ return false;
+ }
+ return true;
+ }
+
+ private String parseQueueId(String mediaId, int mId) {
+ if (isNumeric(mediaId)) {
+ Log.d(TAG, "Get queue id: " + mediaId);
+ return mediaId.trim();
+ } else {
+ String[] mediaIdItems = mediaId.split(",");
+ if (mediaIdItems != null && mediaIdItems.length > mId) {
+ Log.d(TAG, "Get queue id: " + mediaIdItems[mId]);
+ return mediaIdItems[mId].trim();
+ }
+ }
+
+ Log.d(TAG, "Unkown queue id");
+ return null;
+ }
+
+ /* convert uid to mediaId for Media item*/
+ private String byteToStringMedia(byte[] byteArray) {
+ int uid = new BigInteger(byteArray).intValue();
+ String mediaId = mMediaHmap.get(uid);
+ return mediaId;
+ }
+
+ /* convert uid to mediaId for Folder item*/
+ private String byteToStringFolder(byte[] byteArray) {
+ int uid = new BigInteger(byteArray).intValue();
+ String mediaId = mFolderHmap.get(uid);
+ return mediaId;
+ }
+
+ /* convert mediaId to uid for Media item*/
+ private byte[] stringToByteMedia(String mediaId, int id) {
+ /* check if this mediaId already exists in hashmap */
+ if (!mMediaHmap.containsValue(mediaId)) { /* add to hashmap */
+ int uid;
+ String queueId = parseQueueId(mediaId, id);
+ if (queueId == null) {
+ uid = mMediaHmap.size() + 1;
+ } else {
+ uid = Integer.valueOf(queueId).intValue();
+ }
+
+ mMediaHmap.put(uid, mediaId);
+ return intToByteArray(uid);
+ } else { /* search key for give mediaId */
+ for (int uid : mMediaHmap.keySet()) {
+ if (mMediaHmap.get(uid).equals(mediaId)) {
+ return intToByteArray(uid);
+ }
+ }
+ }
+ return null;
+ }
+
+ /* convert mediaId to uid for Folder item*/
+ private byte[] stringToByteFolder(String mediaId) {
+ /* check if this mediaId already exists in hashmap */
+ if (!mFolderHmap.containsValue(mediaId)) { /* add to hashmap */
+ // Offset by one as uid 0 is reserved
+ int uid = mFolderHmap.size() + 1;
+ mFolderHmap.put(uid, mediaId);
+ return intToByteArray(uid);
+ } else { /* search key for give mediaId */
+ for (int uid : mFolderHmap.keySet()) {
+ if (mFolderHmap.get(uid).equals(mediaId)) {
+ return intToByteArray(uid);
+ }
+ }
+ }
+ return null;
+ }
+
+ private void refreshFolderItems(List<MediaBrowser.MediaItem> folderItems) {
+ for (int itemIndex = 0; itemIndex < folderItems.size(); itemIndex++) {
+ MediaBrowser.MediaItem item = folderItems.get(itemIndex);
+ int flags = item.getFlags();
+ if ((flags & MediaBrowser.MediaItem.FLAG_BROWSABLE) != 0) {
+ Log.d(TAG, "Folder item, no need refresh hashmap from mediaId to uid");
+ } else {
+ Log.d(TAG, "Media item, refresh haspmap from mediaId to uid");
+ stringToByteMedia(item.getDescription().getMediaId(), BROWSED_ITEM_ID_INDEX);
+ }
+ }
+ }
+
+ /* converts queue item received from getQueue call, to MediaItem used by FilterAttr method */
+ private List<MediaBrowser.MediaItem> queueItem2MediaItem(
+ List<MediaSession.QueueItem> tempItems) {
+
+ List<MediaBrowser.MediaItem> tempMedia = new ArrayList<MediaBrowser.MediaItem>();
+ for (int itemCount = 0; itemCount < tempItems.size(); itemCount++) {
+ MediaDescription.Builder build = new MediaDescription.Builder();
+ build.setMediaId(Long.toString(tempItems.get(itemCount).getQueueId()));
+ build.setTitle(tempItems.get(itemCount).getDescription().getTitle());
+ build.setExtras(tempItems.get(itemCount).getDescription().getExtras());
+ MediaDescription des = build.build();
+ MediaItem item = new MediaItem((des), MediaItem.FLAG_PLAYABLE);
+ tempMedia.add(item);
+ }
+ return tempMedia;
+ }
+
+ /* convert integer to byte array of size 8 bytes */
+ public byte[] intToByteArray(int value) {
+ int index = 0;
+ byte[] encodedValue = new byte[AvrcpConstants.UID_SIZE];
+
+ encodedValue[index++] = (byte) 0x00;
+ encodedValue[index++] = (byte) 0x00;
+ encodedValue[index++] = (byte) 0x00;
+ encodedValue[index++] = (byte) 0x00;
+ encodedValue[index++] = (byte) (value >> 24);
+ encodedValue[index++] = (byte) (value >> 16);
+ encodedValue[index++] = (byte) (value >> 8);
+ encodedValue[index++] = (byte) value;
+
+ return encodedValue;
+ }
+
+ public boolean isNumeric(String mediaId) {
+ String trimStr = mediaId.trim();
+ int length = trimStr.length();
+
+ for(int i = 0; i < length; i++) {
+ char c = trimStr.charAt(i);
+ if (!((c >= '0' && c <= '9'))) {
+ Log.v(TAG, "Non-Numeric media Id");
+ return false;
+ }
+ }
+ Log.v(TAG, "Numeric media Id");
+ return true;
+ }
+}
diff --git a/src/com/android/bluetooth/avrcp/mockable/MediaController.java b/src/com/android/bluetooth/avrcp/mockable/MediaController.java
index 5c7b73f..934a454 100644
--- a/src/com/android/bluetooth/avrcp/mockable/MediaController.java
+++ b/src/com/android/bluetooth/avrcp/mockable/MediaController.java
@@ -44,13 +44,13 @@
public android.media.session.MediaController.TransportControls mTransportDelegate;
public TransportControls mTransportControls;
- MediaController(@NonNull android.media.session.MediaController delegate) {
+ public MediaController(@NonNull android.media.session.MediaController delegate) {
mDelegate = delegate;
mTransportDelegate = delegate.getTransportControls();
mTransportControls = new TransportControls();
}
- MediaController(Context context, MediaSession.Token token) {
+ public MediaController(Context context, MediaSession.Token token) {
mDelegate = new android.media.session.MediaController(context, token);
mTransportDelegate = mDelegate.getTransportControls();
mTransportControls = new TransportControls();
@@ -65,169 +65,101 @@
return mTransportControls;
}
- /**
- * Wrapper for MediaController.dispatchMediaButtonEvent(KeyEvent keyEvent)
- */
public boolean dispatchMediaButtonEvent(@NonNull KeyEvent keyEvent) {
return mDelegate.dispatchMediaButtonEvent(keyEvent);
}
- /**
- * Wrapper for MediaController.getPlaybackState()
- */
@Nullable
public PlaybackState getPlaybackState() {
return mDelegate.getPlaybackState();
}
-
- /**
- * Wrapper for MediaController.getMetadata()
- */
@Nullable
public MediaMetadata getMetadata() {
return mDelegate.getMetadata();
}
- /**
- * Wrapper for MediaController.getQueue()
- */
@Nullable
public List<MediaSession.QueueItem> getQueue() {
return mDelegate.getQueue();
}
- /**
- * Wrapper for MediaController.getQueueTitle()
- */
@Nullable
public CharSequence getQueueTitle() {
return mDelegate.getQueueTitle();
}
- /**
- * Wrapper for MediaController.getExtras()
- */
@Nullable
public Bundle getExtras() {
return mDelegate.getExtras();
}
- /**
- * Wrapper for MediaController.getRatingType()
- */
public int getRatingType() {
return mDelegate.getRatingType();
}
- /**
- * Wrapper for MediaController.getFlags()
- */
public long getFlags() {
return mDelegate.getFlags();
}
- /**
- * Wrapper for MediaController.getPlaybackInfo()
- */
@Nullable
public android.media.session.MediaController.PlaybackInfo getPlaybackInfo() {
return mDelegate.getPlaybackInfo();
}
-
- /**
- * Wrapper for MediaController.getSessionActivity()
- */
@Nullable
public PendingIntent getSessionActivity() {
return mDelegate.getSessionActivity();
}
- /**
- * Wrapper for MediaController.getSessionToken()
- */
@NonNull
public MediaSession.Token getSessionToken() {
return mDelegate.getSessionToken();
}
- /**
- * Wrapper for MediaController.setVolumeTo(int value, int flags)
- */
public void setVolumeTo(int value, int flags) {
mDelegate.setVolumeTo(value, flags);
}
- /**
- * Wrapper for MediaController.adjustVolume(int direction, int flags)
- */
public void adjustVolume(int direction, int flags) {
mDelegate.adjustVolume(direction, flags);
}
- /**
- * Wrapper for MediaController.registerCallback(Callback callback)
- */
public void registerCallback(@NonNull Callback callback) {
//TODO(apanicke): Add custom callback struct to be able to analyze and
// delegate callbacks
mDelegate.registerCallback(callback);
}
- /**
- * Wrapper for MediaController.registerCallback(Callback callback, Handler handler)
- */
public void registerCallback(@NonNull Callback callback, @Nullable Handler handler) {
mDelegate.registerCallback(callback, handler);
}
- /**
- * Wrapper for MediaController.unregisterCallback(Callback callback)
- */
public void unregisterCallback(@NonNull Callback callback) {
mDelegate.unregisterCallback(callback);
}
- /**
- * Wrapper for MediaController.sendCommand(String command, Bundle args, ResultReceiver cb)
- */
public void sendCommand(@NonNull String command, @Nullable Bundle args,
@Nullable ResultReceiver cb) {
mDelegate.sendCommand(command, args, cb);
}
- /**
- * Wrapper for MediaController.getPackageName()
- */
public String getPackageName() {
return mDelegate.getPackageName();
}
- /**
- * Wrapper for MediaController.getTag()
- */
public String getTag() {
return mDelegate.getTag();
}
- /**
- * Wrapper for MediaController.controlsSameSession(MediaController other)
- */
public boolean controlsSameSession(MediaController other) {
return mDelegate.controlsSameSession(other.getWrappedInstance());
}
- /**
- * Wrapper for MediaController.controlsSameSession(MediaController other)
- */
public boolean controlsSameSession(android.media.session.MediaController other) {
return mDelegate.controlsSameSession(other);
}
- /**
- * Wrapper for MediaController.equals(Object other)
- */
@Override
public boolean equals(Object o) {
if (o instanceof android.media.session.MediaController) {
@@ -239,9 +171,6 @@
return false;
}
- /**
- * Wrapper for MediaController.toString()
- */
@Override
public String toString() {
MediaMetadata data = getMetadata();
@@ -250,146 +179,83 @@
mDelegate.hashCode()) + ") " + desc;
}
- /**
- * Wrapper for MediaController.Callback
- */
public abstract static class Callback extends android.media.session.MediaController.Callback {}
- /**
- * Wrapper for MediaController.TransportControls
- */
public class TransportControls {
- /**
- * Wrapper for MediaController.TransportControls.prepare()
- */
public void prepare() {
mTransportDelegate.prepare();
}
- /**
- * Wrapper for MediaController.TransportControls.prepareFromMediaId()
- */
public void prepareFromMediaId(String mediaId, Bundle extras) {
mTransportDelegate.prepareFromMediaId(mediaId, extras);
}
- /**
- * Wrapper for MediaController.TransportControls.prepareFromSearch()
- */
public void prepareFromSearch(String query, Bundle extras) {
mTransportDelegate.prepareFromSearch(query, extras);
}
- /**
- * Wrapper for MediaController.TransportControls.prepareFromUri()
- */
public void prepareFromUri(Uri uri, Bundle extras) {
mTransportDelegate.prepareFromUri(uri, extras);
}
- /**
- * Wrapper for MediaController.TransportControls.play()
- */
public void play() {
mTransportDelegate.play();
}
- /**
- * Wrapper for MediaController.TransportControls.playFromMediaId()
- */
public void playFromMediaId(String mediaId, Bundle extras) {
mTransportDelegate.playFromMediaId(mediaId, extras);
}
- /**
- * Wrapper for MediaController.TransportControls.playFromSearch()
- */
public void playFromSearch(String query, Bundle extras) {
mTransportDelegate.playFromSearch(query, extras);
}
- /**
- * Wrapper for MediaController.TransportControls.playFromUri()
- */
public void playFromUri(Uri uri, Bundle extras) {
mTransportDelegate.playFromUri(uri, extras);
}
- /**
- * Wrapper for MediaController.TransportControls.skipToQueueItem()
- */
public void skipToQueueItem(long id) {
mTransportDelegate.skipToQueueItem(id);
}
- /**
- * Wrapper for MediaController.TransportControls.pause()
- */
public void pause() {
mTransportDelegate.pause();
}
- /**
- * Wrapper for MediaController.TransportControls.stop()
- */
public void stop() {
mTransportDelegate.stop();
}
- /**
- * Wrapper for MediaController.TransportControls.seekTo()
- */
public void seekTo(long pos) {
mTransportDelegate.seekTo(pos);
}
- /**
- * Wrapper for MediaController.TransportControls.fastForward()
- */
public void fastForward() {
mTransportDelegate.fastForward();
}
- /**
- * Wrapper for MediaController.TransportControls.skipToNext()
- */
public void skipToNext() {
mTransportDelegate.skipToNext();
}
- /**
- * Wrapper for MediaController.TransportControls.rewind()
- */
public void rewind() {
mTransportDelegate.rewind();
}
- /**
- * Wrapper for MediaController.TransportControls.skipToPrevious()
- */
public void skipToPrevious() {
mTransportDelegate.skipToPrevious();
}
- /**
- * Wrapper for MediaController.TransportControls.setRating()
- */
public void setRating(Rating rating) {
mTransportDelegate.setRating(rating);
}
- /**
- * Wrapper for MediaController.TransportControls.sendCustomAction()
- */
public void sendCustomAction(@NonNull PlaybackState.CustomAction customAction,
@Nullable Bundle args) {
mTransportDelegate.sendCustomAction(customAction, args);
}
- /**
- * Wrapper for MediaController.TransportControls.sendCustomAction()
- */
public void sendCustomAction(@NonNull String action, @Nullable Bundle args) {
mTransportDelegate.sendCustomAction(action, args);
}
diff --git a/src/com/android/bluetooth/avrcpcontroller/AvrcpControllerService.java b/src/com/android/bluetooth/avrcpcontroller/AvrcpControllerService.java
index 56684cd..e51cacf 100644
--- a/src/com/android/bluetooth/avrcpcontroller/AvrcpControllerService.java
+++ b/src/com/android/bluetooth/avrcpcontroller/AvrcpControllerService.java
@@ -25,6 +25,7 @@
import android.media.MediaDescription;
import android.media.browse.MediaBrowser.MediaItem;
import android.media.session.PlaybackState;
+import android.os.Message;
import android.os.Bundle;
import android.util.Log;
@@ -39,14 +40,17 @@
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
+import android.content.res.Resources;
+import android.content.res.Resources.NotFoundException;
+
/**
* Provides Bluetooth AVRCP Controller profile, as a service in the Bluetooth application.
*/
public class AvrcpControllerService extends ProfileService {
static final String TAG = "AvrcpControllerService";
static final int MAXIMUM_CONNECTED_DEVICES = 5;
- static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
- static final boolean VDBG = Log.isLoggable(TAG, Log.VERBOSE);
+ static final boolean DBG = true;
+ static final boolean VDBG = true;
public static final String MEDIA_ITEM_UID_KEY = "media-item-uid-key";
/*
@@ -90,10 +94,42 @@
public static final int KEY_STATE_PRESSED = 0;
public static final int KEY_STATE_RELEASED = 1;
+ public static final String ACTION_TRACK_EVENT =
+ "android.bluetooth.avrcp-controller.profile.action.TRACK_EVENT";
+ public static final String EXTRA_PLAYBACK =
+ "android.bluetooth.avrcp-controller.profile.extra.PLAYBACK";
+
+
+ /**
+ * Intent used to broadcast the change of folder list.
+ *
+ * <p>This intent will have the one extra:
+ * <ul>
+ * <li> {@link #EXTRA_FOLDER_LIST} - array of {@link MediaBrowser#MediaItem}
+ * containing the folder listing of currently selected folder.
+ * </ul>
+ */
+ public static final String ACTION_FOLDER_LIST =
+ "android.bluetooth.avrcp-controller.profile.action.FOLDER_LIST";
+
+ public static final String EXTRA_FOLDER_LIST =
+ "android.bluetooth.avrcp-controller.profile.extra.FOLDER_LIST";
+
+ public static final String EXTRA_FOLDER_ID = "com.android.bluetooth.avrcp.EXTRA_FOLDER_ID";
+ public static final String EXTRA_FOLDER_BT_ID =
+ "com.android.bluetooth.avrcp-controller.EXTRA_FOLDER_BT_ID";
+
+ public static final String EXTRA_METADATA =
+ "android.bluetooth.avrcp-controller.profile.extra.METADATA";
+
+
static BrowseTree sBrowseTree;
private static AvrcpControllerService sService;
private final BluetoothAdapter mAdapter;
+ private int mFeatures;
+ private int mCaPsm;
+
protected Map<BluetoothDevice, AvrcpControllerStateMachine> mDeviceStateMap =
new ConcurrentHashMap<>(1);
@@ -123,6 +159,7 @@
Intent stopIntent = new Intent(this, BluetoothMediaBrowserService.class);
stopService(stopIntent);
for (AvrcpControllerStateMachine stateMachine : mDeviceStateMap.values()) {
+ stateMachine.doQuit();
stateMachine.quitNow();
}
@@ -297,6 +334,11 @@
StackEvent event =
StackEvent.connectionStateChanged(remoteControlConnected, browsingConnected);
AvrcpControllerStateMachine stateMachine = getOrCreateStateMachine(device);
+ if (stateMachine == null) {
+ Log.e(TAG, "onConnectionStateChanged: mAvrcpCtSm is null, return");
+ return;
+ }
+
if (remoteControlConnected || browsingConnected) {
stateMachine.connect(event);
} else {
@@ -305,8 +347,24 @@
}
// Called by JNI to notify Avrcp of features supported by the Remote device.
- private void getRcFeatures(byte[] address, int features) {
- /* Do Nothing. */
+ private void getRcFeatures(byte[] address, int features, int caPsm) {
+ Log.i(TAG, " getRcFeatures caPsm :" + caPsm);
+ mFeatures = features;
+ mCaPsm = caPsm;
+ BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address);
+ AvrcpControllerStateMachine stateMachine = getStateMachine(device);
+ if (stateMachine == null) {
+ Log.e(TAG, "getRcFeatures: AvrcpControllerStateMachine is null for device: " + device);
+ return;
+ }
+
+ try {
+ stateMachine.sendMessage(
+ AvrcpControllerStateMachine.MESSAGE_PROCESS_RC_FEATURES, features, caPsm, device);
+ } catch(Exception ee) {
+ Log.i(TAG, "getRcFeatures exception occured.");
+ ee.printStackTrace();
+ }
}
// Called by JNI
@@ -323,7 +381,8 @@
AvrcpControllerStateMachine stateMachine = getStateMachine(device);
if (stateMachine != null) {
stateMachine.sendMessage(
- AvrcpControllerStateMachine.MESSAGE_PROCESS_REGISTER_ABS_VOL_NOTIFICATION);
+ AvrcpControllerStateMachine.MESSAGE_PROCESS_REGISTER_ABS_VOL_NOTIFICATION,
+ (int) label);
}
}
@@ -336,7 +395,7 @@
AvrcpControllerStateMachine stateMachine = getStateMachine(device);
if (stateMachine != null) {
stateMachine.sendMessage(AvrcpControllerStateMachine.MESSAGE_PROCESS_SET_ABS_VOL_CMD,
- absVol);
+ absVol, label);
}
}
@@ -350,11 +409,31 @@
BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address);
AvrcpControllerStateMachine stateMachine = getStateMachine(device);
if (stateMachine != null) {
- stateMachine.sendMessage(AvrcpControllerStateMachine.MESSAGE_PROCESS_TRACK_CHANGED,
- TrackInfo.getMetadata(attributes, attribVals));
+ List<Integer> attrList = new ArrayList<>();
+ for (int attr : attributes) {
+ attrList.add(attr);
+ }
+ List<String> attrValList = Arrays.asList(attribVals);
+ TrackInfo trackInfo = new TrackInfo(attrList, attrValList);
+ stateMachine.sendMessage(AvrcpControllerStateMachine.MESSAGE_PROCESS_TRACK_CHANGED, trackInfo);
}
+
}
+ private void onElementAttributeUpdate(byte[] address, byte numAttributes, int[] attributes,
+ String[] attribVals) {
+ if (DBG) {
+ Log.d(TAG, "onElementAttributeUpdate");
+ }
+ BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address);
+ AvrcpControllerStateMachine stateMachine = getStateMachine(device);
+ if (stateMachine == null)
+ return;
+ CoverArtUtils coverArtUtils = new CoverArtUtils();
+ coverArtUtils.onElementAttributeUpdate(address, numAttributes, attributes, attribVals,
+ device, stateMachine);
+ }
+
// Called by JNI periodically based upon timer to update play position
private synchronized void onPlayPositionChanged(byte[] address, int songLen,
int currSongPosition) {
@@ -643,10 +722,7 @@
return true;
}
- /**
- * Remove state machine from device map once it is no longer needed.
- */
- public void removeStateMachine(AvrcpControllerStateMachine stateMachine) {
+ void removeStateMachine(AvrcpControllerStateMachine stateMachine) {
mDeviceStateMap.remove(stateMachine.getDevice());
}
@@ -663,7 +739,10 @@
if (stateMachine == null) {
stateMachine = newStateMachine(device);
mDeviceStateMap.put(device, stateMachine);
+ Log.d(TAG, "AvrcpControllerStateMachine start() called: " + device);
stateMachine.start();
+ Log.d(TAG, "AvrcpcontrollerSM started for device: " + device);
+ stateMachine.registerReceiver(device);
}
return stateMachine;
}
@@ -693,6 +772,15 @@
: stateMachine.getState();
}
+ public void onDeviceUpdated(BluetoothDevice device) {
+ AvrcpControllerStateMachine stateMachine = mDeviceStateMap.get(device);
+ if (stateMachine != null) {
+ Log.d(TAG, "Send device: " + device + " updated meassage to Avrcpstatemachine");
+ stateMachine.sendMessage(AvrcpControllerStateMachine.MSG_DEVICE_UPDATED,
+ device);
+ }
+ }
+
@Override
public void dump(StringBuilder sb) {
super.dump(sb);
@@ -729,7 +817,7 @@
* @param keyState state
* @return command was sent
*/
- public native boolean sendGroupNavigationCommandNative(byte[] address, int keyCode,
+ static native boolean sendGroupNavigationCommandNative(byte[] address, int keyCode,
int keyState);
/**
@@ -739,7 +827,7 @@
* @param attribIds list of settings to be changed
* @param attribVal list of settings values
*/
- public native void setPlayerApplicationSettingValuesNative(byte[] address, byte numAttrib,
+ static native void setPlayerApplicationSettingValuesNative(byte[] address, byte numAttrib,
byte[] attribIds, byte[] attribVal);
/**
@@ -748,7 +836,7 @@
* @param absVol new volume
* @param label label
*/
- public native void sendAbsVolRspNative(byte[] address, int absVol, int label);
+ static native void sendAbsVolRspNative(byte[] address, int absVol, int label);
/**
* Register for any volume level changes
@@ -757,13 +845,13 @@
* @param absVol current volume
* @param label label
*/
- public native void sendRegisterAbsVolRspNative(byte[] address, byte rspType, int absVol,
+ static native void sendRegisterAbsVolRspNative(byte[] address, byte rspType, int absVol,
int label);
/**
* Fetch the playback state
*/
- public native void getPlaybackStateNative(byte[] address);
+ static native void getPlaybackStateNative(byte[] address);
/**
* Fetch the current now playing list
@@ -771,7 +859,7 @@
* @param start first index to retrieve
* @param end last index to retrieve
*/
- public native void getNowPlayingListNative(byte[] address, int start, int end);
+ static native void getNowPlayingListNative(byte[] address, int start, int end);
/**
* Fetch the current folder's listing
@@ -779,7 +867,7 @@
* @param start first index to retrieve
* @param end last index to retrieve
*/
- public native void getFolderListNative(byte[] address, int start, int end);
+ static native void getFolderListNative(byte[] address, int start, int end);
/**
* Fetch the listing of players
@@ -787,7 +875,7 @@
* @param start first index to retrieve
* @param end last index to retrieve
*/
- public native void getPlayerListNative(byte[] address, int start, int end);
+ static native void getPlayerListNative(byte[] address, int start, int end);
/**
* Change the current browsed folder
@@ -795,7 +883,7 @@
* @param direction up/down
* @param uid folder unique id
*/
- public native void changeFolderPathNative(byte[] address, byte direction, long uid);
+ static native void changeFolderPathNative(byte[] address, byte direction, long uid);
/**
* Play item with provided uid
@@ -804,19 +892,23 @@
* @param uid song unique id
* @param uidCounter counter
*/
- public native void playItemNative(byte[] address, byte scope, long uid, int uidCounter);
+ static native void playItemNative(byte[] address, byte scope, long uid, int uidCounter);
/**
* Set a specific player for browsing
*
* @param playerId player number
*/
- public native void setBrowsedPlayerNative(byte[] address, int playerId);
+ static native void setBrowsedPlayerNative(byte[] address, int playerId);
/**
* Set a specific player for handling playback commands
*
* @param playerId player number
*/
- public native void setAddressedPlayerNative(byte[] address, int playerId);
+ static native void setAddressedPlayerNative(byte[] address, int playerId);
+
+ /* This api is used to fetch ElementAttributes */
+ native static void getElementAttributesNative(byte[] address, byte numAttributes,
+ byte[] attribIds);
}
diff --git a/src/com/android/bluetooth/avrcpcontroller/AvrcpControllerStateMachine.java b/src/com/android/bluetooth/avrcpcontroller/AvrcpControllerStateMachine.java
index c319364..e5c5e87 100644
--- a/src/com/android/bluetooth/avrcpcontroller/AvrcpControllerStateMachine.java
+++ b/src/com/android/bluetooth/avrcpcontroller/AvrcpControllerStateMachine.java
@@ -16,9 +16,12 @@
package com.android.bluetooth.avrcpcontroller;
+import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothAvrcpController;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
+import android.content.BroadcastReceiver;
+import android.content.IntentFilter;
import android.content.Context;
import android.content.Intent;
import android.media.AudioManager;
@@ -49,11 +52,12 @@
*/
class AvrcpControllerStateMachine extends StateMachine {
static final String TAG = "AvrcpControllerStateMachine";
- static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
+ static final boolean DBG = true;
//0->99 Events from Outside
public static final int CONNECT = 1;
public static final int DISCONNECT = 2;
+ public static final int MSG_DEVICE_UPDATED = 3;
//100->199 Internal Events
protected static final int CLEANUP = 100;
@@ -79,6 +83,7 @@
static final int MESSAGE_PROCESS_NOW_PLAYING_CONTENTS_CHANGED = 216;
static final int MESSAGE_PROCESS_SUPPORTED_APPLICATION_SETTINGS = 217;
static final int MESSAGE_PROCESS_CURRENT_APPLICATION_SETTINGS = 218;
+ static final int MESSAGE_PROCESS_RC_FEATURES = 219;
//300->399 Events for Browsing
static final int MESSAGE_GET_FOLDER_ITEMS = 300;
@@ -104,21 +109,30 @@
private final boolean mIsVolumeFixed;
protected final BluetoothDevice mDevice;
+ private BluetoothDevice mA2dpDevice = null;
protected final byte[] mDeviceAddress;
protected final AvrcpControllerService mService;
protected final Disconnected mDisconnected;
protected final Connecting mConnecting;
protected final Connected mConnected;
protected final Disconnecting mDisconnecting;
+ private A2dpSinkService mA2dpSinkService;
+
+ private static CoverArtUtils mCoveArtUtils;
+ private AvrcpControllerBipStateMachine mBipStateMachine;
protected int mMostRecentState = BluetoothProfile.STATE_DISCONNECTED;
boolean mRemoteControlConnected = false;
boolean mBrowsingConnected = false;
final BrowseTree mBrowseTree;
+ private boolean smActive = false;
private AvrcpPlayer mAddressedPlayer = new AvrcpPlayer();
+ private RemoteDevice mRemoteDevice;
+ private int mPreviousPercentageVol = -1;
private int mAddressedPlayerId = -1;
private SparseArray<AvrcpPlayer> mAvailablePlayerList = new SparseArray<AvrcpPlayer>();
+ // Only accessed from State Machine processMessage
private int mVolumeChangedNotificationsToIgnore = 0;
private int mVolumeNotificationLabel = -1;
@@ -131,6 +145,7 @@
AvrcpControllerStateMachine(BluetoothDevice device, AvrcpControllerService service) {
super(TAG);
+ setDbg(DBG);
mDevice = device;
mDeviceAddress = Utils.getByteAddress(mDevice);
mService = service;
@@ -147,11 +162,19 @@
addState(mConnected);
addState(mDisconnecting);
+ smActive = true;
mGetFolderList = new GetFolderList();
addState(mGetFolderList, mConnected);
+
+ mRemoteDevice = new RemoteDevice(device);
+
mAudioManager = (AudioManager) service.getSystemService(Context.AUDIO_SERVICE);
mIsVolumeFixed = mAudioManager.isVolumeFixed();
+ mCoveArtUtils = new CoverArtUtils();
+ mBipStateMachine = AvrcpControllerBipStateMachine.make(this, getHandler(), service);
+
+ Log.d(TAG, "Setting initial state: Disconnected: " + mDevice);
setInitialState(mDisconnected);
}
@@ -219,7 +242,7 @@
}
synchronized void onBrowsingConnected() {
- if (mBrowsingConnected) return;
+ if (mBrowsingConnected || (!smActive)) return;
mService.sBrowseTree.mRootNode.addChild(mBrowseTree.mRootNode);
BluetoothMediaBrowserService.notifyChanged(mService
.sBrowseTree.mRootNode);
@@ -227,15 +250,18 @@
}
synchronized void onBrowsingDisconnected() {
- if (!mBrowsingConnected) return;
+ if (!mBrowsingConnected || (!smActive)) return;
mAddressedPlayer.setPlayStatus(PlaybackStateCompat.STATE_ERROR);
mAddressedPlayer.updateCurrentTrack(null);
- mBrowseTree.mNowPlayingNode.setCached(false);
- BluetoothMediaBrowserService.notifyChanged(mBrowseTree.mNowPlayingNode);
- mService.sBrowseTree.mRootNode.removeChild(
- mBrowseTree.mRootNode);
- BluetoothMediaBrowserService.notifyChanged(mService
- .sBrowseTree.mRootNode);
+ if (mBrowseTree != null && mBrowseTree.mNowPlayingNode != null) {
+ mBrowseTree.mNowPlayingNode.setCached(false);
+ BluetoothMediaBrowserService.notifyChanged(mBrowseTree.mNowPlayingNode);
+ }
+ if (mBrowseTree != null && mBrowseTree.mRootNode != null) {
+ mService.sBrowseTree.mRootNode.removeChild(
+ mBrowseTree.mRootNode);
+ BluetoothMediaBrowserService.notifyChanged(mService.sBrowseTree.mRootNode);
+ }
mBrowsingConnected = false;
}
@@ -257,10 +283,11 @@
protected class Disconnected extends State {
@Override
public void enter() {
- logD("Enter Disconnected");
+ logD("Enter Disconnected mDevice:" + mDevice);
if (mMostRecentState != BluetoothProfile.STATE_DISCONNECTED) {
sendMessage(CLEANUP);
}
+ mA2dpDevice = null;
broadcastConnectionStateChanged(BluetoothProfile.STATE_DISCONNECTED);
}
@@ -273,6 +300,7 @@
break;
case CLEANUP:
mService.removeStateMachine(AvrcpControllerStateMachine.this);
+ doQuit();
break;
}
return true;
@@ -296,6 +324,9 @@
@Override
public void enter() {
if (mMostRecentState == BluetoothProfile.STATE_CONNECTING) {
+ BluetoothDevice device =
+ BluetoothAdapter.getDefaultAdapter().getRemoteDevice(mDeviceAddress);
+ mA2dpDevice = device;
BluetoothMediaBrowserService.addressedPlayerChanged(mSessionCallbacks);
BluetoothMediaBrowserService.notifyChanged(mAddressedPlayer.getPlaybackState());
broadcastConnectionStateChanged(BluetoothProfile.STATE_CONNECTED);
@@ -317,13 +348,6 @@
handleAbsVolumeRequest(msg.arg1, msg.arg2);
return true;
- case MESSAGE_PROCESS_REGISTER_ABS_VOL_NOTIFICATION:
- mVolumeNotificationLabel = msg.arg1;
- mService.sendRegisterAbsVolRspNative(mDeviceAddress,
- NOTIFICATION_RSP_TYPE_INTERIM,
- getAbsVolume(), mVolumeNotificationLabel);
- return true;
-
case MESSAGE_GET_FOLDER_ITEMS:
transitionTo(mGetFolderList);
return true;
@@ -346,22 +370,28 @@
return true;
case MESSAGE_PROCESS_TRACK_CHANGED:
- mAddressedPlayer.updateCurrentTrack((MediaMetadata) msg.obj);
- BluetoothMediaBrowserService.trackChanged((MediaMetadata) msg.obj);
+ TrackInfo trackInfo = (TrackInfo)msg.obj;
+ mAddressedPlayer.updateCurrentTrack((MediaMetadata) trackInfo.getMediaMetaData());
+ BluetoothMediaBrowserService.trackChanged((MediaMetadata) trackInfo.getMediaMetaData());
+ mAddressedPlayer.updateCurrentTrackInfo(trackInfo);
+ mCoveArtUtils.msgTrackChanged(mService, mBipStateMachine,mAddressedPlayer,mRemoteDevice);
return true;
case MESSAGE_PROCESS_PLAY_STATUS_CHANGED:
- mAddressedPlayer.setPlayStatus(msg.arg1);
- BluetoothMediaBrowserService.notifyChanged(mAddressedPlayer.getPlaybackState());
- if (mAddressedPlayer.getPlaybackState().getState()
- == PlaybackStateCompat.STATE_PLAYING
- && A2dpSinkService.getFocusState() == AudioManager.AUDIOFOCUS_NONE) {
- if (shouldRequestFocus()) {
- mSessionCallbacks.onPrepare();
- } else {
- sendMessage(MSG_AVRCP_PASSTHRU,
- AvrcpControllerService.PASS_THRU_CMD_ID_PAUSE);
- }
+ int status = msg.arg1;
+ mAddressedPlayer.setPlayStatus(status);
+ BluetoothMediaBrowserService.notifyChanged(mAddressedPlayer.getPlaybackState());
+ broadcastPlayBackStateChanged(mAddressedPlayer.getPlaybackState());
+ BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(mDeviceAddress);
+ mA2dpSinkService = A2dpSinkService.getA2dpSinkService();
+ if (mA2dpSinkService == null) {
+ Log.e(TAG, "mA2dpSinkService is null, return");
+ }
+ if (status == PlaybackStateCompat.STATE_PLAYING) {
+ mA2dpSinkService.informTGStatePlaying(device, true);
+ } else if (status == PlaybackStateCompat.STATE_PAUSED
+ || status == PlaybackStateCompat.STATE_STOPPED) {
+ mA2dpSinkService.informTGStatePlaying(device, false);
}
return true;
@@ -404,6 +434,75 @@
transitionTo(mDisconnecting);
return true;
+ case MSG_DEVICE_UPDATED:
+ msgDeviceUpdated((BluetoothDevice)msg.obj);
+ return true;
+
+ case MESSAGE_PROCESS_REGISTER_ABS_VOL_NOTIFICATION: {
+ mVolumeNotificationLabel = msg.arg1;
+ mRemoteDevice.setNotificationLabel(mVolumeNotificationLabel);
+ mRemoteDevice.setAbsVolNotificationRequested(true);
+ int percentageVol = getVolumePercentage();
+ if (DBG) {
+ Log.d(TAG, " Sending Interim Response = " + percentageVol + " label "
+ + msg.arg1);
+ }
+ AvrcpControllerService.sendRegisterAbsVolRspNative(
+ mRemoteDevice.getBluetoothAddress(), NOTIFICATION_RSP_TYPE_INTERIM,
+ percentageVol, mRemoteDevice.getNotificationLabel());
+ }
+ return true;
+
+ case MESSAGE_PROCESS_VOLUME_CHANGED_NOTIFICATION: {
+ if (mVolumeChangedNotificationsToIgnore > 0) {
+ mVolumeChangedNotificationsToIgnore--;
+ if (mVolumeChangedNotificationsToIgnore == 0) {
+ removeMessages(MESSAGE_INTERNAL_ABS_VOL_TIMEOUT);
+ }
+ } else {
+ if (mRemoteDevice.getAbsVolNotificationRequested()) {
+ int percentageVol = getVolumePercentage();
+ Log.d(TAG, " percentageVol = " + percentageVol);
+ if (percentageVol != mPreviousPercentageVol) {
+ if (DBG) {
+ Log.d(TAG, " Sending Changed Response = " + percentageVol +
+ " label: " + msg.arg1 + " mPreviousPercentageVol: " +
+ mPreviousPercentageVol);
+ }
+ AvrcpControllerService.sendRegisterAbsVolRspNative(
+ mRemoteDevice.getBluetoothAddress(),
+ NOTIFICATION_RSP_TYPE_CHANGED, percentageVol,
+ mRemoteDevice.getNotificationLabel());
+ mPreviousPercentageVol = percentageVol;
+ mRemoteDevice.setAbsVolNotificationRequested(false);
+ }
+ }
+ }
+ }
+ return true;
+
+ case MESSAGE_INTERNAL_ABS_VOL_TIMEOUT:
+ // Volume changed notifications should come back promptly from the
+ // AudioManager, if for some reason some notifications were squashed don't
+ // prevent future notifications.
+ if (DBG) Log.d(TAG, "Timed out on volume changed notification");
+ mVolumeChangedNotificationsToIgnore = 0;
+ return true;
+
+ case MESSAGE_PROCESS_RC_FEATURES:
+ mRemoteDevice.setRemoteFeatures(msg.arg1);
+ if (msg.arg2 > 0) {
+ mCoveArtUtils.msgProcessRcFeatures(mBipStateMachine, mRemoteDevice,msg.arg2);
+ }
+ return true;
+
+ case CoverArtUtils.MESSAGE_BIP_CONNECTED:
+ case CoverArtUtils.MESSAGE_BIP_DISCONNECTED:
+ case CoverArtUtils.MESSAGE_BIP_IMAGE_FETCHED:
+ case CoverArtUtils.MESSAGE_BIP_THUMB_NAIL_FETCHED:
+ mCoveArtUtils.processBipAction(mService, mAddressedPlayer,
+ mRemoteDevice, msg.what, msg);
+ return true;
default:
return super.processMessage(msg);
}
@@ -453,6 +552,28 @@
}
}
+ private synchronized void msgDeviceUpdated(BluetoothDevice device) {
+ if (device != null && device.equals(mA2dpDevice)) {
+ return;
+ }
+ Log.d(TAG, "msgDeviceUpdated. Previous: " + mA2dpDevice + " New: " + device);
+ // We are connected to a new device via A2DP now.
+ mA2dpDevice = device;
+ Log.w(TAG, "mA2dpDevice: " + mA2dpDevice +
+ " mBrowsingConnected: " + mBrowsingConnected);
+ if (mBrowsingConnected) {
+ //To do
+ BluetoothMediaBrowserService.notifyChanged(mService.sBrowseTree.mRootNode);
+ //BluetoothMediaBrowserService.notifyChanged(BrowseTree.ROOT);
+ }
+
+ int Playstate = mAddressedPlayer.getPlayStatus();
+ MediaMetadata mediaMetadata = mAddressedPlayer.getCurrentTrack();
+ Log.d(TAG, "Media metadata " + mediaMetadata + " playback state " + Playstate);
+ mAddressedPlayer.setPlayStatus(Playstate);
+ mAddressedPlayer.updateCurrentTrack(mediaMetadata);
+ }
+
private boolean isHoldableKey(int cmd) {
return (cmd == AvrcpControllerService.PASS_THRU_CMD_ID_REWIND)
|| (cmd == AvrcpControllerService.PASS_THRU_CMD_ID_FF);
@@ -630,15 +751,15 @@
+ ITEM_PAGE_SIZE) - 1;
switch (target.getScope()) {
case AvrcpControllerService.BROWSE_SCOPE_PLAYER_LIST:
- mService.getPlayerListNative(mDeviceAddress,
+ AvrcpControllerService.getPlayerListNative(mDeviceAddress,
start, end);
break;
case AvrcpControllerService.BROWSE_SCOPE_NOW_PLAYING:
- mService.getNowPlayingListNative(
+ AvrcpControllerService.getNowPlayingListNative(
mDeviceAddress, start, end);
break;
case AvrcpControllerService.BROWSE_SCOPE_VFS:
- mService.getFolderListNative(mDeviceAddress,
+ AvrcpControllerService.getFolderListNative(mDeviceAddress,
start, end);
break;
default:
@@ -672,7 +793,7 @@
} else if (mNextStep.isPlayer()) {
logD("NAVIGATING Player " + mNextStep.toString());
if (mNextStep.isBrowsable()) {
- mService.setBrowsedPlayerNative(
+ AvrcpControllerService.setBrowsedPlayerNative(
mDeviceAddress, (int) mNextStep.getBluetoothID());
} else {
logD("Player doesn't support browsing");
@@ -684,14 +805,14 @@
mNextStep = mBrowseTree.getCurrentBrowsedFolder().getParent();
mBrowseTree.getCurrentBrowsedFolder().setCached(false);
- mService.changeFolderPathNative(
+ AvrcpControllerService.changeFolderPathNative(
mDeviceAddress,
AvrcpControllerService.FOLDER_NAVIGATION_DIRECTION_UP,
0);
} else {
logD("NAVIGATING DOWN " + mNextStep.toString());
- mService.changeFolderPathNative(
+ AvrcpControllerService.changeFolderPathNative(
mDeviceAddress,
AvrcpControllerService.FOLDER_NAVIGATION_DIRECTION_DOWN,
mNextStep.getBluetoothID());
@@ -717,6 +838,42 @@
}
}
+ private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ String action = intent.getAction();
+ Log.d(TAG, "onReceive(): action: " + action);
+ if (action.equals(AudioManager.VOLUME_CHANGED_ACTION)) {
+ int streamType = intent.getIntExtra(AudioManager.EXTRA_VOLUME_STREAM_TYPE, -1);
+ if (streamType == AudioManager.STREAM_MUSIC) {
+ sendMessage(MESSAGE_PROCESS_VOLUME_CHANGED_NOTIFICATION);
+ }
+ }
+ }
+ };
+
+ void registerReceiver(BluetoothDevice device) {
+ if (DBG) {
+ Log.d(TAG, " Register receiver for device: " + device);
+ }
+ IntentFilter filter = new IntentFilter(AudioManager.VOLUME_CHANGED_ACTION);
+ mService.registerReceiver(mBroadcastReceiver, filter);
+ }
+
+ void doQuit() {
+ Log.d(TAG, "doQuit()");
+ try {
+ mService.unregisterReceiver(mBroadcastReceiver);
+ } catch (IllegalArgumentException expected) {
+ // If the receiver was never registered unregister will throw an
+ // IllegalArgumentException.
+ }
+ synchronized(AvrcpControllerStateMachine.this) {
+ smActive = false;
+ }
+ // we should disacrd, all currently queuedup messages.
+ quitNow();
+ }
/**
* Handle a request to align our local volume with the volume of a remote device. If
* we're assuming the source volume is fixed then a response of ABS_VOL_MAX will always be
@@ -748,6 +905,21 @@
private void setAbsVolume(int absVol) {
int maxLocalVolume = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
int curLocalVolume = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
+
+ /* If SetAbsVolume Control Cmd is received from non-Streaming device then the
+ * requested volume level would be accepted at SINK device, and current Abs vol level
+ * at DUT (sink: rendering device) will be sent in changed response. */
+ Log.d(TAG, "Streaming device: " + A2dpSinkService.getCurrentStreamingDevice()
+ + " Device: " + mDevice + " absVol: " + absVol);
+ if (!mDevice.equals(A2dpSinkService.getCurrentStreamingDevice())) {
+ Log.w(TAG, "Volume change request came from non-streaming device," +
+ "respond with accepted absVol: " + absVol + "at Sink");
+ int percentageVol = getVolumePercentage();
+ AvrcpControllerService.sendRegisterAbsVolRspNative(mRemoteDevice.getBluetoothAddress(),
+ NOTIFICATION_RSP_TYPE_CHANGED, percentageVol, mRemoteDevice.getNotificationLabel());
+ mPreviousPercentageVol = percentageVol;
+ return;
+ }
int reqLocalVolume = (maxLocalVolume * absVol) / ABS_VOL_BASE;
logD("setAbsVolme: absVol = " + absVol + ", reqLocal = " + reqLocalVolume
+ ", curLocal = " + curLocalVolume + ", maxLocal = " + maxLocalVolume);
@@ -763,14 +935,20 @@
}
}
+ private int getVolumePercentage() {
+ int maxVolume = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
+ int currIndex = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
+ int percentageVol = ((currIndex * ABS_VOL_BASE) / maxVolume);
+ logD("maxVolume: " + maxVolume + " currIndex: " + currIndex +
+ " percentageVol: " + percentageVol);
+ return percentageVol;
+ }
+
private int getAbsVolume() {
if (mIsVolumeFixed) {
return ABS_VOL_BASE;
}
- int maxVolume = mAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
- int currIndex = mAudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
- int newIndex = (currIndex * ABS_VOL_BASE) / maxVolume;
- return newIndex;
+ return getVolumePercentage();
}
MediaSessionCompat.Callback mSessionCallbacks = new MediaSessionCompat.Callback() {
@@ -879,6 +1057,16 @@
mService.sendBroadcast(intent, ProfileService.BLUETOOTH_PERM);
}
+ private void broadcastPlayBackStateChanged(PlaybackStateCompat state) {
+ Intent intent = new Intent(AvrcpControllerService.ACTION_TRACK_EVENT);
+ intent.putExtra(AvrcpControllerService.EXTRA_PLAYBACK, state);
+ if (DBG) {
+ Log.d(TAG, " broadcastPlayBackStateChanged = " + state.toString());
+ }
+ mService.sendBroadcast(intent, ProfileService.BLUETOOTH_PERM);
+ }
+
+
private boolean shouldRequestFocus() {
return mService.getResources()
.getBoolean(R.bool.a2dp_sink_automatically_request_audio_focus);
diff --git a/src/com/android/bluetooth/avrcpcontroller/AvrcpPlayer.java b/src/com/android/bluetooth/avrcpcontroller/AvrcpPlayer.java
index 4736acf..d3410d9 100644
--- a/src/com/android/bluetooth/avrcpcontroller/AvrcpPlayer.java
+++ b/src/com/android/bluetooth/avrcpcontroller/AvrcpPlayer.java
@@ -29,7 +29,7 @@
*/
class AvrcpPlayer {
private static final String TAG = "AvrcpPlayer";
- private static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
+ private static final boolean DBG = true;
public static final int INVALID_ID = -1;
@@ -57,6 +57,8 @@
new PlayerApplicationSettings();
private PlayerApplicationSettings mCurrentPlayerApplicationSettings;
+ private TrackInfo mCurrentTrackInfo = new TrackInfo();
+
AvrcpPlayer() {
mId = INVALID_ID;
//Set Default Actions in case Player data isn't available.
@@ -215,4 +217,12 @@
if (DBG) Log.d(TAG, "Supported Actions = " + mAvailableActions);
}
+
+ public synchronized void updateCurrentTrackInfo(TrackInfo update) {
+ mCurrentTrackInfo = update;
+ }
+
+ public synchronized TrackInfo getCurrentTrackInfo() {
+ return mCurrentTrackInfo;
+ }
}
diff --git a/src/com/android/bluetooth/avrcpcontroller/BluetoothMediaBrowserService.java b/src/com/android/bluetooth/avrcpcontroller/BluetoothMediaBrowserService.java
index a0b1224..380ea1c 100644
--- a/src/com/android/bluetooth/avrcpcontroller/BluetoothMediaBrowserService.java
+++ b/src/com/android/bluetooth/avrcpcontroller/BluetoothMediaBrowserService.java
@@ -54,7 +54,7 @@
*/
public class BluetoothMediaBrowserService extends MediaBrowserServiceCompat {
private static final String TAG = "BluetoothMediaBrowserService";
- private static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
+ private static final boolean DBG = true;
private static BluetoothMediaBrowserService sBluetoothMediaBrowserService;
@@ -63,6 +63,7 @@
// Browsing related structures.
private List<MediaSessionCompat.QueueItem> mMediaQueue = new ArrayList<>();
+
// Error messaging extras
public static final String ERROR_RESOLUTION_ACTION_INTENT =
"android.media.extras.ERROR_RESOLUTION_ACTION_INTENT";
diff --git a/src/com/android/bluetooth/avrcpcontroller/RemoteDevice.java b/src/com/android/bluetooth/avrcpcontroller/RemoteDevice.java
new file mode 100644
index 0000000..07c2a4b
--- /dev/null
+++ b/src/com/android/bluetooth/avrcpcontroller/RemoteDevice.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2016 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.bluetooth.avrcpcontroller;
+
+import android.bluetooth.BluetoothDevice;
+
+import com.android.bluetooth.Utils;
+
+/*
+ * Contains information about remote device specifically the player and features enabled on it along
+ * with an encapsulation of the current track and playlist information.
+ */
+class RemoteDevice {
+
+ /*
+ * Remote features from JNI
+ */
+ private static final int FEAT_NONE = 0;
+ private static final int FEAT_METADATA = 1;
+ private static final int FEAT_ABSOLUTE_VOLUME = 2;
+ private static final int FEAT_BROWSE = 4;
+ private static final int FEAT_COVER_ART = 8;
+
+ private static final int VOLUME_LABEL_UNDEFINED = -1;
+ private static final int L2CAP_PSM_UNDEFINED = -1;
+
+ final BluetoothDevice mBTDevice;
+ private int mRemoteFeatures;
+ private boolean mAbsVolNotificationRequested;
+ private boolean mFirstAbsVolCmdRecvd;
+ private int mNotificationLabel;
+ private int mBipL2capPsm;
+
+ RemoteDevice(BluetoothDevice mDevice) {
+ mBTDevice = mDevice;
+ mRemoteFeatures = FEAT_NONE;
+ mAbsVolNotificationRequested = false;
+ mNotificationLabel = VOLUME_LABEL_UNDEFINED;
+ mFirstAbsVolCmdRecvd = false;
+ mBipL2capPsm = L2CAP_PSM_UNDEFINED;
+ }
+
+ synchronized void setRemoteFeatures(int remoteFeatures) {
+ mRemoteFeatures = remoteFeatures;
+ }
+
+ synchronized void setRemoteBipPsm( int remotePsm) {
+ mBipL2capPsm = remotePsm;
+ }
+
+ synchronized int getRemoteBipPsm () {
+ return mBipL2capPsm;
+ }
+
+ synchronized boolean isBrowsingSupported() {
+ return ((mRemoteFeatures & FEAT_BROWSE) != 0);
+ }
+
+ synchronized boolean isMetaDataSupported() {
+ return ((mRemoteFeatures & FEAT_METADATA) != 0);
+ }
+
+ synchronized boolean isCoverArtSupported() {
+ return ((mRemoteFeatures & FEAT_COVER_ART) != 0);
+ }
+
+ synchronized public byte[] getBluetoothAddress() {
+ return Utils.getByteAddress(mBTDevice);
+ }
+
+ public synchronized void setNotificationLabel(int label) {
+ mNotificationLabel = label;
+ }
+
+ public synchronized int getNotificationLabel() {
+ return mNotificationLabel;
+ }
+
+ public synchronized void setAbsVolNotificationRequested(boolean request) {
+ mAbsVolNotificationRequested = request;
+ }
+
+ public synchronized boolean getAbsVolNotificationRequested() {
+ return mAbsVolNotificationRequested;
+ }
+
+ public synchronized void setFirstAbsVolCmdRecvd() {
+ mFirstAbsVolCmdRecvd = true;
+ }
+
+ public synchronized boolean getFirstAbsVolCmdRecvd() {
+ return mFirstAbsVolCmdRecvd;
+ }
+}
diff --git a/src/com/android/bluetooth/avrcpcontroller/TrackInfo.java b/src/com/android/bluetooth/avrcpcontroller/TrackInfo.java
index fd1b784..961e92e 100644
--- a/src/com/android/bluetooth/avrcpcontroller/TrackInfo.java
+++ b/src/com/android/bluetooth/avrcpcontroller/TrackInfo.java
@@ -17,8 +17,29 @@
package com.android.bluetooth.avrcpcontroller;
import android.media.MediaMetadata;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.media.MediaMetadata;
+import android.net.Uri;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
final class TrackInfo {
+
+ private static final String TAG = "AvrcpTrackInfo";
+ private static final boolean VDBG = AvrcpControllerService.VDBG;
+ /*
+ * Default values for each of the items from JNI
+ */
+ private static final int TRACK_NUM_INVALID = -1;
+ private static final int TOTAL_TRACKS_INVALID = -1;
+ private static final int TOTAL_TRACK_TIME_INVALID = -1;
+ private static final String UNPOPULATED_ATTRIBUTE = "";
+
/*
*Element Id Values for GetMetaData from JNI
*/
@@ -29,6 +50,108 @@
private static final int MEDIA_ATTRIBUTE_TOTAL_TRACK_NUMBER = 0x05;
private static final int MEDIA_ATTRIBUTE_GENRE = 0x06;
private static final int MEDIA_ATTRIBUTE_PLAYING_TIME = 0x07;
+ private static final int MEDIA_ATTRIBUTE_COVER_ART_HANDLE = 0x08;
+
+ private final String mArtistName;
+ private final String mTrackTitle;
+ private final String mAlbumTitle;
+ private final String mGenre;
+ private final long mTrackNum; // number of audio file on original recording.
+ private final long mTotalTracks; // total number of tracks on original recording
+ private final long mTrackLen; // full length of AudioFile.
+ private String mCoverArtHandle;
+ private String mImageLocation;
+ private String mThumbNailLocation;
+
+
+ TrackInfo() {
+ this(new ArrayList<Integer>(), new ArrayList<String>());
+ }
+
+ TrackInfo(List<Integer> attrIds, List<String> attrMap) {
+ Map<Integer, String> attributeMap = new HashMap<>();
+ for (int i = 0; i < attrIds.size(); i++) {
+ attributeMap.put(attrIds.get(i), attrMap.get(i));
+ }
+
+ String attribute;
+ mTrackTitle = attributeMap.getOrDefault(MEDIA_ATTRIBUTE_TITLE, UNPOPULATED_ATTRIBUTE);
+
+ mArtistName = attributeMap.getOrDefault(MEDIA_ATTRIBUTE_ARTIST_NAME, UNPOPULATED_ATTRIBUTE);
+
+ mAlbumTitle = attributeMap.getOrDefault(MEDIA_ATTRIBUTE_ALBUM_NAME, UNPOPULATED_ATTRIBUTE);
+
+ attribute = attributeMap.get(MEDIA_ATTRIBUTE_TRACK_NUMBER);
+ mTrackNum = (attribute != null && !attribute.isEmpty()) ? Long.valueOf(attribute)
+ : TRACK_NUM_INVALID;
+
+ attribute = attributeMap.get(MEDIA_ATTRIBUTE_TOTAL_TRACK_NUMBER);
+ mTotalTracks = (attribute != null && !attribute.isEmpty()) ? Long.valueOf(attribute)
+ : TOTAL_TRACKS_INVALID;
+
+ mGenre = attributeMap.getOrDefault(MEDIA_ATTRIBUTE_GENRE, UNPOPULATED_ATTRIBUTE);
+
+ attribute = attributeMap.get(MEDIA_ATTRIBUTE_PLAYING_TIME);
+ mTrackLen = (attribute != null && !attribute.isEmpty()) ? Long.valueOf(attribute)
+ : TOTAL_TRACK_TIME_INVALID;
+ mCoverArtHandle = attributeMap.getOrDefault(MEDIA_ATTRIBUTE_COVER_ART_HANDLE,
+ UNPOPULATED_ATTRIBUTE);
+ mImageLocation = UNPOPULATED_ATTRIBUTE;
+ mThumbNailLocation = UNPOPULATED_ATTRIBUTE;
+ }
+
+ boolean updateImageLocation(String mCAHandle, String mLocation) {
+ if (VDBG) Log.d(TAG, " updateImageLocation hndl " + mCAHandle + " location " + mLocation);
+ if (!mCAHandle.equals(mCoverArtHandle) || (mLocation == null)) {
+ return false;
+ }
+ mImageLocation = mLocation;
+ return true;
+ }
+
+ boolean updateThumbNailLocation(String mCAHandle, String mLocation) {
+ if (VDBG) Log.d(TAG, " mCAHandle " + mCAHandle + " location " + mLocation);
+ if (!mCAHandle.equals(mCoverArtHandle) || (mLocation == null)) {
+ return false;
+ }
+ mThumbNailLocation = mLocation;
+ return true;
+ }
+
+ public String toString() {
+ return "Metadata [artist=" + mArtistName + " trackTitle= " + mTrackTitle + " albumTitle= "
+ + mAlbumTitle + " genre= " + mGenre + " trackNum= " + Long.toString(mTrackNum)
+ + " track_len : " + Long.toString(mTrackLen) + " TotalTracks " + Long.toString(
+ mTotalTracks) + " mCoverArtHandle=" + mCoverArtHandle +
+ " mImageLocation :"+mImageLocation+"]";
+ }
+
+
+ public MediaMetadata getMediaMetaData() {
+ if (VDBG) {
+ Log.d(TAG, " TrackInfo " + toString());
+ }
+ MediaMetadata.Builder mMetaDataBuilder = new MediaMetadata.Builder();
+ mMetaDataBuilder.putString(MediaMetadata.METADATA_KEY_ARTIST, mArtistName);
+ mMetaDataBuilder.putString(MediaMetadata.METADATA_KEY_TITLE, mTrackTitle);
+ mMetaDataBuilder.putString(MediaMetadata.METADATA_KEY_ALBUM, mAlbumTitle);
+ mMetaDataBuilder.putString(MediaMetadata.METADATA_KEY_GENRE, mGenre);
+ mMetaDataBuilder.putLong(MediaMetadata.METADATA_KEY_TRACK_NUMBER, mTrackNum);
+ mMetaDataBuilder.putLong(MediaMetadata.METADATA_KEY_NUM_TRACKS, mTotalTracks);
+ mMetaDataBuilder.putLong(MediaMetadata.METADATA_KEY_DURATION, mTrackLen);
+ if (mImageLocation != UNPOPULATED_ATTRIBUTE) {
+ Uri imageUri = Uri.parse(mImageLocation);
+ if (VDBG) Log.d(TAG," updating image uri = " + imageUri.toString());
+ mMetaDataBuilder.putString(MediaMetadata.METADATA_KEY_ALBUM_ART_URI,
+ imageUri.toString());
+ }
+ if (mThumbNailLocation != UNPOPULATED_ATTRIBUTE) {
+ Bitmap mThumbNailBitmap = BitmapFactory.decodeFile(mThumbNailLocation);
+ mMetaDataBuilder.putBitmap(MediaMetadata.METADATA_KEY_DISPLAY_ICON, mThumbNailBitmap);
+ }
+ return mMetaDataBuilder.build();
+ }
+
static MediaMetadata getMetadata(int[] attrIds, String[] attrMap) {
MediaMetadata.Builder metaDataBuilder = new MediaMetadata.Builder();
@@ -73,6 +196,45 @@
break;
}
}
+
return metaDataBuilder.build();
}
+
+ public String displayMetaData() {
+ MediaMetadata metaData = getMediaMetaData();
+ StringBuffer sb = new StringBuffer();
+ // getDescription only contains artist, title and album
+ sb.append(metaData.getDescription().toString() + " ");
+ if (metaData.containsKey(MediaMetadata.METADATA_KEY_GENRE)) {
+ sb.append(metaData.getString(MediaMetadata.METADATA_KEY_GENRE) + " ");
+ }
+ if (metaData.containsKey(MediaMetadata.METADATA_KEY_MEDIA_ID)) {
+ sb.append(metaData.getString(MediaMetadata.METADATA_KEY_MEDIA_ID) + " ");
+ }
+ if (metaData.containsKey(MediaMetadata.METADATA_KEY_TRACK_NUMBER)) {
+ sb.append(
+ Long.toString(metaData.getLong(MediaMetadata.METADATA_KEY_TRACK_NUMBER)) + " ");
+ }
+ if (metaData.containsKey(MediaMetadata.METADATA_KEY_NUM_TRACKS)) {
+ sb.append(Long.toString(metaData.getLong(MediaMetadata.METADATA_KEY_NUM_TRACKS)) + " ");
+ }
+ if (metaData.containsKey(MediaMetadata.METADATA_KEY_TRACK_NUMBER)) {
+ sb.append(Long.toString(metaData.getLong(MediaMetadata.METADATA_KEY_DURATION)) + " ");
+ }
+ if (metaData.containsKey(MediaMetadata.METADATA_KEY_TRACK_NUMBER)) {
+ sb.append(Long.toString(metaData.getLong(MediaMetadata.METADATA_KEY_DURATION)) + " ");
+ }
+ return sb.toString();
+ }
+
+ String getCoverArtHandle() {
+ return mCoverArtHandle;
+ }
+
+ void clearCoverArtData() {
+ mCoverArtHandle = UNPOPULATED_ATTRIBUTE;
+ mImageLocation = UNPOPULATED_ATTRIBUTE;
+ mThumbNailLocation = UNPOPULATED_ATTRIBUTE;
+ }
+
}
diff --git a/src/com/android/bluetooth/btservice/AbstractionLayer.java b/src/com/android/bluetooth/btservice/AbstractionLayer.java
index e15104d..3da2440 100644
--- a/src/com/android/bluetooth/btservice/AbstractionLayer.java
+++ b/src/com/android/bluetooth/btservice/AbstractionLayer.java
@@ -1,4 +1,39 @@
/*
+ * Copyright (C) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted (subject to the limitations in the
+ * disclaimer below) provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
+ * GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
+ * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
@@ -85,4 +120,32 @@
public static final int BT_STATUS_RMT_DEV_DOWN = 10;
public static final int BT_STATUS_AUTH_REJECTED = 11;
public static final int BT_STATUS_AUTH_TIMEOUT = 12;
+
+ // Profile IDs to get profile features from profile_conf
+ public static final int AVRCP = 1;
+ public static final int PBAP = 2;
+ public static final int MAP = 3;
+ public static final int MAX_POW = 4;
+
+ // Profile features supported in profile_conf
+ public static final int PROFILE_VERSION =1;
+ public static final int AVRCP_COVERART_SUPPORT = 2;
+ public static final int AVRCP_0103_SUPPORT = 3;
+ public static final int USE_SIM_SUPPORT = 4;
+ public static final int MAP_EMAIL_SUPPORT = 5;
+ public static final int PBAP_0102_SUPPORT = 6;
+ public static final int MAP_0104_SUPPORT = 7;
+ public static final int BR_MAX_POW_SUPPORT = 8;
+ public static final int EDR_MAX_POW_SUPPORT = 9;
+ public static final int BLE_MAX_POW_SUPPORT = 10;
+
+
+ static final int BT_VENDOR_PROPERTY_TWS_PLUS_DEVICE_TYPE = 0x01;
+ static final int BT_VENDOR_PROPERTY_TWS_PLUS_PEER_ADDR = 0x02;
+ static final int BT_VENDOR_PROPERTY_TWS_PLUS_AUTO_CONNECT = 0x03;
+ static final int BT_VENDOR_PROPERTY_HOST_ADD_ON_FEATURES = 0x04;
+ static final int BT_VENDOR_PROPERTY_SOC_ADD_ON_FEATURES = 0x05;
+ static final int TWS_PLUS_DEV_TYPE_NONE = 0x00;
+ static final int TWS_PLUS_DEV_TYPE_PRIMARY = 0x01;
+ static final int TWS_PLUS_DEV_TYPE_SECONDARY = 0x02;
}
diff --git a/src/com/android/bluetooth/btservice/ActiveDeviceManager.java b/src/com/android/bluetooth/btservice/ActiveDeviceManager.java
old mode 100644
new mode 100755
index 69381c5..17b9100
--- a/src/com/android/bluetooth/btservice/ActiveDeviceManager.java
+++ b/src/com/android/bluetooth/btservice/ActiveDeviceManager.java
@@ -33,11 +33,13 @@
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
+import android.os.SystemProperties;
import android.util.Log;
import com.android.bluetooth.a2dp.A2dpService;
import com.android.bluetooth.hearingaid.HearingAidService;
import com.android.bluetooth.hfp.HeadsetService;
+import com.android.bluetooth.ba.BATService;
import com.android.internal.annotations.VisibleForTesting;
import java.util.LinkedList;
@@ -123,6 +125,8 @@
private BluetoothDevice mA2dpActiveDevice = null;
private BluetoothDevice mHfpActiveDevice = null;
private BluetoothDevice mHearingAidActiveDevice = null;
+ private boolean mTwsPlusSwitch = false;
+ private static boolean a2dpMulticast = false;
// Broadcast receiver for all changes
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@@ -190,6 +194,10 @@
Intent intent = (Intent) msg.obj;
BluetoothDevice device =
intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+ if (device.getAddress().equals(BATService.mBAAddress)) {
+ Log.d(TAG," Update from BA, bail out");
+ break;
+ }
int prevState = intent.getIntExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, -1);
int nextState = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, -1);
if (prevState == nextState) {
@@ -209,8 +217,19 @@
mA2dpConnectedDevices.add(device);
if (mHearingAidActiveDevice == null) {
// New connected device: select it as active
- setA2dpActiveDevice(device);
- break;
+ if (!a2dpMulticast) {
+ setA2dpActiveDevice(device);
+ }
+ else {
+ if (mA2dpActiveDevice == null) {
+ setA2dpActiveDevice(device);
+ }
+ else {
+ // store the volume for the new added device
+ final A2dpService a2dpService = mFactory.getA2dpService();
+ a2dpService.storeDeviceAudioVolume(device);
+ }
+ }
}
break;
}
@@ -222,8 +241,39 @@
+ "device " + device + " disconnected");
}
mA2dpConnectedDevices.remove(device);
+
if (Objects.equals(mA2dpActiveDevice, device)) {
- setA2dpActiveDevice(null);
+ final A2dpService mA2dpService = mFactory.getA2dpService();
+ BluetoothDevice mDevice = null;
+ if (mAdapterService.isTwsPlusDevice(device) && !mTwsPlusSwitch &&
+ !mA2dpConnectedDevices.isEmpty()) {
+ for (BluetoothDevice connected_device: mA2dpConnectedDevices) {
+ if (mAdapterService.isTwsPlusDevice(connected_device) &&
+ mA2dpService.getConnectionState(connected_device) ==
+ BluetoothProfile.STATE_CONNECTED) {
+ mDevice = connected_device;
+ break;
+ }
+ }
+ } else if (device.isTwsPlusDevice() && mTwsPlusSwitch) {
+ Log.d(TAG, "Resetting mTwsPlusSwitch");
+ mTwsPlusSwitch = false;
+ }
+ else if (a2dpMulticast && !mA2dpConnectedDevices.isEmpty()) {
+ for (BluetoothDevice connected_device: mA2dpConnectedDevices) {
+ if (mA2dpService.getConnectionState(connected_device) ==
+ BluetoothProfile.STATE_CONNECTED) {
+ Log.d(TAG, "a2dp Multicast calling set a2dp Active dev: " + connected_device);
+ mDevice = connected_device;
+ break;
+ }
+ }
+ }
+ if (!setA2dpActiveDevice(mDevice) && (mDevice != null) &&
+ (mAdapterService.isTwsPlusDevice(mDevice) || a2dpMulticast)) {
+ Log.w(TAG, "Switch A2dp active device to peer earbud failed");
+ setA2dpActiveDevice(null);
+ }
}
}
}
@@ -266,7 +316,7 @@
break; // The device is already connected
}
mHfpConnectedDevices.add(device);
- if (mHearingAidActiveDevice == null) {
+ if ((!a2dpMulticast || mHfpActiveDevice == null) && mHearingAidActiveDevice == null) {
// New connected device: select it as active
setHfpActiveDevice(device);
break;
@@ -280,9 +330,51 @@
"handleMessage(MESSAGE_HFP_ACTION_CONNECTION_STATE_CHANGED): "
+ "device " + device + " disconnected");
}
+ final HeadsetService hfpService = mFactory.getHeadsetService();
+
mHfpConnectedDevices.remove(device);
if (Objects.equals(mHfpActiveDevice, device)) {
- setHfpActiveDevice(null);
+ if (mAdapterService.isTwsPlusDevice(device) &&
+ !mHfpConnectedDevices.isEmpty()) {
+ if (hfpService == null) {
+ Log.e(TAG, "no headsetService, FATAL");
+ return;
+ }
+ BluetoothDevice peerTwsDevice =
+ hfpService.getTwsPlusConnectedPeer(device);
+ if (peerTwsDevice != null &&
+ hfpService.getConnectionState(peerTwsDevice)
+ == BluetoothProfile.STATE_CONNECTED) {
+ Log.d(TAG, "calling set Active dev: "
+ + peerTwsDevice);
+ if (!setHfpActiveDevice(peerTwsDevice)) {
+ Log.w(TAG, "Set hfp active device failed");
+ setHfpActiveDevice(null);
+ }
+ } else {
+ Log.d(TAG, "No Active device Switch" +
+ "as there is no Connected TWS+ peer");
+ setHfpActiveDevice(null);
+ }
+ } else if (a2dpMulticast && !mHfpConnectedDevices.isEmpty()) {
+ if (hfpService == null) {
+ Log.e(TAG, "no headsetService, FATAL");
+ return;
+ }
+ for (BluetoothDevice connected_device: mHfpConnectedDevices) {
+ if (hfpService.getConnectionState(connected_device) ==
+ BluetoothProfile.STATE_CONNECTED) {
+ Log.d(TAG, "a2dp Multicast calling set HFP Active dev: " + connected_device);
+ if (!setHfpActiveDevice(connected_device)) {
+ setHfpActiveDevice(null);
+ }
+ break;
+ }
+ }
+ }
+ else {
+ setHfpActiveDevice(null);
+ }
}
}
}
@@ -390,6 +482,7 @@
mAdapterService.registerReceiver(mReceiver, filter);
mAudioManager.registerAudioDeviceCallback(mAudioManagerAudioDeviceCallback, mHandler);
+ a2dpMulticast = SystemProperties.getBoolean("persist.vendor.service.bt.a2dp_multicast_enable", false);
}
void cleanup() {
@@ -405,7 +498,12 @@
}
resetState();
}
-
+ public void notify_active_device_unbonding(BluetoothDevice device) {
+ if (device.isTwsPlusDevice() && Objects.equals(mA2dpActiveDevice, device)) {
+ Log.d(TAG,"TWS+ active device is getting unpaired, avoid switch to pair");
+ mTwsPlusSwitch = true;
+ }
+ }
/**
* Get the {@link Looper} for the handler thread. This is used in testing and helper
* objects
@@ -420,32 +518,34 @@
return mHandlerThread.getLooper();
}
- private void setA2dpActiveDevice(BluetoothDevice device) {
+ private boolean setA2dpActiveDevice(BluetoothDevice device) {
if (DBG) {
Log.d(TAG, "setA2dpActiveDevice(" + device + ")");
}
final A2dpService a2dpService = mFactory.getA2dpService();
if (a2dpService == null) {
- return;
+ return false;
}
if (!a2dpService.setActiveDevice(device)) {
- return;
+ return false;
}
mA2dpActiveDevice = device;
+ return true;
}
- private void setHfpActiveDevice(BluetoothDevice device) {
+ private boolean setHfpActiveDevice(BluetoothDevice device) {
if (DBG) {
Log.d(TAG, "setHfpActiveDevice(" + device + ")");
}
final HeadsetService headsetService = mFactory.getHeadsetService();
if (headsetService == null) {
- return;
+ return false;
}
if (!headsetService.setActiveDevice(device)) {
- return;
+ return false;
}
mHfpActiveDevice = device;
+ return true;
}
private void setHearingAidActiveDevice(BluetoothDevice device) {
diff --git a/src/com/android/bluetooth/btservice/AdapterProperties.java b/src/com/android/bluetooth/btservice/AdapterProperties.java
index 4b4b4df..b9e52e5 100644
--- a/src/com/android/bluetooth/btservice/AdapterProperties.java
+++ b/src/com/android/bluetooth/btservice/AdapterProperties.java
@@ -44,7 +44,6 @@
import android.util.Log;
import android.util.Pair;
import android.util.StatsLog;
-
import androidx.annotation.VisibleForTesting;
import com.android.bluetooth.Utils;
@@ -64,10 +63,14 @@
"persist.bluetooth.maxconnectedaudiodevices";
static final int MAX_CONNECTED_AUDIO_DEVICES_LOWER_BOND = 1;
private static final int MAX_CONNECTED_AUDIO_DEVICES_UPPER_BOUND = 5;
- private static final String A2DP_OFFLOAD_SUPPORTED_PROPERTY =
- "ro.bluetooth.a2dp_offload.supported";
+ private static final int BLUETOOTH_NAME_MAX_LENGTH_BYTES = 248;
+
+ private static final String A2DP_OFFLOAD_ENABLE_PROPERTY =
+ "persist.bluetooth.a2dp_offload.enable";
private static final String A2DP_OFFLOAD_DISABLED_PROPERTY =
"persist.bluetooth.a2dp_offload.disabled";
+ private static final String A2DP_OFFLOAD_SUPPORTED_PROPERTY =
+ "ro.bluetooth.a2dp_offload.supported";
private static final long DEFAULT_DISCOVERY_TIMEOUT_MS = 12800;
private static final int BD_ADDR_LEN = 6; // in bytes
@@ -114,6 +117,36 @@
private boolean mIsLeExtendedAdvertisingSupported;
private boolean mIsLePeriodicAdvertisingSupported;
private int mLeMaximumAdvertisingDataLength;
+ private boolean mWiPowerFastbootEnabled;
+ private boolean mSplitA2DPScrambleDataRequired;
+ private boolean mSplitA2DP44p1KhzSampleFreq;
+ private boolean mSplitA2DP48KhzSampleFreq;
+ private boolean mSplitA2DPSingleVSCommandSupport;
+ private boolean mSplitA2DPSourceSBCEncoding;
+ private boolean mSplitA2DPSourceSBC;
+ private boolean mSplitA2DPSourceMP3;
+ private boolean mSplitA2DPSourceAAC;
+ private boolean mSplitA2DPSourceLDAC;
+ private boolean mSplitA2DPSourceAPTX;
+ private boolean mSplitA2DPSourceAPTXHD;
+ private boolean mSplitA2DPSourceAPTXADAPTIVE;
+ private boolean mSplitA2DPSourceAPTXTWSPLUS;
+ private boolean mSplitA2DPSinkSBC;
+ private boolean mSplitA2DPSinkMP3;
+ private boolean mSplitA2DPSinkAAC;
+ private boolean mSplitA2DPSinkLDAC;
+ private boolean mSplitA2DPSinkAPTX;
+ private boolean mSplitA2DPSinkAPTXHD;
+ private boolean mSplitA2DPSinkAPTXADAPTIVE;
+ private boolean mSplitA2DPSinkAPTXTWSPLUS;
+ private boolean mVoiceDualSCO;
+ private boolean mVoiceTWSPLUSeSCOAG;
+ private boolean mSWBVoicewithAptxAdaptiveAG;
+ private boolean mBroadcastAudioTxwithEC_2_5;
+ private boolean mBroadcastAudioTxwithEC_3_9;
+ private boolean mBroadcastAudioRxwithEC_2_5;
+ private boolean mBroadcastAudioRxwithEC_3_9;
+ private boolean mAddonFeaturesSupported;
private boolean mReceiverRegistered;
private BroadcastReceiver mReceiver = new BroadcastReceiver() {
@@ -198,6 +231,12 @@
// Make sure the final value of max connected audio devices is within allowed range
mMaxConnectedAudioDevices = Math.min(Math.max(propertyOverlayedMaxConnectedAudioDevices,
MAX_CONNECTED_AUDIO_DEVICES_LOWER_BOND), MAX_CONNECTED_AUDIO_DEVICES_UPPER_BOUND);
+ // if QTI stack, overwrite max audio connections to 2
+ if(mService.isVendorIntfEnabled() && mMaxConnectedAudioDevices > 5) {
+ Log.i(TAG, "overwriting mMaxConnectedAudioDevices to 5 for vendor stack");
+ mMaxConnectedAudioDevices = 5;
+ }
+
Log.i(TAG, "init(), maxConnectedAudioDevices, default="
+ configDefaultMaxConnectedAudioDevices + ", propertyOverlayed="
+ propertyOverlayedMaxConnectedAudioDevices + ", finalValue="
@@ -229,7 +268,9 @@
mRemoteDevices = null;
mProfileConnectionState.clear();
if (mReceiverRegistered) {
- mService.unregisterReceiver(mReceiver);
+ if (mReceiver != null) {
+ mService.unregisterReceiver(mReceiver);
+ }
mReceiverRegistered = false;
}
mService = null;
@@ -254,6 +295,9 @@
*/
boolean setName(String name) {
synchronized (mObject) {
+ if (name.length() > BLUETOOTH_NAME_MAX_LENGTH_BYTES) {
+ name = name.substring(0, BLUETOOTH_NAME_MAX_LENGTH_BYTES);
+ }
return mService.setAdapterPropertyNative(AbstractionLayer.BT_PROPERTY_BDNAME,
name.getBytes());
}
@@ -481,6 +525,12 @@
}
/**
+ * @param set the maximum number of connected audio devices
+ */
+ void setMaxConnectedAudioDevices(int maxConnectedAudioDevices) {
+ mMaxConnectedAudioDevices = maxConnectedAudioDevices;
+ }
+ /**
* @return the maximum number of connected audio devices
*/
int getMaxConnectedAudioDevices() {
@@ -495,6 +545,215 @@
}
/**
+ * @return Wipower Fastboot status
+ */
+ boolean isWipowerFastbootEnabled() {
+ return mWiPowerFastbootEnabled;
+ }
+
+ /**
+ * @return Split A2DP Scramble Data Support status
+ */
+ boolean isSplitA2DPScrambleDataRequired() {
+ return mSplitA2DPScrambleDataRequired;
+ }
+
+ /**
+ * @return Split A2DP 44.1Khz Sample Freq status
+ */
+ boolean isSplitA2DP44p1KhzSampleFreq() {
+ return mSplitA2DP44p1KhzSampleFreq;
+ }
+
+ /**
+ * @return Split A2DP 48Khz Sample Freq status
+ */
+ boolean isSplitA2DP48KhzSampleFreq() {
+ return mSplitA2DP48KhzSampleFreq;
+ }
+ /**
+ * @return Split A2DP Single VS Command Support status
+ */
+ boolean isSplitA2DPSingleVSCommandSupport() {
+ return mSplitA2DPSingleVSCommandSupport;
+ }
+
+ /**
+ * @return Split A2DP Source SBC Encoding status
+ */
+ boolean isSplitA2DPSourceSBCEncoding() {
+ return mSplitA2DPSourceSBCEncoding;
+ }
+
+ /**
+ * @return Split A2DP Source SBC status
+ */
+ boolean isSplitA2DPSourceSBC() {
+ return mSplitA2DPSourceSBC;
+ }
+
+ /**
+ * @return Split A2DP Source MP3 status
+ */
+ boolean isSplitA2DPSourceMP3() {
+ return mSplitA2DPSourceMP3;
+ }
+
+ /**
+ * @return Split A2DP Source AAC status
+ */
+ boolean isSplitA2DPSourceAAC() {
+ return mSplitA2DPSourceAAC;
+ }
+
+ /**
+ * @return Split A2DP Source LDAC status
+ */
+ boolean isSplitA2DPSourceLDAC() {
+ return mSplitA2DPSourceLDAC;
+ }
+
+ /**
+ * @return Split A2DP Source APTX status
+ */
+ boolean isSplitA2DPSourceAPTX() {
+ return mSplitA2DPSourceAPTX;
+ }
+
+ /**
+ * @return Split A2DP Source APTXHD status
+ */
+ boolean isSplitA2DPSourceAPTXHD() {
+ return mSplitA2DPSourceAPTXHD;
+ }
+
+ /**
+ * @return Split A2DP Source APTXADAPTIVE status
+ */
+ boolean isSplitA2DPSourceAPTXADAPTIVE() {
+ return mSplitA2DPSourceAPTXADAPTIVE;
+ }
+
+ /**
+ * @return Split A2DP Source APTXTWSPLUS status
+ */
+ boolean isSplitA2DPSourceAPTXTWSPLUS() {
+ return mSplitA2DPSourceAPTXTWSPLUS;
+ }
+
+ /**
+ * @return Split A2DP Sink SBC status
+ */
+ boolean isSplitA2DPSinkSBC() {
+ return mSplitA2DPSinkSBC;
+ }
+
+ /**
+ * @return Split A2DP Sink MP3 status
+ */
+ boolean isSplitA2DPSinkMP3() {
+ return mSplitA2DPSinkMP3;
+ }
+
+ /**
+ * @return Split A2DP Sink AAC status
+ */
+ boolean isSplitA2DPSinkAAC() {
+ return mSplitA2DPSinkAAC;
+ }
+
+ /**
+ * @return Split A2DP Sink LDAC status
+ */
+ boolean isSplitA2DPSinkLDAC() {
+ return mSplitA2DPSinkLDAC;
+ }
+
+ /**
+ * @return Split A2DP Sink APTX status
+ */
+ boolean isSplitA2DPSinkAPTX() {
+ return mSplitA2DPSinkAPTX;
+ }
+
+ /**
+ * @return Split A2DP Sink APTXHD status
+ */
+ boolean isSplitA2DPSinkAPTXHD() {
+ return mSplitA2DPSinkAPTXHD;
+ }
+
+ /**
+ * @return Split A2DP Sink APTXADAPTIVE status
+ */
+ boolean isSplitA2DPSinkAPTXADAPTIVE() {
+ return mSplitA2DPSinkAPTXADAPTIVE;
+ }
+
+ /**
+ * @return Split A2DP Sink APTXTWSPLUS status
+ */
+ boolean isSplitA2DPSinkAPTXTWSPLUS() {
+ return mSplitA2DPSinkAPTXTWSPLUS;
+ }
+
+ /**
+ * @return mVoiceDualSCO status
+ */
+ boolean isVoiceDualSCO() {
+ return mVoiceDualSCO;
+ }
+
+ /**
+ * @return Voice TWS+ eSCO AG status
+ */
+ boolean isVoiceTWSPLUSeSCOAG() {
+ return mVoiceTWSPLUSeSCOAG;
+ }
+
+ /**
+ * @return SWB Voice with Aptx Adaptive AG status
+ */
+ boolean isSWBVoicewithAptxAdaptiveAG() {
+ return mSWBVoicewithAptxAdaptiveAG;
+ }
+
+ /**
+ * @return Broadcast Audio Tx with EC_2_5 status
+ */
+ boolean isBroadcastAudioTxwithEC_2_5() {
+ return mBroadcastAudioTxwithEC_2_5;
+ }
+
+ /**
+ * @return Broadcast Audio Tx with EC_3_9 status
+ */
+ boolean isBroadcastAudioTxwithEC_3_9() {
+ return mBroadcastAudioTxwithEC_3_9;
+ }
+
+ /**
+ * @return Broadcast Audio Rx with EC_2_5 status
+ */
+ boolean isBroadcastAudioRxwithEC_2_5() {
+ return mBroadcastAudioRxwithEC_2_5;
+ }
+
+ /**
+ * @return Broadcast Audio Rx with EC_3_9 status
+ */
+ boolean isBroadcastAudioRxwithEC_3_9() {
+ return mBroadcastAudioRxwithEC_3_9;
+ }
+
+ /**
+ * @return Broadcast AddonFeatures Cmd Support status
+ */
+ boolean isAddonFeaturesCmdSupported() {
+ return mAddonFeaturesSupported;
+ }
+
+ /**
* @return the mBondedDevices
*/
BluetoothDevice[] getBondedDevices() {
@@ -602,10 +861,22 @@
return;
}
+
synchronized (mObject) {
+
updateProfileConnectionState(profile, state, prevState);
- if (updateCountersAndCheckForConnectionStateChange(state, prevState)) {
+ boolean validateConnectionState = false;
+
+ try {
+ validateConnectionState =
+ updateCountersAndCheckForConnectionStateChange(state, prevState);
+ } catch (IllegalStateException ee) {
+ Log.w(TAG, "ADAPTER_CONNECTION_STATE_CHANGE: unexpected transition for profile="
+ + profile + ", " + prevState + " -> " + state);
+ }
+
+ if (validateConnectionState) {
int newAdapterState = convertToAdapterState(state);
int prevAdapterState = convertToAdapterState(prevState);
setConnectionState(newAdapterState);
@@ -891,6 +1162,78 @@
+ " mLeMaximumAdvertisingDataLength = " + mLeMaximumAdvertisingDataLength);
}
+ public void updateSocFeatureSupport(byte[] val) {
+ mAddonFeaturesSupported = (val.length != 0);
+ if (!mAddonFeaturesSupported) {
+ Log.d(TAG, "BT_PROPERTY_ADD_ON_FEATURES: add-on features VSC is not supported");
+ } else {
+ mWiPowerFastbootEnabled = ((0x01 & ((int) val[0])) != 0);
+ mSplitA2DPScrambleDataRequired = ((0x02 & ((int) val[0])) != 0);
+ mSplitA2DP44p1KhzSampleFreq = ((0x04 & ((int) val[0])) != 0);
+ mSplitA2DP48KhzSampleFreq = ((0x08 & ((int) val[0])) != 0);
+ mSplitA2DPSingleVSCommandSupport = ((0x10 & ((int) val[0])) != 0);
+ mSplitA2DPSourceSBCEncoding = ((0x20 & ((int) val[0])) != 0);
+ mSplitA2DPSourceSBC = ((0x01 & ((int) val[1])) != 0);
+ mSplitA2DPSourceMP3 = ((0x02 & ((int) val[1])) != 0);
+ mSplitA2DPSourceAAC = ((0x04 & ((int) val[1])) != 0);
+ mSplitA2DPSourceLDAC = ((0x08 & ((int) val[1])) != 0);
+ mSplitA2DPSourceAPTX = ((0x10 & ((int) val[1])) != 0);
+ mSplitA2DPSourceAPTXHD = ((0x20 & ((int) val[1])) != 0);
+ mSplitA2DPSourceAPTXADAPTIVE = ((0x40 & ((int) val[1])) != 0);
+ mSplitA2DPSourceAPTXTWSPLUS = ((0x80 & ((int) val[1])) != 0);
+ mSplitA2DPSinkSBC = ((0x01 & ((int) val[2])) != 0);
+ mSplitA2DPSinkMP3 = ((0x02 & ((int) val[2])) != 0);
+ mSplitA2DPSinkAAC = ((0x04 & ((int) val[2])) != 0);
+ mSplitA2DPSinkLDAC = ((0x08 & ((int) val[2])) != 0);
+ mSplitA2DPSinkAPTX = ((0x10 & ((int) val[2])) != 0);
+ mSplitA2DPSinkAPTXHD = ((0x20 & ((int) val[2])) != 0);
+ mSplitA2DPSinkAPTXADAPTIVE = ((0x40 & ((int) val[2])) != 0);
+ mSplitA2DPSinkAPTXTWSPLUS = ((0x80 & ((int) val[2])) != 0);
+ mVoiceDualSCO = ((0x01 & ((int) val[3])) != 0);
+ mVoiceTWSPLUSeSCOAG = ((0x02 & ((int) val[3])) != 0);
+ mSWBVoicewithAptxAdaptiveAG = ((0x04 & ((int) val[3])) != 0);
+ mBroadcastAudioTxwithEC_2_5 = ((0x01 & ((int) val[4])) != 0);
+ mBroadcastAudioTxwithEC_3_9 = ((0x02 & ((int) val[4])) != 0);
+ mBroadcastAudioRxwithEC_2_5 = ((0x04 & ((int) val[4])) != 0);
+ mBroadcastAudioRxwithEC_3_9 = ((0x08 & ((int) val[4])) != 0);
+
+
+ Log.d(TAG, "BT_PROPERTY_ADD_ON_FEATURES: update from BT controller"
+ + "\n mWiPowerFastbootEnabled = "
+ + mWiPowerFastbootEnabled + "\n SplitA2DPScrambleDataRequired = "
+ + mSplitA2DPScrambleDataRequired + "\n mSplitA2DP44p1KhzSampleFreq = "
+ + mSplitA2DP44p1KhzSampleFreq + "\n mSplitA2DP48KhzSampleFreq = "
+ + mSplitA2DP48KhzSampleFreq + "\n mSplitA2DPSingleVSCommandSupport = "
+ + mSplitA2DPSingleVSCommandSupport + "\n mSplitA2DPSourceSBCEncoding = "
+ + mSplitA2DPSourceSBCEncoding + "\n mSplitA2DPSourceSBC = "
+ + mSplitA2DPSourceSBC + "\n mSplitA2DPSourceMP3 = "
+ + mSplitA2DPSourceMP3 + "\n mSplitA2DPSourceAAC = "
+ + mSplitA2DPSourceAAC + "\n mSplitA2DPSourceLDAC = " + mSplitA2DPSourceLDAC
+ + "\n mSplitA2DPSourceAPTX = " + mSplitA2DPSourceAPTX
+ + "\n mSplitA2DPSourceAPTXHD = " + mSplitA2DPSourceAPTXHD
+ + "\n mSplitA2DPSourceAPTXADAPTIVE = " + mSplitA2DPSourceAPTXADAPTIVE
+ + "\n mSplitA2DPSourceAPTXTWSPLUS = " + mSplitA2DPSourceAPTXTWSPLUS
+ + "\n mSplitA2DPSinkSBC = " + mSplitA2DPSinkSBC + "\n mSplitA2DPSinkMP3 = "
+ + mSplitA2DPSinkMP3 + "\n mSplitA2DPSinkAAC = "
+ + mSplitA2DPSinkAAC + "\n mSplitA2DPSinkLDAC = " + mSplitA2DPSinkLDAC
+ + "\n mSplitA2DPSinkAPTX = " + mSplitA2DPSinkAPTX
+ + "\n mSplitA2DPSinkAPTXHD = " + mSplitA2DPSinkAPTXHD
+ + "\n mSplitA2DPSinkAPTXADAPTIVE = " + mSplitA2DPSinkAPTXADAPTIVE
+ + "\n mSplitA2DPSinkAPTXTWSPLUS = " + mSplitA2DPSinkAPTXTWSPLUS
+ + "\n mVoiceDualSCO = " + mVoiceDualSCO + "\n mVoiceTWSPLUSeSCOAG = "
+ + mVoiceTWSPLUSeSCOAG + "\n mSWBVoicewithAptxAdaptiveAG = "
+ + mSWBVoicewithAptxAdaptiveAG + "\n BroadcastAudioTxwithEC_2_5 = "
+ + mBroadcastAudioTxwithEC_2_5 + "\n mBroadcastAudioTxwithEC_3_9 = "
+ + mBroadcastAudioTxwithEC_3_9 + "\n mBroadcastAudioRxwithEC_2_5 = "
+ + mBroadcastAudioRxwithEC_2_5 + "\n mBroadcastAudioRxwithEC_3_9= "
+ + mBroadcastAudioRxwithEC_3_9);
+ }
+ }
+
+ public void updateHostFeatureSupport(byte[] val) {
+ Log.d(TAG, " Host Features are not supported currently ");
+ }
+
void onBluetoothReady() {
debugLog("onBluetoothReady, state=" + BluetoothAdapter.nameForState(getState())
+ ", ScanMode=" + mScanMode);
@@ -929,7 +1272,7 @@
infoLog("Callback:discoveryStateChangeCallback with state:" + state);
synchronized (mObject) {
Intent intent;
- if (state == AbstractionLayer.BT_DISCOVERY_STOPPED) {
+ if ((state == AbstractionLayer.BT_DISCOVERY_STOPPED) && mDiscovering) {
mDiscovering = false;
mService.clearDiscoveringPackages();
mDiscoveryEndMs = System.currentTimeMillis();
diff --git a/src/com/android/bluetooth/btservice/AdapterService.java b/src/com/android/bluetooth/btservice/AdapterService.java
index a65bcfd..2f0d6ab 100644
--- a/src/com/android/bluetooth/btservice/AdapterService.java
+++ b/src/com/android/bluetooth/btservice/AdapterService.java
@@ -1,4 +1,39 @@
/*
+ * Copyright (C) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted (subject to the limitations in the
+ * disclaimer below) provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
+ * GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
+ * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
@@ -73,10 +108,16 @@
import com.android.bluetooth.btservice.storage.MetadataDatabase;
import com.android.bluetooth.gatt.GattService;
import com.android.bluetooth.sdp.SdpManager;
+import com.android.bluetooth.ba.BATService;
import com.android.internal.R;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.app.IBatteryStats;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiManager;
+import android.net.NetworkInfo;
+import android.net.wifi.WifiConfiguration;
+
import com.google.protobuf.InvalidProtocolBufferException;
import java.io.FileDescriptor;
@@ -101,6 +142,7 @@
private long mRxTimeTotalMs;
private long mIdleTimeTotalMs;
private long mEnergyUsedTotalVoltAmpSecMicro;
+ private WifiManager mWifiManager;
private final SparseArray<UidTraffic> mUidTraffic = new SparseArray<>();
private final ArrayList<ProfileService> mRegisteredProfiles = new ArrayList<>();
@@ -140,6 +182,7 @@
private final ArrayList<DiscoveringPackage> mDiscoveringPackages = new ArrayList<>();
static {
+ System.loadLibrary("bluetooth_jni");
classInitNative();
}
@@ -166,6 +209,8 @@
private AdapterProperties mAdapterProperties;
private AdapterState mAdapterStateMachine;
+ private Vendor mVendor;
+ private boolean mVendorAvailble;
private BondStateMachine mBondStateMachine;
private JniCallbacks mJniCallbacks;
private RemoteDevices mRemoteDevices;
@@ -190,6 +235,7 @@
private PowerManager.WakeLock mWakeLock;
private String mWakeLockName;
private UserManager mUserManager;
+ private static BluetoothAdapter mAdapter;
private ProfileObserver mProfileObserver;
private PhonePolicy mPhonePolicy;
@@ -197,6 +243,7 @@
private DatabaseManager mDatabaseManager;
private SilenceDeviceManager mSilenceDeviceManager;
private AppOpsManager mAppOps;
+ private VendorSocket mVendorSocket;
/**
* Register a {@link ProfileService} with AdapterService.
@@ -232,6 +279,60 @@
mHandler.sendMessage(m);
}
+ public boolean getProfileInfo(int profile_id , int profile_info) {
+ if (isVendorIntfEnabled()) {
+ return mVendor.getProfileInfo(profile_id, profile_info);
+ } else {
+ return false;
+ }
+ }
+
+ private void fetchWifiState() {
+ if (!isVendorIntfEnabled()) {
+ return;
+ }
+ boolean isWifiConnected = false;
+ WifiManager wifiMgr = (WifiManager) getSystemService(Context.WIFI_SERVICE);
+ if ((wifiMgr != null) && (wifiMgr.isWifiEnabled())) {
+ WifiInfo wifiInfo = wifiMgr.getConnectionInfo();
+ if((wifiInfo != null) && (wifiInfo.getNetworkId() != -1)) {
+ isWifiConnected = true;
+ }
+ }
+ mVendor.setWifiState(isWifiConnected);
+ }
+
+ public void StartHCIClose() {
+ if (isVendorIntfEnabled()) {
+ mVendor.HCIClose();
+ }
+ }
+
+ public void voipNetworkWifiInfo(boolean isVoipStarted, boolean isNetworkWifi) {
+ Log.i(TAG, "In voipNetworkWifiInfo, isVoipStarted: " + isVoipStarted +
+ ", isNetworkWifi: " + isNetworkWifi);
+ mVendor.voipNetworkWifiInformation(isVoipStarted, isNetworkWifi);
+ }
+
+ public String getSocName() {
+ return mVendor.getSocName();
+ }
+
+ public String getA2apOffloadCapability() {
+ return mVendor.getA2apOffloadCapability();
+ }
+
+ public boolean isSplitA2dpEnabled() {
+ return mVendor.isSplitA2dpEnabled();
+ }
+
+ public boolean isSwbEnabled() {
+ return mVendor.isSwbEnabled();
+ }
+ public boolean isSwbPmEnabled() {
+ return mVendor.isSwbPmEnabled();
+ }
+
private static final int MESSAGE_PROFILE_SERVICE_STATE_CHANGED = 1;
private static final int MESSAGE_PROFILE_SERVICE_REGISTERED = 2;
private static final int MESSAGE_PROFILE_SERVICE_UNREGISTERED = 3;
@@ -286,15 +387,26 @@
}
mRunningProfiles.add(profile);
if (GattService.class.getSimpleName().equals(profile.getName())) {
+ Log.w(TAG,"onProfileServiceStateChange() - Gatt profile service started..");
enableNative();
} else if (mRegisteredProfiles.size() == Config.getSupportedProfiles().length
&& mRegisteredProfiles.size() == mRunningProfiles.size()) {
+ Log.w(TAG,"onProfileServiceStateChange() - All profile services started..");
mAdapterProperties.onBluetoothReady();
updateUuids();
setBluetoothClassFromConfig();
getAdapterPropertyNative(AbstractionLayer.BT_PROPERTY_LOCAL_IO_CAPS);
getAdapterPropertyNative(AbstractionLayer.BT_PROPERTY_LOCAL_IO_CAPS_BLE);
mAdapterStateMachine.sendMessage(AdapterState.BREDR_STARTED);
+ //update wifi state to lower layers
+ fetchWifiState();
+ if (isVendorIntfEnabled()) {
+ if (isPowerbackRequired()) {
+ mVendor.setPowerBackoff(true);
+ } else {
+ mVendor.setPowerBackoff(false);
+ }
+ }
}
break;
case BluetoothAdapter.STATE_OFF:
@@ -310,8 +422,11 @@
// If only GATT is left, send BREDR_STOPPED.
if ((mRunningProfiles.size() == 1 && (GattService.class.getSimpleName()
.equals(mRunningProfiles.get(0).getName())))) {
+ Log.w(TAG,"onProfileServiceStateChange() - All profile services except gatt stopped..");
mAdapterStateMachine.sendMessage(AdapterState.BREDR_STOPPED);
} else if (mRunningProfiles.size() == 0) {
+ Log.w(TAG,"onProfileServiceStateChange() - All profile services stopped..");
+ mAdapterStateMachine.sendMessage(AdapterState.BLE_STOPPED);
disableNative();
}
break;
@@ -386,13 +501,16 @@
public void onCreate() {
super.onCreate();
debugLog("onCreate()");
+ mAdapter = BluetoothAdapter.getDefaultAdapter();
mRemoteDevices = new RemoteDevices(this, Looper.getMainLooper());
mRemoteDevices.init();
clearDiscoveringPackages();
mBinder = new AdapterServiceBinder(this);
mAdapterProperties = new AdapterProperties(this);
- mAdapterStateMachine = AdapterState.make(this);
+ mVendor = new Vendor(this);
+ mAdapterStateMachine = AdapterState.make(this);
mJniCallbacks = new JniCallbacks(this, mAdapterProperties);
+ mVendorSocket = new VendorSocket(this);
initNative(isGuest(), isNiapMode());
mNativeAvailable = true;
mCallbacks = new RemoteCallbackList<IBluetoothCallback>();
@@ -409,6 +527,11 @@
mSdpManager = SdpManager.init(this);
registerReceiver(mAlarmBroadcastReceiver, new IntentFilter(ACTION_ALARM_WAKEUP));
+ IntentFilter wifiFilter = new IntentFilter();
+ wifiFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+ wifiFilter.addAction(WifiManager.WIFI_AP_STATE_CHANGED_ACTION);
+ wifiFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
+ registerReceiver(mWifiStateBroadcastReceiver, wifiFilter);
mProfileObserver = new ProfileObserver(getApplicationContext(), this, new Handler());
mProfileObserver.start();
@@ -421,6 +544,7 @@
} else {
Log.i(TAG, "Phone policy disabled");
}
+ mBondStateMachine = BondStateMachine.make(mPowerManager, this, mAdapterProperties, mRemoteDevices);
mActiveDeviceManager = new ActiveDeviceManager(this, new ServiceFactory());
mActiveDeviceManager.start();
@@ -448,6 +572,9 @@
return null;
}
}.execute();
+ mVendor.init();
+ mVendorAvailble = mVendor.getQtiStackStatus();
+ mVendorSocket.init();
try {
int systemUiUid = getApplicationContext().getPackageManager().getPackageUidAsUser(
@@ -466,6 +593,18 @@
int fuid = ActivityManager.getCurrentUser();
Utils.setForegroundUserId(fuid);
setForegroundUserIdNative(fuid);
+
+ // Reset |mRemoteDevices| whenever BLE is turned off then on
+ // This is to replace the fact that |mRemoteDevices| was
+ // reinitialized in previous code.
+ //
+ // TODO(apanicke): The reason is unclear but
+ // I believe it is to clear the variable every time BLE was
+ // turned off then on. The same effect can be achieved by
+ // calling cleanup but this may not be necessary at all
+ // We should figure out why this is needed later
+ mRemoteDevices.reset();
+ mAdapterProperties.init(mRemoteDevices);
}
@Override
@@ -476,7 +615,7 @@
@Override
public boolean onUnbind(Intent intent) {
- debugLog("onUnbind() - calling cleanup");
+ Log.w(TAG, "onUnbind, calling cleanup");
cleanup();
return super.onUnbind(intent);
}
@@ -505,26 +644,16 @@
void bringUpBle() {
debugLog("bleOnProcessStart()");
-
+ /* To reload profile support in BLE turning ON state. So even if profile support
+ * is disabled in Bluetooth Adapter turned off state(10), this flag will ensure
+ * rechecking profile support after BT is turned ON
+ */
if (getResources().getBoolean(
- R.bool.config_bluetooth_reload_supported_profiles_when_enabled)) {
+ com.android.bluetooth.R.bool.reload_supported_profiles_when_enabled)) {
Config.init(getApplicationContext());
}
- // Reset |mRemoteDevices| whenever BLE is turned off then on
- // This is to replace the fact that |mRemoteDevices| was
- // reinitialized in previous code.
- //
- // TODO(apanicke): The reason is unclear but
- // I believe it is to clear the variable every time BLE was
- // turned off then on. The same effect can be achieved by
- // calling cleanup but this may not be necessary at all
- // We should figure out why this is needed later
- mRemoteDevices.reset();
- mAdapterProperties.init(mRemoteDevices);
-
- debugLog("bleOnProcessStart() - Make Bond State Machine");
- mBondStateMachine = BondStateMachine.make(this, mAdapterProperties, mRemoteDevices);
+ debugLog("BleOnProcessStart() - Make Bond State Machine");
mJniCallbacks.init(mBondStateMachine, mRemoteDevices);
@@ -547,14 +676,26 @@
void stateChangeCallback(int status) {
if (status == AbstractionLayer.BT_STATE_OFF) {
debugLog("stateChangeCallback: disableNative() completed");
- mAdapterStateMachine.sendMessage(AdapterState.BLE_STOPPED);
+ mAdapterStateMachine.sendMessage(AdapterState.STACK_DISABLED);
} else if (status == AbstractionLayer.BT_STATE_ON) {
+ String BT_SOC = getSocName();
+
+ if (BT_SOC.equals("pronto")) {
+ Log.i(TAG, "setting max audio connection to 2");
+ mAdapterProperties.setMaxConnectedAudioDevices(2);
+ }
mAdapterStateMachine.sendMessage(AdapterState.BLE_STARTED);
} else {
Log.e(TAG, "Incorrect status " + status + " in stateChangeCallback");
}
}
+ void ssrCleanupCallback() {
+ disableProfileServices(false);
+ Log.e(TAG, "Killing the process to force restart as part of fault tolerance");
+ android.os.Process.killProcess(android.os.Process.myPid());
+ }
+
/**
* Sets the Bluetooth CoD value of the local adapter if there exists a config value for it.
*/
@@ -581,6 +722,10 @@
return result;
}
+ void startBluetoothDisable() {
+ mAdapterStateMachine.sendMessage(AdapterState.BEGIN_BREDR_STOP);
+ }
+
void startProfileServices() {
debugLog("startCoreServices()");
Class[] supportedProfileServices = Config.getSupportedProfiles();
@@ -595,8 +740,23 @@
}
}
- void stopProfileServices() {
+ void startBrEdrStartup(){
+ if (isVendorIntfEnabled()) {
+ mVendor.bredrStartup();
+ }
+ }
+
+ void startBrEdrCleanup(){
mAdapterProperties.onBluetoothDisable();
+ if (isVendorIntfEnabled()) {
+ mVendor.bredrCleanup();
+ } else {
+ mAdapterStateMachine.sendMessage(
+ mAdapterStateMachine.obtainMessage(AdapterState.BEGIN_BREDR_STOP));
+ }
+ }
+
+ void stopProfileServices() {
Class[] supportedProfileServices = Config.getSupportedProfiles();
if (supportedProfileServices.length == 1 && (mRunningProfiles.size() == 1
&& GattService.class.getSimpleName().equals(mRunningProfiles.get(0).getName()))) {
@@ -607,6 +767,27 @@
}
}
+ void disableProfileServices(boolean onlyGatt) {
+ Class[] services = Config.getSupportedProfiles();
+ for (int i = 0; i < services.length; i++) {
+ if (onlyGatt && !(GattService.class.getSimpleName().equals(services[i].getSimpleName())))
+ continue;
+ boolean res = false;
+ String serviceName = services[i].getName();
+ mProfileServicesState.put(serviceName,BluetoothAdapter.STATE_OFF);
+ Intent intent = new Intent(this,services[i]);
+ intent.putExtra(EXTRA_ACTION,ACTION_SERVICE_STATE_CHANGED);
+ intent.putExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.STATE_OFF);
+ intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
+ res = stopService(intent);
+ Log.d(TAG, "disableProfileServices() - Stopping service "
+ + serviceName + " with result: " + res);
+ if(onlyGatt)
+ break;
+ }
+ return;
+ }
+
private void stopGattProfileService() {
mAdapterProperties.onBleDisable();
if (mRunningProfiles.size() == 0) {
@@ -664,11 +845,18 @@
return;
}
+ // Unregistering Bluetooth Adapter
+ if ( mAdapter!= null ){
+ mAdapter.unregisterAdapter();
+ mAdapter = null;
+ }
+
clearAdapterService(this);
mCleaningUp = true;
unregisterReceiver(mAlarmBroadcastReceiver);
+ unregisterReceiver(mWifiStateBroadcastReceiver);
if (mPendingAlarm != null) {
mAlarmManager.cancel(mPendingAlarm);
@@ -717,6 +905,14 @@
mAdapterProperties.cleanup();
}
+ if (mVendor != null) {
+ mVendor.cleanup();
+ }
+
+ if (mVendorSocket!= null) {
+ mVendorSocket.cleanup();
+ }
+
if (mJniCallbacks != null) {
mJniCallbacks.cleanup();
}
@@ -751,6 +947,7 @@
Intent intent = new Intent(this, service);
intent.putExtra(EXTRA_ACTION, ACTION_SERVICE_STATE_CHANGED);
intent.putExtra(BluetoothAdapter.EXTRA_STATE, state);
+ intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
startService(intent);
}
@@ -1216,6 +1413,17 @@
}
@Override
+ public void setBondingInitiatedLocally(BluetoothDevice device, boolean localInitiated) {
+ // don't check caller, may be called from system UI
+ AdapterService service = getService();
+ if (service == null) {
+ return;
+ }
+ service.setBondingInitiatedLocally(device,localInitiated);
+ return;
+ }
+
+ @Override
public long getSupportedProfiles() {
AdapterService service = getService();
if (service == null) {
@@ -1519,6 +1727,28 @@
return service.sdpSearch(device, uuid);
}
+ public boolean isTwsPlusDevice(BluetoothDevice device) {
+ if (!Utils.checkCaller()) {
+ Log.w(TAG,"(): isTws+device(): not allowed for non-active user");
+ return false;
+ }
+
+ AdapterService service = getService();
+ if (service == null) return false;
+ return service.isTwsPlusDevice(device);
+ }
+
+ public String getTwsPlusPeerAddress(BluetoothDevice device) {
+ if (!Utils.checkCaller()) {
+ Log.w(TAG,"getTws+peerAddress(): not allowed for non-active user");
+ return null;
+ }
+
+ AdapterService service = getService();
+ if (service == null) return null;
+ return service.getTwsPlusPeerAddress(device);
+ }
+
@Override
public int getBatteryLevel(BluetoothDevice device) {
if (!Utils.checkCaller()) {
@@ -1559,8 +1789,11 @@
if (service == null) {
return false;
}
+ if ((getState() == BluetoothAdapter.STATE_BLE_ON) ||
+ (getState() == BluetoothAdapter.STATE_BLE_TURNING_ON)) {
+ service.onBrEdrDown();
+ }
return service.factoryReset();
-
}
@Override
@@ -1727,6 +1960,16 @@
}
@Override
+ public void updateQuietModeStatus(boolean quietMode) {
+ AdapterService service = getService();
+ if (service == null) {
+ return;
+ }
+ service.updateQuietModeStatus(quietMode);
+ }
+
+
+ @Override
public void onBrEdrDown() {
AdapterService service = getService();
if (service == null) {
@@ -1735,6 +1978,29 @@
service.onBrEdrDown();
}
+ public int setSocketOpt(int type, int channel, int optionName, byte [] optionVal,
+ int optionLen) {
+ if (!Utils.checkCaller()) {
+ Log.w(TAG,"setSocketOpt(): not allowed for non-active user");
+ return -1;
+ }
+
+ AdapterService service = getService();
+ if (service == null) return -1;
+ return service.setSocketOpt(type, channel, optionName, optionVal, optionLen);
+ }
+
+ public int getSocketOpt(int type, int channel, int optionName, byte [] optionVal) {
+ if (!Utils.checkCaller()) {
+ Log.w(TAG,"getSocketOpt(): not allowed for non-active user");
+ return -1;
+ }
+
+ AdapterService service = getService();
+ if (service == null) return -1;
+ return service.getSocketOpt(type, channel, optionName, optionVal);
+ }
+
@Override
public void dump(FileDescriptor fd, String[] args) {
PrintWriter writer = new PrintWriter(new FileOutputStream(fd));
@@ -1756,6 +2022,10 @@
return mAdapterProperties.getState() == BluetoothAdapter.STATE_ON;
}
+ public boolean isVendorIntfEnabled() {
+ return mVendorAvailble;
+ }
+
public int getState() {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
if (mAdapterProperties != null) {
@@ -1891,6 +2161,74 @@
return mAdapterProperties.setLeIoCapability(capability);
}
+ boolean setTwsPlusDevType(byte[] address, short twsPlusDevType) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ BluetoothDevice device = mRemoteDevices.getDevice(address);
+ DeviceProperties deviceProp;
+ if (device == null) {
+ deviceProp = mRemoteDevices.addDeviceProperties(address);
+ } else {
+ deviceProp = mRemoteDevices.getDeviceProperties(device);
+ }
+ if(deviceProp != null) {
+ deviceProp.setTwsPlusDevType(twsPlusDevType);
+ return true;
+ }
+ return false;
+ }
+
+ boolean setTwsPlusPeerEbAddress(byte[] address, byte[] peerEbAddress) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ BluetoothDevice device = mRemoteDevices.getDevice(address);
+ BluetoothDevice peerDevice = null;
+ DeviceProperties deviceProp;
+ DeviceProperties peerDeviceProp;
+
+ if(peerEbAddress != null)
+ peerDevice = mRemoteDevices.getDevice(peerEbAddress);
+
+ if (device == null) {
+ deviceProp = mRemoteDevices.addDeviceProperties(address);
+ } else {
+ deviceProp = mRemoteDevices.getDeviceProperties(device);
+ }
+ if (peerDevice == null && peerEbAddress != null) {
+ peerDeviceProp = mRemoteDevices.addDeviceProperties(peerEbAddress);
+ peerDevice = mRemoteDevices.getDevice(peerEbAddress);
+ }
+ if(deviceProp != null) {
+ deviceProp.setTwsPlusPeerEbAddress(peerDevice, peerEbAddress);
+ return true;
+ }
+ return false;
+ }
+
+ boolean setTwsPlusAutoConnect(byte[] address, boolean autoConnect) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ BluetoothDevice device = mRemoteDevices.getDevice(address);
+ BluetoothDevice peerDevice = null;
+ DeviceProperties deviceProp;
+
+ if (device == null) {
+ deviceProp = mRemoteDevices.addDeviceProperties(address);
+ } else {
+ deviceProp = mRemoteDevices.getDeviceProperties(device);
+ }
+ if(deviceProp != null) {
+ deviceProp.setTwsPlusAutoConnect(peerDevice, autoConnect);
+ return true;
+ }
+ return false;
+ }
+
+ void updateHostFeatureSupport(byte[] val) {
+ mAdapterProperties.updateHostFeatureSupport(val);
+ }
+
+ void updateSocFeatureSupport(byte[] val) {
+ mAdapterProperties.updateSocFeatureSupport(val);
+ }
+
int getScanMode() {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
@@ -1951,6 +2289,10 @@
permission = android.Manifest.permission.ACCESS_COARSE_LOCATION;
}
+ if (mAdapterProperties.isDiscovering()) {
+ Log.i(TAG,"discovery already active, ignore startDiscovery");
+ return false;
+ }
synchronized (mDiscoveringPackages) {
mDiscoveringPackages.add(new DiscoveringPackage(callingPackage, permission));
}
@@ -1961,6 +2303,10 @@
debugLog("cancelDiscovery");
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission");
+ if (!mAdapterProperties.isDiscovering()) {
+ Log.i(TAG,"discovery not active, ignore cancelDiscovery");
+ return false;
+ }
return cancelDiscoveryNative();
}
@@ -2017,6 +2363,35 @@
}
}
+ public boolean isTwsPlusDevice(BluetoothDevice device) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ DeviceProperties deviceProp = mRemoteDevices.getDeviceProperties(device);
+ if (deviceProp == null) {
+ return false;
+ }
+ return (deviceProp.getTwsPlusPeerAddress() != null);
+ }
+
+ public String getTwsPlusPeerAddress(BluetoothDevice device) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ DeviceProperties deviceProp = mRemoteDevices.getDeviceProperties(device);
+ if (deviceProp == null) {
+ return null;
+ }
+ byte[] address = deviceProp.getTwsPlusPeerAddress();
+ return Utils.getAddressStringFromByte(address);
+ }
+
+ public BluetoothDevice getTwsPlusPeerDevice(BluetoothDevice device) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ DeviceProperties deviceProp = mRemoteDevices.getDeviceProperties(device);
+ if (deviceProp == null) {
+ return null;
+ }
+ byte[] address = deviceProp.getTwsPlusPeerAddress();
+ return mRemoteDevices.getDevice(address);
+ }
+
boolean createBond(BluetoothDevice device, int transport, OobData oobData) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission");
DeviceProperties deviceProp = mRemoteDevices.getDeviceProperties(device);
@@ -2028,7 +2403,11 @@
// Pairing is unreliable while scanning, so cancel discovery
// Note, remove this when native stack improves
- cancelDiscoveryNative();
+ if (!mAdapterProperties.isDiscovering()) {
+ Log.i(TAG,"discovery not active, no need to send cancelDiscovery");
+ } else {
+ cancelDiscoveryNative();
+ }
Message msg = mBondStateMachine.obtainMessage(BondStateMachine.CREATE_BOND);
msg.obj = device;
@@ -2091,7 +2470,9 @@
return false;
}
deviceProp.setBondingInitiatedLocally(false);
-
+ if (device.isTwsPlusDevice()) {
+ mActiveDeviceManager.notify_active_device_unbonding(device);
+ }
Message msg = mBondStateMachine.obtainMessage(BondStateMachine.REMOVE_BOND);
msg.obj = device;
mBondStateMachine.sendMessage(msg);
@@ -2126,6 +2507,17 @@
return deviceProp.isBondingInitiatedLocally();
}
+ void setBondingInitiatedLocally(BluetoothDevice device, boolean localInitiated) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ DeviceProperties deviceProp = mRemoteDevices.getDeviceProperties(device);
+ if (deviceProp == null) {
+ return;
+ }
+ Log.w(TAG," localInitiated " + localInitiated);
+ deviceProp.setBondingInitiatedLocally(localInitiated);
+ return;
+ }
+
long getSupportedProfiles() {
return Config.getSupportedProfilesBitMask();
}
@@ -2144,6 +2536,10 @@
*/
public String getRemoteName(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ if (device.getAddress().equals(BATService.mBAAddress)) {
+ Log.d(TAG," Request Name for BA device ");
+ return "Broadcast_Audio";
+ }
if (mRemoteDevices == null) {
return null;
}
@@ -2210,6 +2606,10 @@
boolean fetchRemoteUuids(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ if (device.getAddress().equals(BATService.mBAAddress)) {
+ Log.d(TAG," Update from BA, don't check UUIDS, bail out");
+ return false;
+ }
mRemoteDevices.fetchUuids(device);
return true;
}
@@ -2495,6 +2895,312 @@
return mAdapterProperties.isA2dpOffloadEnabled();
}
+ /**
+ * Check whether Wipower Fastboot enabled.
+ *
+ * @return true if Wipower fastboot is enabled
+ */
+ public boolean isWipowerFastbootEnabled() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isWipowerFastbootEnabled();
+ }
+
+ /**
+ * Check whether Split A2DP Scramble Data Required
+ *
+ * @return true if Split A2DP Scramble Data Required is enabled
+ */
+ public boolean isSplitA2DPScrambleDataRequired() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPScrambleDataRequired();
+ }
+
+ /**
+ * Check whether Split A2DP 44.1Khz Sample Freq enabled.
+ *
+ * @return true if Split A2DP 44.1Khz Sample Freq is enabled
+ */
+ public boolean isSplitA2DP44p1KhzSampleFreq() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DP44p1KhzSampleFreq();
+ }
+
+ /**
+ * Check whether Split A2DP 48Khz Sample Freq enabled.
+ *
+ * @return true if Split A2DP 48Khz Sample Freq is enabled
+ */
+ public boolean isSplitA2DP48KhzSampleFreq() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DP48KhzSampleFreq();
+ }
+
+ /**
+ * Check whether Split A2DP Single VS Command Support enabled.
+ *
+ * @return true if Split A2DP Single VSCommand Support is enabled
+ */
+ public boolean isSplitA2DPSingleVSCommandSupport() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSingleVSCommandSupport();
+ }
+
+ /**
+ * Check whether Split A2DP Source SBC Encoding enabled.
+ *
+ * @return true if Split A2DP Source SBC Encoding is enabled
+ */
+ public boolean isSplitA2DPSourceSBCEncoding() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSourceSBCEncoding();
+ }
+
+ /**
+ * Check whether Split A2DP Source SBC enabled.
+ *
+ * @return true if Split A2DP Source SBC is enabled
+ */
+ public boolean isSplitA2DPSourceSBC() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSourceSBC();
+ }
+
+ /**
+ * Check whether Split A2DP Source MP3 enabled.
+ *
+ * @return true if Split A2DP Source MP3 is enabled
+ */
+ public boolean isSplitA2DPSourceMP3() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSourceMP3();
+ }
+
+ /**
+ * Check whether Split A2DP Source AAC enabled.
+ *
+ * @return true if Split A2DP Source AAC is enabled
+ */
+ public boolean isSplitA2DPSourceAAC() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSourceAAC();
+ }
+
+ /**
+ * Check whether Split A2DP Source LDAC enabled.
+ *
+ * @return true if Split A2DP Source LDAC is enabled
+ */
+ public boolean isSplitA2DPSourceLDAC() {
+ String BT_SOC = getSocName();
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return (!mAdapterProperties.isAddonFeaturesCmdSupported() && BT_SOC.equals("cherokee")) ||
+ mAdapterProperties.isSplitA2DPSourceLDAC();
+ }
+
+ /**
+ * Check whether Split A2DP Source APTX enabled.
+ *
+ * @return true if Split A2DP Source APTX is enabled
+ */
+ public boolean isSplitA2DPSourceAPTX() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSourceAPTX();
+ }
+
+ /**
+ * Check whether Split A2DP Source APTX HD enabled.
+ *
+ * @return true if Split A2DP Source APTX HD is enabled
+ */
+ public boolean isSplitA2DPSourceAPTXHD() {
+ String BT_SOC = getSocName();
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return (!mAdapterProperties.isAddonFeaturesCmdSupported() && BT_SOC.equals("cherokee")) ||
+ mAdapterProperties.isSplitA2DPSourceAPTXHD();
+ }
+
+ /**
+ * Check whether Split A2DP Source APTX ADAPTIVE enabled.
+ *
+ * @return true if Split A2DP Source APTX ADAPTIVE is enabled
+ */
+ public boolean isSplitA2DPSourceAPTXADAPTIVE() {
+ String BT_SOC = getSocName();
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return (!mAdapterProperties.isAddonFeaturesCmdSupported() && BT_SOC.equals("cherokee")) ||
+ mAdapterProperties.isSplitA2DPSourceAPTXADAPTIVE();
+ }
+
+ /**
+ * Check whether Split A2DP Source APTX TWS+ enabled.
+ *
+ * @return true if Split A2DP Source APTX TWS+ is enabled
+ */
+ public boolean isSplitA2DPSourceAPTXTWSPLUS() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSourceAPTXTWSPLUS();
+ }
+
+ /**
+ * Check whether Split A2DP Sink SBC enabled.
+ *
+ * @return true if Split A2DP Sink SBC is enabled
+ */
+ public boolean isSplitA2DPSinkSBC() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSinkSBC();
+ }
+
+ /**
+ * Check whether Split A2DP Sink MP3 enabled.
+ *
+ * @return true if Split A2DP Sink MP3 is enabled
+ */
+ public boolean isSplitA2DPSinkMP3() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSinkMP3();
+ }
+
+ /**
+ * Check whether Split A2DP Sink AAC enabled.
+ *
+ * @return true if Split A2DP Sink AAC is enabled
+ */
+ public boolean isSplitA2DPSinkAAC() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSinkAAC();
+ }
+
+ /**
+ * Check whether Split A2DP Sink LDAC enabled.
+ *
+ * @return true if Split A2DP Sink LDAC is enabled
+ */
+ public boolean isSplitA2DPSinkLDAC() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSinkLDAC();
+ }
+
+ /**
+ * Check whether Split A2DP Sink APTX enabled.
+ *
+ * @return true if Split A2DP Sink APTX is enabled
+ */
+ public boolean isSplitA2DPSinkAPTX() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSinkAPTX();
+ }
+
+ /**
+ * Check whether Split A2DP Sink APTX HD enabled.
+ *
+ * @return true if Split A2DP Sink APTX HD is enabled
+ */
+ public boolean isSplitA2DPSinkAPTXHD() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSinkAPTXHD();
+ }
+
+ /**
+ * Check whether Split A2DP Sink APTX ADAPTIVE enabled.
+ *
+ * @return true if Split A2DP Sink APTX ADAPTIVE is enabled
+ */
+ public boolean isSplitA2DPSinkAPTXADAPTIVE() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSinkAPTXADAPTIVE();
+ }
+
+ /**
+ * Check whether Split A2DP Sink APTX TWS+ enabled.
+ *
+ * @return true if Split A2DP Sink APTX TWS+ is enabled
+ */
+ public boolean isSplitA2DPSinkAPTXTWSPLUS() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSplitA2DPSinkAPTXTWSPLUS();
+ }
+
+ /**
+ * Check whether Voice Dual SCO enabled.
+ *
+ * @return true if Voice Dual SCO is enabled
+ */
+ public boolean isVoiceDualSCO() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isVoiceDualSCO();
+ }
+
+ /**
+ * Check whether Voice TWS+ eSCO AG enabled.
+ *
+ * @return true if Voice TWS+ eSCO AG is enabled
+ */
+ public boolean isVoiceTWSPLUSeSCOAG() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isVoiceTWSPLUSeSCOAG();
+ }
+
+ /**
+ * Check whether SWB Voice with Aptx Adaptive AG enabled.
+ *
+ * @return true if SWB Voice with Aptx Adaptive AG is enabled
+ */
+ public boolean isSWBVoicewithAptxAdaptiveAG() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isSWBVoicewithAptxAdaptiveAG();
+ }
+
+ /**
+ * Check whether Broadcast Audio Tx with EC-2:5 enabled.
+ *
+ * @return true if Broadcast Audio Tx with EC-2:5 is enabled
+ */
+ public boolean isBroadcastAudioTxwithEC_2_5() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isBroadcastAudioTxwithEC_2_5();
+ }
+
+ /**
+ * Check whether Broadcast Audio Tx with EC_3:9 enabled.
+ *
+ * @return true if Broadcast Audio Tx with EC_3:9 is enabled
+ */
+ public boolean isBroadcastAudioTxwithEC_3_9() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isBroadcastAudioTxwithEC_3_9();
+ }
+
+ /**
+ * Check whether Broadcast Audio Rx with EC_2:5 enabled.
+ *
+ * @return true if Broadcast Audio Rx with EC_2:5 is enabled
+ */
+ public boolean isBroadcastAudioRxwithEC_2_5() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isBroadcastAudioRxwithEC_2_5();
+ }
+
+ /**
+ * Check whether Broadcast Audio Rx with EC_3:9 enabled.
+ *
+ * @return true if Broadcast Audio Rx with EC_3:9 is enabled
+ */
+ public boolean isBroadcastAudioRxwithEC_3_9() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isBroadcastAudioRxwithEC_3_9();
+ }
+
+ /**
+ * Check AddonFeatures Cmd Support.
+ *
+ * @return true if AddonFeatures Cmd is Supported
+ */
+ public boolean isAddonFeaturesCmdSupported() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ return mAdapterProperties.isAddonFeaturesCmdSupported();
+ }
+
private BluetoothActivityEnergyInfo reportActivityInfo() {
enforceCallingOrSelfPermission(BLUETOOTH_PRIVILEGED, "Need BLUETOOTH permission");
if (mAdapterProperties.getState() != BluetoothAdapter.STATE_ON
@@ -2548,6 +3254,12 @@
return mAdapterProperties.getTotalNumOfTrackableAdvertisements();
}
+ void updateQuietModeStatus(boolean quietMode) {
+ debugLog("updateQuietModeStatus()-updateQuietModeStatus called with quiet mode status:"
+ + quietMode);
+ mQuietmode = quietMode;
+ }
+
void onLeServiceUp() {
mAdapterStateMachine.sendMessage(AdapterState.USER_TURN_ON);
}
@@ -2556,6 +3268,19 @@
mAdapterStateMachine.sendMessage(AdapterState.BLE_TURN_OFF);
}
+ int setSocketOpt(int type, int channel, int optionName, byte [] optionVal,
+ int optionLen) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+
+ return mVendorSocket.setSocketOpt(type, channel, optionName, optionVal, optionLen);
+ }
+
+ int getSocketOpt(int type, int channel, int optionName, byte [] optionVal) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+
+ return mVendorSocket.getSocketOpt(type, channel, optionName, optionVal);
+ }
+
private static int convertScanModeToHal(int mode) {
switch (mode) {
case BluetoothAdapter.SCAN_MODE_NONE:
@@ -2866,6 +3591,26 @@
}
};
+ private final BroadcastReceiver mWifiStateBroadcastReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ String action = (intent != null) ? intent.getAction():null;
+ debugLog(action);
+ if (action == null) return;
+ if (isEnabled() && (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION))) {
+ fetchWifiState();
+ } else if (isEnabled() &&
+ (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION) ||
+ (action.equals(WifiManager.WIFI_AP_STATE_CHANGED_ACTION)))){
+ if (isPowerbackRequired()) {
+ mVendor.setPowerBackoff(true);
+ } else {
+ mVendor.setPowerBackoff(false);
+ }
+ }
+ }
+ };
+
private boolean isGuest() {
return UserManager.get(this).isGuestUser();
}
@@ -2882,12 +3627,29 @@
* or empty byte array when either device is null or obfuscateAddressNative fails
*/
public byte[] obfuscateAddress(BluetoothDevice device) {
- if (device == null) {
- return new byte[0];
- }
- return obfuscateAddressNative(Utils.getByteAddress(device));
+ if (device == null) {
+ return new byte[0];
+ }
+ return obfuscateAddressNative(Utils.getByteAddress(device));
}
+ private boolean isPowerbackRequired() {
+ try {
+
+ WifiManager mWifiManager = (WifiManager)getSystemService(Context.WIFI_SERVICE);
+ final WifiConfiguration config = mWifiManager.getWifiApConfiguration();
+ if ((mWifiManager != null) && ((mWifiManager.isWifiEnabled() ||
+ ((mWifiManager.getWifiApState() == WifiManager.WIFI_AP_STATE_ENABLED) &&
+ (config.apBand == WifiConfiguration.AP_BAND_5GHZ))))) {
+ return true;
+ }
+ return false;
+ } catch(SecurityException e) {
+ debugLog(e.toString());
+ }
+ return false;
+ }
+
static native void classInitNative();
native boolean initNative(boolean startRestricted, boolean isNiapMode);
diff --git a/src/com/android/bluetooth/btservice/AdapterState.java b/src/com/android/bluetooth/btservice/AdapterState.java
index 94feef2..d36f9e6 100644
--- a/src/com/android/bluetooth/btservice/AdapterState.java
+++ b/src/com/android/bluetooth/btservice/AdapterState.java
@@ -69,11 +69,21 @@
static final int BREDR_STOP_TIMEOUT = 10;
static final int BLE_STOP_TIMEOUT = 11;
static final int BLE_START_TIMEOUT = 12;
+ static final int BEGIN_BREDR_STOP = 13;
+ static final int STACK_DISABLED = 14;
+ static final int STACK_DISABLE_TIMEOUT = 15;
+ static final int BREDR_CLEANUP_TIMEOUT = 16;
+ static final int BT_FORCEKILL_TIMEOUT = 17;
- static final int BLE_START_TIMEOUT_DELAY = 4000;
+ // TODO: To be optimized : Increased BLE_START_TIMEOUT_DELAY to 6 sec
+ // as OMR1 Total timeout value was 14 seconds
+ static final int BLE_START_TIMEOUT_DELAY = 6000;
static final int BLE_STOP_TIMEOUT_DELAY = 1000;
static final int BREDR_START_TIMEOUT_DELAY = 4000;
static final int BREDR_STOP_TIMEOUT_DELAY = 4000;
+ static final int BREDR_CLEANUP_TIMEOUT_DELAY = 2000;
+ static final int STACK_DISABLE_TIMEOUT_DELAY = 8000;
+ static final int BT_FORCEKILL_TIMEOUT_DELAY = 100;
private AdapterService mAdapterService;
private TurningOnState mTurningOnState = new TurningOnState();
@@ -181,6 +191,11 @@
transitionTo(mTurningBleOnState);
break;
+ case BT_FORCEKILL_TIMEOUT:
+ errorLog("Killing the process to force a restart as part of cleanup");
+ android.os.Process.killProcess(android.os.Process.myPid());
+ break;
+
default:
infoLog("Unhandled message - " + messageString(msg.what));
return false;
@@ -200,6 +215,7 @@
public boolean processMessage(Message msg) {
switch (msg.what) {
case USER_TURN_ON:
+ mAdapterService.startBrEdrStartup();
transitionTo(mTurningOnState);
break;
@@ -207,6 +223,12 @@
transitionTo(mTurningBleOffState);
break;
+ case BT_FORCEKILL_TIMEOUT:
+ transitionTo(mOffState);
+ errorLog("Killing the process to force a restart as part of cleanup");
+ android.os.Process.killProcess(android.os.Process.myPid());
+ break;
+
default:
infoLog("Unhandled message - " + messageString(msg.what));
return false;
@@ -229,6 +251,12 @@
transitionTo(mTurningOffState);
break;
+ case BT_FORCEKILL_TIMEOUT:
+ transitionTo(mOffState);
+ errorLog("Killing the process to force a restart as part of cleanup");
+ android.os.Process.killProcess(android.os.Process.myPid());
+ break;
+
default:
infoLog("Unhandled message - " + messageString(msg.what));
return false;
@@ -266,7 +294,16 @@
case BLE_START_TIMEOUT:
errorLog(messageString(msg.what));
- transitionTo(mTurningBleOffState);
+ mAdapterService.disableProfileServices(true);
+ mAdapterService.StartHCIClose();
+ errorLog("BLE_START_TIMEOUT is going to kill the process as part of cleanup");
+ sendMessageDelayed(BT_FORCEKILL_TIMEOUT, BT_FORCEKILL_TIMEOUT_DELAY);
+ break;
+
+ case BT_FORCEKILL_TIMEOUT:
+ transitionTo(mOffState);
+ errorLog("Killing the process to force a restart as part of cleanup");
+ android.os.Process.killProcess(android.os.Process.myPid());
break;
default:
@@ -306,7 +343,16 @@
case BREDR_START_TIMEOUT:
errorLog(messageString(msg.what));
- transitionTo(mTurningOffState);
+ mAdapterService.disableProfileServices(false);
+ mAdapterService.StartHCIClose();
+ errorLog("BREDR_START_TIMEOUT is going to kill the process as part of cleanup");
+ sendMessageDelayed(BT_FORCEKILL_TIMEOUT, BT_FORCEKILL_TIMEOUT_DELAY);
+ break;
+
+ case BT_FORCEKILL_TIMEOUT:
+ transitionTo(mOffState);
+ errorLog("Killing the process to force a restart as part of cleanup");
+ android.os.Process.killProcess(android.os.Process.myPid());
break;
default:
@@ -327,8 +373,9 @@
@Override
public void enter() {
super.enter();
- sendMessageDelayed(BREDR_STOP_TIMEOUT, BREDR_STOP_TIMEOUT_DELAY);
- mAdapterService.stopProfileServices();
+ Log.w(TAG,"Calling startBrEdrCleanup");
+ sendMessageDelayed(BREDR_CLEANUP_TIMEOUT, BREDR_CLEANUP_TIMEOUT_DELAY);
+ mAdapterService.startBrEdrCleanup();
}
@Override
@@ -346,7 +393,30 @@
case BREDR_STOP_TIMEOUT:
errorLog(messageString(msg.what));
- transitionTo(mTurningBleOffState);
+ mAdapterService.disableProfileServices(false);
+ mAdapterService.StartHCIClose();
+ errorLog("BREDR_STOP_TIMEOUT is going to kill the process as part of cleanup");
+ sendMessageDelayed(BT_FORCEKILL_TIMEOUT, BT_FORCEKILL_TIMEOUT_DELAY);
+ break;
+
+ case BT_FORCEKILL_TIMEOUT:
+ transitionTo(mOffState);
+ errorLog("Killing the process to force a restart as part of cleanup");
+ android.os.Process.killProcess(android.os.Process.myPid());
+ break;
+
+ case BREDR_CLEANUP_TIMEOUT:
+ errorLog("Error cleaningup Bluetooth profiles (cleanup timeout)");
+ mAdapterService.disableProfileServices(false);
+ mAdapterService.StartHCIClose();
+ errorLog("BREDR_CLEANUP_TIMEOUT going to kill the process as part of cleanup");
+ sendMessageDelayed(BT_FORCEKILL_TIMEOUT, BT_FORCEKILL_TIMEOUT_DELAY);
+ break;
+
+ case BEGIN_BREDR_STOP:
+ removeMessages(BREDR_CLEANUP_TIMEOUT);
+ sendMessageDelayed(BREDR_STOP_TIMEOUT, BREDR_STOP_TIMEOUT_DELAY);
+ mAdapterService.stopProfileServices();
break;
default:
@@ -367,8 +437,13 @@
@Override
public void enter() {
super.enter();
- sendMessageDelayed(BLE_STOP_TIMEOUT, BLE_STOP_TIMEOUT_DELAY);
- mAdapterService.bringDownBle();
+ sendMessageDelayed(STACK_DISABLE_TIMEOUT, STACK_DISABLE_TIMEOUT_DELAY);
+ boolean ret = mAdapterService.disableNative();
+ if (!ret) {
+ removeMessages(STACK_DISABLE_TIMEOUT);
+ errorLog("Error while calling disableNative");
+ transitionTo(mBleOnState);
+ }
}
@Override
@@ -385,10 +460,30 @@
break;
case BLE_STOP_TIMEOUT:
+ errorLog("Error stopping Bluetooth profiles (BLE stop timeout)");
errorLog(messageString(msg.what));
transitionTo(mOffState);
break;
+ case STACK_DISABLED:
+ removeMessages(STACK_DISABLE_TIMEOUT);
+ sendMessageDelayed(BLE_STOP_TIMEOUT, BLE_STOP_TIMEOUT_DELAY);
+ mAdapterService.bringDownBle();
+ break;
+
+ case STACK_DISABLE_TIMEOUT:
+ mAdapterService.disableProfileServices(true);
+ mAdapterService.StartHCIClose();
+ errorLog("STACK_DISABLE_TIMEOUT going to kill the process as part of cleanup");
+ sendMessageDelayed(BT_FORCEKILL_TIMEOUT, BT_FORCEKILL_TIMEOUT_DELAY);
+ break;
+
+ case BT_FORCEKILL_TIMEOUT:
+ transitionTo(mOffState);
+ errorLog("Killing the process to force a restart as part of cleanup");
+ android.os.Process.killProcess(android.os.Process.myPid());
+ break;
+
default:
infoLog("Unhandled message - " + messageString(msg.what));
return false;
diff --git a/src/com/android/bluetooth/btservice/BondStateMachine.java b/src/com/android/bluetooth/btservice/BondStateMachine.java
index 037753e..4ba610c 100644
--- a/src/com/android/bluetooth/btservice/BondStateMachine.java
+++ b/src/com/android/bluetooth/btservice/BondStateMachine.java
@@ -1,4 +1,6 @@
/*
+ * Copyright (C) 2018 The Linux Foundation. All rights reserved.
+ * Not a Contribution
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,6 +28,7 @@
import android.os.Message;
import android.os.UserHandle;
import android.util.Log;
+import android.os.PowerManager;
import android.util.StatsLog;
import com.android.bluetooth.Utils;
@@ -73,6 +76,10 @@
private RemoteDevices mRemoteDevices;
private BluetoothAdapter mAdapter;
+ /* The WakeLock is used for bringing up the LCD during a pairing request
+ * from remote device when Android is in Suspend state.*/
+ private PowerManager.WakeLock mWakeLock;
+
private PendingCommandState mPendingCommandState = new PendingCommandState();
private StableState mStableState = new StableState();
@@ -80,8 +87,11 @@
@VisibleForTesting Set<BluetoothDevice> mPendingBondedDevices = new HashSet<>();
- private BondStateMachine(AdapterService service, AdapterProperties prop,
- RemoteDevices remoteDevices) {
+ private final ArrayList<BluetoothDevice> mDevices =
+ new ArrayList<BluetoothDevice>();
+
+ private BondStateMachine(PowerManager pm, AdapterService service,
+ AdapterProperties prop, RemoteDevices remoteDevices) {
super("BondStateMachine:");
addState(mStableState);
addState(mPendingCommandState);
@@ -90,17 +100,22 @@
mAdapterProperties = prop;
mAdapter = BluetoothAdapter.getDefaultAdapter();
setInitialState(mStableState);
+
+ //WakeLock instantiation in RemoteDevices class
+ mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK
+ | PowerManager.ACQUIRE_CAUSES_WAKEUP | PowerManager.ON_AFTER_RELEASE, TAG);
+ mWakeLock.setReferenceCounted(false);
}
- public static BondStateMachine make(AdapterService service, AdapterProperties prop,
- RemoteDevices remoteDevices) {
+ public static BondStateMachine make(PowerManager pm, AdapterService service,
+ AdapterProperties prop, RemoteDevices remoteDevices) {
Log.d(TAG, "make");
- BondStateMachine bsm = new BondStateMachine(service, prop, remoteDevices);
+ BondStateMachine bsm = new BondStateMachine(pm, service, prop, remoteDevices);
bsm.start();
return bsm;
}
- public void doQuit() {
+ public synchronized void doQuit() {
quitNow();
}
@@ -122,7 +137,7 @@
}
@Override
- public boolean processMessage(Message msg) {
+ public synchronized boolean processMessage(Message msg) {
BluetoothDevice dev = (BluetoothDevice) msg.obj;
@@ -141,12 +156,15 @@
break;
case BONDING_STATE_CHANGE:
int newState = msg.arg1;
- /* if incoming pairing, transition to pending state */
+ /* if incoming pairing, transition to pending state */
if (newState == BluetoothDevice.BOND_BONDING) {
+ if (!mDevices.contains(dev)) {
+ mDevices.add(dev);
+ }
sendIntent(dev, newState, 0);
transitionTo(mPendingCommandState);
} else if (newState == BluetoothDevice.BOND_NONE) {
- /* if the link key was deleted by the stack */
+ /* if the link key was deleted by the stack */
sendIntent(dev, newState, 0);
} else {
Log.e(TAG, "In stable state, received invalid newState: "
@@ -169,7 +187,6 @@
private class PendingCommandState extends State {
- private final ArrayList<BluetoothDevice> mDevices = new ArrayList<BluetoothDevice>();
@Override
public void enter() {
@@ -178,7 +195,7 @@
}
@Override
- public boolean processMessage(Message msg) {
+ public synchronized boolean processMessage(Message msg) {
BluetoothDevice dev = (BluetoothDevice) msg.obj;
DeviceProperties devProp = mRemoteDevices.getDeviceProperties(dev);
boolean result = false;
@@ -214,6 +231,14 @@
}
sendIntent(dev, newState, reason);
if (newState != BluetoothDevice.BOND_BONDING) {
+ // check if bond none is received from device which
+ // was in pairing state otherwise don't transition to
+ // stable state.
+ if (newState == BluetoothDevice.BOND_NONE &&
+ !mDevices.contains(dev) && mDevices.size() != 0) {
+ infoLog("not transitioning to stable state");
+ break;
+ }
/* this is either none/bonded, remove and transition */
result = !mDevices.remove(dev);
if (mDevices.isEmpty()) {
@@ -241,11 +266,21 @@
case SSP_REQUEST:
int passkey = msg.arg1;
int variant = msg.arg2;
+ if (devProp == null)
+ {
+ Log.e(TAG,"Received msg from an unknown device");
+ return false;
+ }
sendDisplayPinIntent(devProp.getAddress(), passkey, variant);
break;
case PIN_REQUEST:
BluetoothClass btClass = dev.getBluetoothClass();
int btDeviceClass = btClass.getDeviceClass();
+ if (devProp == null)
+ {
+ Log.e(TAG,"Received msg from an unknown device");
+ return false;
+ }
if (btDeviceClass == BluetoothClass.Device.PERIPHERAL_KEYBOARD || btDeviceClass
== BluetoothClass.Device.PERIPHERAL_KEYBOARD_POINTING) {
// Its a keyboard. Follow the HID spec recommendation of creating the
@@ -285,6 +320,7 @@
}
private boolean cancelBond(BluetoothDevice dev) {
+ if (mAdapterService == null) return false;
if (dev.getBondState() == BluetoothDevice.BOND_BONDING) {
byte[] addr = Utils.getBytesFromAddress(dev.getAddress());
if (!mAdapterService.cancelBondNative(addr)) {
@@ -297,6 +333,7 @@
}
private boolean removeBond(BluetoothDevice dev, boolean transition) {
+ if (mAdapterService == null) return false;
if (dev.getBondState() == BluetoothDevice.BOND_BONDED) {
byte[] addr = Utils.getBytesFromAddress(dev.getAddress());
if (!mAdapterService.removeBondNative(addr)) {
@@ -304,6 +341,7 @@
} else {
if (transition) {
transitionTo(mPendingCommandState);
+ dev.setAlias(null);
}
return true;
}
@@ -314,6 +352,7 @@
private boolean createBond(BluetoothDevice dev, int transport, OobData oobData,
boolean transition) {
+ if (mAdapterService == null) return false;
if (dev.getBondState() == BluetoothDevice.BOND_NONE) {
infoLog("Bond address is:" + dev);
byte[] addr = Utils.getBytesFromAddress(dev.getAddress());
@@ -346,6 +385,9 @@
}
private void sendDisplayPinIntent(byte[] address, int pin, int variant) {
+
+ // Acquire wakelock during PIN code request to bring up LCD display
+ mWakeLock.acquire();
Intent intent = new Intent(BluetoothDevice.ACTION_PAIRING_REQUEST);
intent.putExtra(BluetoothDevice.EXTRA_DEVICE, mRemoteDevices.getDevice(address));
if (pin != 0) {
@@ -355,7 +397,9 @@
intent.setFlags(Intent.FLAG_RECEIVER_FOREGROUND);
// Workaround for Android Auto until pre-accepting pairing requests is added.
intent.addFlags(Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND);
- mAdapterService.sendOrderedBroadcast(intent, mAdapterService.BLUETOOTH_ADMIN_PERM);
+ mAdapterService.sendOrderedBroadcast(intent, AdapterService.BLUETOOTH_ADMIN_PERM);
+ // Release wakelock to allow the LCD to go off after the PIN popup notification.
+ mWakeLock.release();
}
@VisibleForTesting
@@ -386,6 +430,7 @@
if (oldState == newState) {
return;
}
+
StatsLog.write(StatsLog.BLUETOOTH_BOND_STATE_CHANGED,
mAdapterService.obfuscateAddress(device), 0, device.getType(),
newState, BluetoothProtoEnums.BOND_SUB_STATE_UNKNOWN, reason);
@@ -393,6 +438,7 @@
int classOfDevice = deviceClass == null ? 0 : deviceClass.getClassOfDevice();
StatsLog.write(StatsLog.BLUETOOTH_CLASS_OF_DEVICE_REPORTED,
mAdapterService.obfuscateAddress(device), classOfDevice);
+
mAdapterProperties.onBondStateChanged(device, newState);
if (devProp != null && ((devProp.getDeviceType() == BluetoothDevice.DEVICE_TYPE_CLASSIC
@@ -554,6 +600,11 @@
if (pbapClientService != null) {
pbapClientService.setPriority(device, BluetoothProfile.PRIORITY_UNDEFINED);
}
+
+ // Clear Absolute Volume black list
+ if (a2dpService != null) {
+ a2dpService.resetAvrcpBlacklist(device);
+ }
}
private String state2str(int state) {
diff --git a/src/com/android/bluetooth/btservice/Config.java b/src/com/android/bluetooth/btservice/Config.java
old mode 100644
new mode 100755
index 2b1f46c..c906317
--- a/src/com/android/bluetooth/btservice/Config.java
+++ b/src/com/android/bluetooth/btservice/Config.java
@@ -23,6 +23,7 @@
import android.provider.Settings;
import android.util.FeatureFlagUtils;
import android.util.Log;
+import android.os.SystemProperties;
import com.android.bluetooth.R;
import com.android.bluetooth.a2dp.A2dpService;
@@ -42,6 +43,7 @@
import com.android.bluetooth.pbap.BluetoothPbapService;
import com.android.bluetooth.pbapclient.PbapClientService;
import com.android.bluetooth.sap.SapService;
+import com.android.bluetooth.ba.BATService;
import java.util.ArrayList;
@@ -99,7 +101,9 @@
(1 << BluetoothProfile.PBAP)),
new ProfileConfig(HearingAidService.class,
com.android.internal.R.bool.config_hearing_aid_profile_supported,
- (1 << BluetoothProfile.HEARING_AID))
+ (1 << BluetoothProfile.HEARING_AID)),
+ new ProfileConfig(BATService.class, R.bool.profile_supported_ba,
+ (1 << BATService.BA_TRANSMITTER))
};
private static Class[] sSupportedProfiles = new Class[0];
@@ -124,6 +128,10 @@
}
if (supported && !isProfileDisabled(ctx, config.mMask)) {
+ if (!addAudioProfiles(config.mClass.getSimpleName())) {
+ Log.i(TAG, " Profile " + config.mClass.getSimpleName() + " Not added ");
+ continue;
+ }
Log.v(TAG, "Adding " + config.mClass.getSimpleName());
profiles.add(config.mClass);
}
@@ -160,4 +168,47 @@
return (disabledProfilesBitMask & profileMask) != 0;
}
+
+ private static synchronized boolean addAudioProfiles(String serviceName) {
+ Log.d(TAG," addAudioProfiles profile" + serviceName);
+ boolean isA2dpConcurrency= SystemProperties.getBoolean(
+ "persist.vendor.service.bt.a2dp_concurrency", false);
+ Log.i(TAG, "addAudioProfiles isA2dpConcurrency:" + isA2dpConcurrency);
+
+ if(isA2dpConcurrency) {
+ if ((serviceName.equals("A2dpSinkService")) || (serviceName.equals("A2dpService"))) {
+ return true;
+ }
+ } else {
+ boolean isA2dpSink = SystemProperties.getBoolean(
+ "persist.vendor.service.bt.a2dp.sink", false);
+ Log.i(TAG, "addAudioProfiles isA2dpSink :" + isA2dpSink);
+ /* If property not enabled and request is for A2DPSinkService, don't add */
+ if ((serviceName.equals("A2dpSinkService")) && (!isA2dpSink))
+ return false;
+ if ((serviceName.equals("A2dpService")) && (isA2dpSink))
+ return false;
+ }
+
+ boolean isBAEnabled = SystemProperties.getBoolean("persist.vendor.service.bt.bca", false);
+
+ // Split A2dp will be enabled by default
+ boolean isSplitA2dpEnabled = true;
+ AdapterService adapterService = AdapterService.getAdapterService();
+
+ if (adapterService != null){
+ isSplitA2dpEnabled = adapterService.isSplitA2dpEnabled();
+ Log.v(TAG,"isSplitA2dpEnabled: " + isSplitA2dpEnabled);
+ } else {
+ Log.e(TAG,"adapterService is null");
+ }
+
+ if(serviceName.equals("BATService")) {
+ Log.d(TAG," isBAEnabled = " + isBAEnabled
+ + " isSplitEnabled " + isSplitA2dpEnabled);
+ return isBAEnabled && isSplitA2dpEnabled;
+ }
+ // always return true for other profiles
+ return true;
+ }
}
diff --git a/src/com/android/bluetooth/btservice/PhonePolicy.java b/src/com/android/bluetooth/btservice/PhonePolicy.java
index 39b1252..529decf 100644
--- a/src/com/android/bluetooth/btservice/PhonePolicy.java
+++ b/src/com/android/bluetooth/btservice/PhonePolicy.java
@@ -1,3 +1,4 @@
+
/*
* Copyright (C) 2017 The Android Open Source Project
*
@@ -17,6 +18,7 @@
package com.android.bluetooth.btservice;
import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothA2dpSink;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothHeadset;
@@ -34,10 +36,12 @@
import android.util.Log;
import com.android.bluetooth.a2dp.A2dpService;
+import com.android.bluetooth.a2dpsink.A2dpSinkService;
import com.android.bluetooth.hearingaid.HearingAidService;
import com.android.bluetooth.hfp.HeadsetService;
import com.android.bluetooth.hid.HidHostService;
import com.android.bluetooth.pan.PanService;
+import com.android.bluetooth.ba.BATService;
import com.android.internal.R;
import com.android.internal.annotations.VisibleForTesting;
@@ -78,10 +82,17 @@
private static final int MESSAGE_PROFILE_INIT_PRIORITIES = 2;
private static final int MESSAGE_CONNECT_OTHER_PROFILES = 3;
private static final int MESSAGE_ADAPTER_STATE_TURNED_ON = 4;
- private static final int MESSAGE_PROFILE_ACTIVE_DEVICE_CHANGED = 5;
+ private static final int MESSAGE_AUTO_CONNECT_PROFILES = 50;
// Timeouts
+ private static final int AUTO_CONNECT_PROFILES_TIMEOUT= 500;
@VisibleForTesting static int sConnectOtherProfilesTimeoutMillis = 6000; // 6s
+ private static final int CONNECT_OTHER_PROFILES_TIMEOUT_DELAYED = 10000; //10s
+ private static final int CONNECT_OTHER_PROFILES_REDUCED_TIMEOUT_DELAYED = 2000; //2s
+
+ private static final int MESSAGE_PROFILE_ACTIVE_DEVICE_CHANGED = 5;
+ private static final String delayConnectTimeoutDevice[] = {"00:23:3D"}; // volkswagen carkit
+ private static final String delayReducedConnectTimeoutDevice[] = {"10:4F:A8"}; //h.ear (MDR-EX750BT)
private final AdapterService mAdapterService;
private final ServiceFactory mFactory;
@@ -110,11 +121,21 @@
BluetoothProfile.A2DP, -1, // No-op argument
intent).sendToTarget();
break;
+ case BluetoothA2dpSink.ACTION_CONNECTION_STATE_CHANGED:
+ mHandler.obtainMessage(MESSAGE_PROFILE_CONNECTION_STATE_CHANGED,
+ BluetoothProfile.A2DP_SINK,-1, // No-op argument
+ intent).sendToTarget();
+ break;
case BluetoothA2dp.ACTION_ACTIVE_DEVICE_CHANGED:
mHandler.obtainMessage(MESSAGE_PROFILE_ACTIVE_DEVICE_CHANGED,
BluetoothProfile.A2DP, -1, // No-op argument
intent).sendToTarget();
break;
+ case BluetoothHeadset.ACTION_ACTIVE_DEVICE_CHANGED:
+ mHandler.obtainMessage(MESSAGE_PROFILE_ACTIVE_DEVICE_CHANGED,
+ BluetoothProfile.HEADSET, -1, // No-op argument
+ intent).sendToTarget();
+ break;
case BluetoothAdapter.ACTION_STATE_CHANGED:
// Only pass the message on if the adapter has actually changed state from
// non-ON to ON. NOTE: ON is the state depicting BREDR ON and not just BLE ON.
@@ -168,6 +189,10 @@
Intent intent = (Intent) msg.obj;
BluetoothDevice device =
intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+ if (device.getAddress().equals(BATService.mBAAddress)) {
+ Log.d(TAG," Update from BA, bail out");
+ break;
+ }
int prevState = intent.getIntExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, -1);
int nextState = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, -1);
processProfileStateChanged(device, msg.arg1, nextState, prevState);
@@ -195,6 +220,11 @@
resetStates();
autoConnect();
break;
+ case MESSAGE_AUTO_CONNECT_PROFILES: {
+ if (DBG) debugLog( "MESSAGE_AUTO_CONNECT_PROFILES");
+ autoConnectProfilesDelayed();
+ break;
+ }
}
}
}
@@ -206,9 +236,11 @@
IntentFilter filter = new IntentFilter();
filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
+ filter.addAction(BluetoothA2dpSink.ACTION_CONNECTION_STATE_CHANGED);
filter.addAction(BluetoothDevice.ACTION_UUID);
filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
filter.addAction(BluetoothA2dp.ACTION_ACTIVE_DEVICE_CHANGED);
+ filter.addAction(BluetoothHeadset.ACTION_ACTIVE_DEVICE_CHANGED);
mAdapterService.registerReceiver(mReceiver, filter);
}
@@ -228,9 +260,14 @@
debugLog("processInitProfilePriorities() - device " + device);
HidHostService hidService = mFactory.getHidHostService();
A2dpService a2dpService = mFactory.getA2dpService();
+ A2dpSinkService a2dpSinkService = mFactory.getA2dpSinkService();
HeadsetService headsetService = mFactory.getHeadsetService();
PanService panService = mFactory.getPanService();
HearingAidService hearingAidService = mFactory.getHearingAidService();
+ BluetoothDevice peerTwsDevice = null;
+ if (mAdapterService.isTwsPlusDevice(device)) {
+ peerTwsDevice = mAdapterService.getTwsPlusPeerDevice(device);
+ }
// Set profile priorities only for the profiles discovered on the remote device.
// This avoids needless auto-connect attempts to profiles non-existent on the remote device
@@ -245,12 +282,27 @@
|| BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.Handsfree)) && (
headsetService.getPriority(device) == BluetoothProfile.PRIORITY_UNDEFINED))) {
headsetService.setPriority(device, BluetoothProfile.PRIORITY_ON);
+ if (peerTwsDevice != null) {
+ debugLog("setting peer earbud to priority on for hfp" + peerTwsDevice);
+ headsetService.setPriority(peerTwsDevice, BluetoothProfile.PRIORITY_ON);
+ }
}
if ((a2dpService != null) && (BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.AudioSink)
|| BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.AdvAudioDist)) && (
a2dpService.getPriority(device) == BluetoothProfile.PRIORITY_UNDEFINED)) {
a2dpService.setPriority(device, BluetoothProfile.PRIORITY_ON);
+ if (peerTwsDevice != null) {
+ debugLog("setting peer earbud to priority on for a2dp" + peerTwsDevice);
+ a2dpService.setPriority(peerTwsDevice, BluetoothProfile.PRIORITY_ON);
+ }
+ }
+
+ if ((a2dpSinkService != null)
+ && (BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.AudioSource)
+ || BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.AdvAudioDist)) && (
+ a2dpSinkService.getPriority(device) == BluetoothProfile.PRIORITY_UNDEFINED)) {
+ a2dpSinkService.setPriority(device, BluetoothProfile.PRIORITY_ON);
}
if ((panService != null) && (BluetoothUuid.isUuidPresent(uuids, BluetoothUuid.PANU) && (
@@ -272,34 +324,76 @@
int prevState) {
debugLog("processProfileStateChanged, device=" + device + ", profile=" + profileId + ", "
+ prevState + " -> " + nextState);
- if (((profileId == BluetoothProfile.A2DP) || (profileId == BluetoothProfile.HEADSET))) {
+ if ((profileId == BluetoothProfile.A2DP) || (profileId == BluetoothProfile.HEADSET)
+ || profileId == BluetoothProfile.A2DP_SINK) {
+ BluetoothDevice peerTwsDevice =
+ (mAdapterService != null && mAdapterService.isTwsPlusDevice(device)) ?
+ mAdapterService.getTwsPlusPeerDevice(device):null;
if (nextState == BluetoothProfile.STATE_CONNECTED) {
+ debugLog("processProfileStateChanged: isTwsDevice: " + mAdapterService.isTwsPlusDevice(device));
switch (profileId) {
case BluetoothProfile.A2DP:
mA2dpRetrySet.remove(device);
+ if (mAdapterService.isTwsPlusDevice(device)) {
+ setAutoConnectForA2dpSink(device);
+ if (peerTwsDevice != null)
+ setAutoConnectForA2dpSink(peerTwsDevice);
+ }
break;
case BluetoothProfile.HEADSET:
mHeadsetRetrySet.remove(device);
+ if (mAdapterService.isTwsPlusDevice(device)) {
+ setAutoConnectForHeadset(device);
+ if (peerTwsDevice != null)
+ setAutoConnectForHeadset(peerTwsDevice);
+ }
+ break;
+ case BluetoothProfile.A2DP_SINK:
+ setAutoConnectForA2dpSource(device);
break;
}
connectOtherProfile(device);
}
if (nextState == BluetoothProfile.STATE_DISCONNECTED) {
+ HeadsetService hsService = mFactory.getHeadsetService();
+ A2dpService a2dpService = mFactory.getA2dpService();
handleAllProfilesDisconnected(device);
if (prevState == BluetoothProfile.STATE_CONNECTING) {
- HeadsetService hsService = mFactory.getHeadsetService();
boolean hsDisconnected = hsService == null
|| hsService.getConnectionState(device)
== BluetoothProfile.STATE_DISCONNECTED;
- A2dpService a2dpService = mFactory.getA2dpService();
boolean a2dpDisconnected = a2dpService == null
|| a2dpService.getConnectionState(device)
== BluetoothProfile.STATE_DISCONNECTED;
+ boolean isAnyTwsPairConnected = (peerTwsDevice != null) && ((a2dpService != null) &&
+ (a2dpService.getConnectionState(peerTwsDevice) == BluetoothProfile.STATE_CONNECTED))
+ || ((hsService != null) &&
+ (hsService.getConnectionState(peerTwsDevice) == BluetoothProfile.STATE_CONNECTED));
debugLog("processProfileStateChanged, device=" + device + ", a2dpDisconnected="
- + a2dpDisconnected + ", hsDisconnected=" + hsDisconnected);
+ + a2dpDisconnected + ", hsDisconnected=" + hsDisconnected
+ + ", TwsPairConnected=" + isAnyTwsPairConnected);
if (hsDisconnected && a2dpDisconnected) {
- removeAutoConnectFromA2dpSink(device);
- removeAutoConnectFromHeadset(device);
+ //remove a2dp and headset retry set.
+ mA2dpRetrySet.remove(device);
+ mHeadsetRetrySet.remove(device);
+ if (!isAnyTwsPairConnected) {
+ removeAutoConnectFromA2dpSink(device);
+ removeAutoConnectFromHeadset(device);
+ }
+ }
+ } else if (prevState == BluetoothProfile.STATE_DISCONNECTING) {
+ if (peerTwsDevice != null) {
+ int autoConnect = BluetoothProfile.PRIORITY_AUTO_CONNECT;
+ if (((a2dpService.getPriority(peerTwsDevice) == autoConnect) &&
+ (hsService.getPriority(peerTwsDevice) == autoConnect)) ||
+ ((a2dpService.getPriority(device) == autoConnect) &&
+ (hsService.getPriority(device) == autoConnect))) {
+ debugLog("User triggered disconnect reset priority ON to both EBs");
+ removeAutoConnectFromA2dpSink(device);
+ removeAutoConnectFromHeadset(device);
+ removeAutoConnectFromA2dpSink(peerTwsDevice);
+ removeAutoConnectFromHeadset(peerTwsDevice);
+ }
}
}
}
@@ -307,6 +401,8 @@
}
private void processProfileActiveDeviceChanged(BluetoothDevice activeDevice, int profileId) {
+ HeadsetService hsService = mFactory.getHeadsetService();
+ A2dpService a2dpService = mFactory.getA2dpService();
debugLog("processProfileActiveDeviceChanged, activeDevice=" + activeDevice + ", profile="
+ profileId);
switch (profileId) {
@@ -320,11 +416,39 @@
return;
}
for (BluetoothDevice device : mAdapterService.getBondedDevices()) {
- removeAutoConnectFromA2dpSink(device);
- removeAutoConnectFromHeadset(device);
+ removeAutoConnectFromA2dpSink(device);
+ removeAutoConnectFromHeadset(device);
}
+
setAutoConnectForA2dpSink(activeDevice);
setAutoConnectForHeadset(activeDevice);
+ if (mAdapterService != null && mAdapterService.isTwsPlusDevice(activeDevice)) {
+ BluetoothDevice peerTwsDevice = mAdapterService.getTwsPlusPeerDevice(activeDevice);
+ if (peerTwsDevice != null) {
+ debugLog("A2DP: Set Autoconnect for Peer TWS+ as well");
+ setAutoConnectForA2dpSink(peerTwsDevice);
+ debugLog("HFP: Set Autoconnect for Peer TWS+ as well");
+ setAutoConnectForHeadset(peerTwsDevice);
+ }
+ }
+ break;
+ case BluetoothProfile.HEADSET:
+ // Ignore null active device since we don't know if the change is triggered by
+ // normal device disconnection during Bluetooth shutdown or user action
+ if (activeDevice == null) {
+ warnLog("processProfileActiveDeviceChanged: ignore null HFP active device");
+ return;
+ }
+ // If a device with only HFP profile is connected then set autoconnection for
+ // that device.
+ if (a2dpService != null) {
+ if (a2dpService.getConnectedDevices().size() == 0) {
+ warnLog("processProfileActiveDeviceChanged: HFP active device changed and"+
+ " no A2DP device connected, so setting priority to auto connect for HFP"+
+ " device: " + activeDevice);
+ setAutoConnectForHeadset(activeDevice);
+ }
+ }
break;
}
}
@@ -335,6 +459,7 @@
HeadsetService hsService = mFactory.getHeadsetService();
A2dpService a2dpService = mFactory.getA2dpService();
PanService panService = mFactory.getPanService();
+ A2dpSinkService a2dpSinkService = mFactory.getA2dpSinkService();
if (hsService != null) {
List<BluetoothDevice> hsConnDevList = hsService.getConnectedDevices();
@@ -346,6 +471,11 @@
allProfilesEmpty &= a2dpConnDevList.isEmpty();
atLeastOneProfileConnectedForDevice |= a2dpConnDevList.contains(device);
}
+ if (a2dpSinkService != null) {
+ List<BluetoothDevice> a2dpSinkConnDevList = a2dpSinkService.getConnectedDevices();
+ allProfilesEmpty &= a2dpSinkConnDevList.isEmpty();
+ atLeastOneProfileConnectedForDevice |= a2dpSinkConnDevList.contains(device);
+ }
if (panService != null) {
List<BluetoothDevice> panConnDevList = panService.getConnectedDevices();
allProfilesEmpty &= panConnDevList.isEmpty();
@@ -373,7 +503,18 @@
mA2dpRetrySet.clear();
}
- private void autoConnect() {
+ // Delaying Auto Connect to make sure that all clients
+ // are up and running, specially BluetoothHeadset.
+ public void autoConnect() {
+ debugLog( "delay auto connect by 500 ms");
+ if ((mHandler.hasMessages(MESSAGE_AUTO_CONNECT_PROFILES) == false) &&
+ (mAdapterService.isQuietModeEnabled()== false)) {
+ Message m = mHandler.obtainMessage(MESSAGE_AUTO_CONNECT_PROFILES);
+ mHandler.sendMessageDelayed(m,AUTO_CONNECT_PROFILES_TIMEOUT);
+ }
+ }
+
+ private void autoConnectProfilesDelayed() {
if (mAdapterService.getState() != BluetoothAdapter.STATE_ON) {
errorLog("autoConnect: BT is not ON. Exiting autoConnect");
return;
@@ -381,6 +522,8 @@
if (!mAdapterService.isQuietModeEnabled()) {
debugLog("autoConnect: Initiate auto connection on BT on...");
+ //Remote Device Profiles
+ autoConnectA2dpSink();
final BluetoothDevice[] bondedDevices = mAdapterService.getBondedDevices();
if (bondedDevices == null) {
errorLog("autoConnect: bondedDevices are null");
@@ -427,6 +570,51 @@
}
}
+ private void autoConnectA2dpSink() {
+ A2dpSinkService a2dpSinkService = A2dpSinkService.getA2dpSinkService();
+ if (a2dpSinkService == null) {
+ errorLog("autoConnectA2dpSink, service is null");
+ return;
+ }
+ BluetoothDevice bondedDevices[] = mAdapterService.getBondedDevices();
+ if (bondedDevices == null) {
+ errorLog("autoConnectA2dpSink, bondedDevices are null");
+ return;
+ }
+
+ for (BluetoothDevice device : bondedDevices) {
+ int priority = a2dpSinkService.getPriority(device);
+ debugLog("autoConnectA2dpSink, attempt auto-connect with device " + device
+ + " priority " + priority);
+ if (priority == BluetoothProfile.PRIORITY_AUTO_CONNECT) {
+ debugLog("autoConnectA2dpSink() - Connecting A2DP Sink with " + device.toString());
+ a2dpSinkService.connect(device);
+ }
+ }
+ }
+
+ private boolean isConnectTimeoutDelayApplicable(BluetoothDevice device){
+ boolean isConnectionTimeoutDelayed = false;
+ String deviceAddress = device.getAddress();
+ for (int i = 0; i < delayConnectTimeoutDevice.length;i++) {
+ if (deviceAddress.indexOf(delayConnectTimeoutDevice[i]) == 0) {
+ isConnectionTimeoutDelayed = true;
+ }
+ }
+ return isConnectionTimeoutDelayed;
+ }
+
+ private boolean isConnectReducedTimeoutDelayApplicable(BluetoothDevice device){
+ boolean isConnectionReducedTimeoutDelayed = false;
+ String deviceAddress = device.getAddress();
+ for (int i = 0; i < delayReducedConnectTimeoutDevice.length;i++) {
+ if (deviceAddress.indexOf(delayReducedConnectTimeoutDevice[i]) == 0) {
+ isConnectionReducedTimeoutDelayed = true;
+ }
+ }
+ return isConnectionReducedTimeoutDelayed;
+ }
+
private void connectOtherProfile(BluetoothDevice device) {
if (mAdapterService.isQuietModeEnabled()) {
debugLog("connectOtherProfile: in quiet mode, skip connect other profile " + device);
@@ -439,7 +627,12 @@
mConnectOtherProfilesDeviceSet.add(device);
Message m = mHandler.obtainMessage(MESSAGE_CONNECT_OTHER_PROFILES);
m.obj = device;
- mHandler.sendMessageDelayed(m, sConnectOtherProfilesTimeoutMillis);
+ if (isConnectTimeoutDelayApplicable(device))
+ mHandler.sendMessageDelayed(m,CONNECT_OTHER_PROFILES_TIMEOUT_DELAYED);
+ else if (isConnectReducedTimeoutDelayApplicable(device))
+ mHandler.sendMessageDelayed(m,CONNECT_OTHER_PROFILES_REDUCED_TIMEOUT_DELAYED);
+ else
+ mHandler.sendMessageDelayed(m, sConnectOtherProfilesTimeoutMillis);
}
// This function is called whenever a profile is connected. This allows any other bluetooth
@@ -460,23 +653,109 @@
HeadsetService hsService = mFactory.getHeadsetService();
A2dpService a2dpService = mFactory.getA2dpService();
PanService panService = mFactory.getPanService();
+ A2dpSinkService a2dpSinkService = mFactory.getA2dpSinkService();
+ List<BluetoothDevice> hsConnDevList = null;
+ List<BluetoothDevice> a2dpConnDevList = null;
+ List<BluetoothDevice> a2dpSinkConnDevList = null;
if (hsService != null) {
- if (!mHeadsetRetrySet.contains(device) && (hsService.getPriority(device)
- >= BluetoothProfile.PRIORITY_ON) && (hsService.getConnectionState(device)
- == BluetoothProfile.STATE_DISCONNECTED)) {
- debugLog("Retrying connection to Headset with device " + device);
- mHeadsetRetrySet.add(device);
- hsService.connect(device);
- }
+ hsConnDevList = hsService.getConnectedDevices();
}
if (a2dpService != null) {
- if (!mA2dpRetrySet.contains(device) && (a2dpService.getPriority(device)
- >= BluetoothProfile.PRIORITY_ON) && (a2dpService.getConnectionState(device)
- == BluetoothProfile.STATE_DISCONNECTED)) {
+ a2dpConnDevList = a2dpService.getConnectedDevices();
+ }
+ if (a2dpSinkService != null) {
+ a2dpSinkConnDevList = a2dpSinkService.getConnectedDevices();
+ }
+
+ boolean a2dpConnected = false;
+ boolean hsConnected = false;
+ if(a2dpConnDevList != null && !a2dpConnDevList.isEmpty()) {
+ for (BluetoothDevice a2dpDevice : a2dpConnDevList)
+ {
+ if(a2dpDevice.equals(device))
+ {
+ a2dpConnected = true;
+ }
+ }
+ }
+ if(hsConnDevList != null && !hsConnDevList.isEmpty()) {
+ for (BluetoothDevice hsDevice : hsConnDevList)
+ {
+ if(hsDevice.equals(device))
+ {
+ hsConnected = true;
+ }
+ }
+ }
+
+ // This change makes sure that we try to re-connect
+ // the profile if its connection failed and priority
+ // for desired profile is ON.
+ debugLog("HF connected for device : " + device + " " +
+ (hsConnDevList == null ? false :hsConnDevList.contains(device)));
+ debugLog("A2DP connected for device : " + device + " " +
+ (a2dpConnDevList == null ? false :a2dpConnDevList.contains(device)));
+ debugLog("A2DPSink connected for device : " + device + " " +
+ (a2dpSinkConnDevList == null ? false :a2dpSinkConnDevList.contains(device)));
+
+ if (hsService != null) {
+ if ((hsConnDevList.isEmpty() || !(hsConnDevList.contains(device)))
+ && (!mHeadsetRetrySet.contains(device))
+ && (hsService.getPriority(device) >= BluetoothProfile.PRIORITY_ON)
+ && (hsService.getConnectionState(device)
+ == BluetoothProfile.STATE_DISCONNECTED)
+ && (a2dpConnected || (a2dpService != null &&
+ a2dpService.getPriority(device) == BluetoothProfile.PRIORITY_OFF))) {
+
+ debugLog("Retrying connection to HS with device " + device);
+ int maxConnections = mAdapterService.getMaxConnectedAudioDevices();
+
+ if (!hsConnDevList.isEmpty() && maxConnections == 1) {
+ Log.v(TAG,"HFP is already connected, ignore");
+ return;
+ }
+
+ // proceed connection only if a2dp is connected to this device
+ // add here as if is already overloaded
+ if (a2dpConnDevList.contains(device) ||
+ (hsService.getPriority(device) >= BluetoothProfile.PRIORITY_ON)) {
+ debugLog("Retrying connection to HS with device " + device);
+ mHeadsetRetrySet.add(device);
+ hsService.connect(device);
+ } else {
+ debugLog("do not initiate connect as A2dp is not connected");
+ }
+ }
+ }
+
+ if (a2dpService != null) {
+ if ((a2dpConnDevList.isEmpty() || !(a2dpConnDevList.contains(device)))
+ && (!mA2dpRetrySet.contains(device))
+ && (a2dpService.getPriority(device) >= BluetoothProfile.PRIORITY_ON ||
+ mAdapterService.isTwsPlusDevice(device))
+ && (a2dpService.getConnectionState(device)
+ == BluetoothProfile.STATE_DISCONNECTED)
+ && (hsConnected || (hsService != null &&
+ hsService.getPriority(device) == BluetoothProfile.PRIORITY_OFF))) {
debugLog("Retrying connection to A2DP with device " + device);
- mA2dpRetrySet.add(device);
- a2dpService.connect(device);
+ int maxConnections = mAdapterService.getMaxConnectedAudioDevices();
+
+ if (!a2dpConnDevList.isEmpty() && maxConnections == 1) {
+ Log.v(TAG,"a2dp is already connected, ignore");
+ return;
+ }
+
+ // proceed connection only if HFP is connected to this device
+ // add here as if is already overloaded
+ if (hsConnDevList.contains(device) ||
+ (a2dpService.getPriority(device) >= BluetoothProfile.PRIORITY_ON)) {
+ debugLog("Retrying connection to A2DP with device " + device);
+ mA2dpRetrySet.add(device);
+ a2dpService.connect(device);
+ } else {
+ debugLog("do not initiate connect as HFP is not connected");
+ }
}
}
if (panService != null) {
@@ -490,8 +769,67 @@
panService.connect(device);
}
}
+ // Connect A2DP Sink Service if HS is connected
+ if (a2dpSinkService != null) {
+ List<BluetoothDevice> sinkConnDevList = a2dpSinkService.getConnectedDevices();
+ if (sinkConnDevList.isEmpty() &&
+ (a2dpSinkService.getPriority(device) >= BluetoothProfile.PRIORITY_ON) &&
+ (a2dpSinkService.getConnectionState(device) ==
+ BluetoothProfile.STATE_DISCONNECTED) &&
+ (hsConnected || (hsService != null &&
+ hsService.getPriority(device) == BluetoothProfile.PRIORITY_OFF))) {
+ debugLog("Retrying connection for A2dpSink with device " + device);
+ a2dpSinkService.connect(device);
+ }
+ }
+
}
+ private void setProfileAutoConnectionPriority(BluetoothDevice device, int profileId,
+ boolean autoConnect) {
+ debugLog("setProfileAutoConnectionPriority: device=" + device + ", profile=" + profileId
+ + ", autoConnect=" + autoConnect);
+ switch (profileId) {
+ case BluetoothProfile.HEADSET: {
+ HeadsetService hsService = mFactory.getHeadsetService();
+ if (hsService == null) {
+ warnLog("setProfileAutoConnectionPriority: HEADSET service is null");
+ break;
+ }
+ removeAutoConnectFromDisconnectedHeadsets(hsService);
+ if (autoConnect) {
+ hsService.setPriority(device, BluetoothProfile.PRIORITY_AUTO_CONNECT);
+ }
+ break;
+ }
+ case BluetoothProfile.A2DP: {
+ A2dpService a2dpService = mFactory.getA2dpService();
+ if (a2dpService == null) {
+ warnLog("setProfileAutoConnectionPriority: A2DP service is null");
+ break;
+ }
+ removeAutoConnectFromDisconnectedA2dpSinks(a2dpService);
+ if (autoConnect) {
+ a2dpService.setPriority(device, BluetoothProfile.PRIORITY_AUTO_CONNECT);
+ }
+ break;
+ }
+ case BluetoothProfile.A2DP_SINK: {
+ A2dpSinkService a2dpSinkService = mFactory.getA2dpSinkService();
+ if (a2dpSinkService != null) {
+ if (BluetoothProfile.PRIORITY_AUTO_CONNECT != a2dpSinkService.getPriority(
+ device)) {
+ adjustOtherSourcePriorities(a2dpSinkService, a2dpSinkService.getConnectedDevices());
+ a2dpSinkService.setPriority(device, BluetoothProfile.PRIORITY_AUTO_CONNECT);
+ }
+ }
+ break;
+ }
+ default:
+ Log.w(TAG, "Tried to set AutoConnect priority on invalid profile " + profileId);
+ break;
+ }
+ }
/**
* Set a device's headset profile priority to PRIORITY_AUTO_CONNECT if device support that
* profile
@@ -528,6 +866,21 @@
}
/**
+ * Set device A2DP SINK priority to PRIORITY_AUTO_CONNECT if role is A2DP Sink
+ */
+ private void setAutoConnectForA2dpSource(BluetoothDevice device) {
+ A2dpSinkService a2dpSinkService = mFactory.getA2dpSinkService();
+ if (a2dpSinkService == null) {
+ warnLog("setAutoConnectForA2dpSink: A2DP service is null");
+ return;
+ }
+ if (a2dpSinkService.getPriority(device) >= BluetoothProfile.PRIORITY_ON) {
+ debugLog("setAutoConnectForA2dpSink: device " + device + " PRIORITY_AUTO_CONNECT");
+ a2dpSinkService.setPriority(device, BluetoothProfile.PRIORITY_AUTO_CONNECT);
+ }
+ }
+
+ /**
* Remove PRIORITY_AUTO_CONNECT from all headsets and set headset that used to have
* PRIORITY_AUTO_CONNECT to PRIORITY_ON
*
@@ -563,6 +916,40 @@
}
}
+ private void adjustOtherSourcePriorities(
+ A2dpSinkService a2dpSinkService, List<BluetoothDevice> connectedDeviceList) {
+ for (BluetoothDevice device : mAdapterService.getBondedDevices()) {
+ if (a2dpSinkService.getPriority(device) >= BluetoothProfile.PRIORITY_AUTO_CONNECT
+ && !connectedDeviceList.contains(device)) {
+ a2dpSinkService.setPriority(device, BluetoothProfile.PRIORITY_ON);
+ }
+ }
+ }
+
+ private void removeAutoConnectFromDisconnectedHeadsets(HeadsetService hsService) {
+ List<BluetoothDevice> connectedDeviceList = hsService.getConnectedDevices();
+ for (BluetoothDevice device : mAdapterService.getBondedDevices()) {
+ if (hsService.getPriority(device) >= BluetoothProfile.PRIORITY_AUTO_CONNECT
+ && !connectedDeviceList.contains(device)) {
+ debugLog("removeAutoConnectFromDisconnectedHeadsets, device " + device
+ + " PRIORITY_ON");
+ hsService.setPriority(device, BluetoothProfile.PRIORITY_ON);
+ }
+ }
+ }
+
+ private void removeAutoConnectFromDisconnectedA2dpSinks(A2dpService a2dpService) {
+ List<BluetoothDevice> connectedDeviceList = a2dpService.getConnectedDevices();
+ for (BluetoothDevice device : mAdapterService.getBondedDevices()) {
+ if (a2dpService.getPriority(device) >= BluetoothProfile.PRIORITY_AUTO_CONNECT
+ && !connectedDeviceList.contains(device)) {
+ debugLog("removeAutoConnectFromDisconnectedA2dpSinks, device " + device
+ + " PRIORITY_ON");
+ a2dpService.setPriority(device, BluetoothProfile.PRIORITY_ON);
+ }
+ }
+ }
+
private static void debugLog(String msg) {
if (DBG) {
Log.i(TAG, msg);
diff --git a/src/com/android/bluetooth/btservice/ProfileService.java b/src/com/android/bluetooth/btservice/ProfileService.java
index 9a7186c..92cc261 100644
--- a/src/com/android/bluetooth/btservice/ProfileService.java
+++ b/src/com/android/bluetooth/btservice/ProfileService.java
@@ -54,7 +54,7 @@
//Profile services will not be automatically restarted.
//They must be explicitly restarted by AdapterService
private static final int PROFILE_SERVICE_MODE = Service.START_NOT_STICKY;
- private BluetoothAdapter mAdapter;
+ protected BluetoothAdapter mAdapter;
private IProfileServiceBinder mBinder;
private final String mName;
private AdapterService mAdapterService;
@@ -130,7 +130,7 @@
if (DBG) {
Log.d(mName, "onStartCommand()");
}
-
+ AdapterService adapterService = AdapterService.getAdapterService();
if (checkCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM)
!= PackageManager.PERMISSION_GRANTED) {
Log.e(mName, "Permission denied!");
@@ -145,10 +145,31 @@
String action = intent.getStringExtra(AdapterService.EXTRA_ACTION);
if (AdapterService.ACTION_SERVICE_STATE_CHANGED.equals(action)) {
int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR);
+ int currentState = (adapterService != null) ? adapterService.getState() : -1;
if (state == BluetoothAdapter.STATE_OFF) {
- doStop();
+ if ((currentState == BluetoothAdapter.STATE_TURNING_OFF &&
+ !mName.equals("GattService")) ||
+ (currentState == BluetoothAdapter.STATE_BLE_TURNING_OFF &&
+ mName.equals("GattService")) ) {
+ Log.d(mName, ": Received stop request...Stopping profile...");
+ doStop();
+ } else {
+ Log.e(mName, ":intent received late, not Stopping profile");
+ }
} else if (state == BluetoothAdapter.STATE_ON) {
- doStart();
+ if ((currentState == BluetoothAdapter.STATE_TURNING_ON &&
+ !mName.equals("GattService")) ||
+ (currentState == BluetoothAdapter.STATE_BLE_TURNING_ON &&
+ mName.equals("GattService")) ) {
+
+ Log.d(mName, "Received start request. Starting profile...");
+ doStart();
+ } else {
+ Log.e(mName, ":intent received late, not starting profile");
+ if (adapterService != null) {
+ adapterService.removeProfile(this);
+ }
+ }
}
}
return PROFILE_SERVICE_MODE;
@@ -265,6 +286,7 @@
Log.e(mName, "Error starting profile. start() returned false.");
return;
}
+ Log.d(mName, " profile started successfully");
mAdapterService.onProfileServiceStateChanged(this, BluetoothAdapter.STATE_ON);
}
@@ -273,11 +295,13 @@
Log.w(mName, "doStop() called, but the profile is not running.");
}
mProfileStarted = false;
- if (mAdapterService != null) {
- mAdapterService.onProfileServiceStateChanged(this, BluetoothAdapter.STATE_OFF);
- }
if (!stop()) {
Log.e(mName, "Unable to stop profile");
+ } else {
+ Log.d(mName, " profile stopped successfully");
+ }
+ if (mAdapterService != null) {
+ mAdapterService.onProfileServiceStateChanged(this, BluetoothAdapter.STATE_OFF);
}
if (mAdapterService != null) {
mAdapterService.removeProfile(this);
diff --git a/src/com/android/bluetooth/btservice/RemoteDevices.java b/src/com/android/bluetooth/btservice/RemoteDevices.java
index 2965715..e2bfddf 100644
--- a/src/com/android/bluetooth/btservice/RemoteDevices.java
+++ b/src/com/android/bluetooth/btservice/RemoteDevices.java
@@ -1,4 +1,39 @@
/*
+ * Copyright (C) 2017, The Linux Foundation. All rights reserved.
+ * Not a Contribution.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted (subject to the limitations in the
+ * disclaimer below) provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
+ * GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
+ * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
* Copyright (C) 2012-2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
@@ -109,6 +144,12 @@
}
};
+ public static final String ACTION_TWS_PLUS_DEVICE_PAIR =
+ "android.bluetooth.device.action.TWS_PLUS_DEVICE_PAIR";
+ public static final String EXTRA_TWS_PLUS_DEVICE1 =
+ "android.bluetooth.device.extra.EXTRA_TWS_PLUS_DEVICE1";
+ public static final String EXTRA_TWS_PLUS_DEVICE2 =
+ "android.bluetooth.device.extra.EXTRA_TWS_PLUS_DEVICE2";
RemoteDevices(AdapterService service, Looper looper) {
sAdapter = BluetoothAdapter.getDefaultAdapter();
sAdapterService = service;
@@ -172,11 +213,14 @@
}
BluetoothDevice getDevice(byte[] address) {
- DeviceProperties prop = mDevices.get(Utils.getAddressStringFromByte(address));
- if (prop == null) {
- return null;
+ DeviceProperties prop;
+ synchronized (mDevices) {
+ prop = mDevices.get(Utils.getAddressStringFromByte(address));
}
- return prop.getDevice();
+ if (prop != null) {
+ return prop.getDevice();
+ }
+ return null;
}
@VisibleForTesting
@@ -214,12 +258,18 @@
private BluetoothDevice mDevice;
private boolean mIsBondingInitiatedLocally;
private int mBatteryLevel = BluetoothDevice.BATTERY_LEVEL_UNKNOWN;
+ private short mTwsPlusDevType;
+ private byte[] peerEbAddress;
+ private boolean autoConnect;
@VisibleForTesting int mBondState;
@VisibleForTesting int mDeviceType;
@VisibleForTesting ParcelUuid[] mUuids;
DeviceProperties() {
mBondState = BluetoothDevice.BOND_NONE;
+ mTwsPlusDevType = AbstractionLayer.TWS_PLUS_DEV_TYPE_NONE;
+ autoConnect = true;
+ peerEbAddress = null;
}
/**
@@ -275,6 +325,7 @@
return mRssi;
}
}
+
/**
* @return mDeviceType
*/
@@ -299,6 +350,8 @@
void setAlias(BluetoothDevice device, String mAlias) {
synchronized (mObject) {
this.mAlias = mAlias;
+ if (mAlias == null)
+ return;
sAdapterService.setDevicePropertyNative(mAddress,
AbstractionLayer.BT_PROPERTY_REMOTE_FRIENDLY_NAME, mAlias.getBytes());
Intent intent = new Intent(BluetoothDevice.ACTION_ALIAS_CHANGED);
@@ -309,6 +362,72 @@
}
/**
+ * @return mTwsPlusDevType
+ */
+ int getTwsPlusDevType() {
+ synchronized (mObject) {
+ return mTwsPlusDevType;
+ }
+ }
+
+ /**
+ * @return peerEbAddress
+ */
+ byte[] getTwsPlusPeerAddress() {
+ synchronized (mObject) {
+ return peerEbAddress;
+ }
+ }
+
+ /**
+ * @param mTwsPlusDevType the mTwsPlusDevType to set
+ */
+ void setTwsPlusDevType(short twsPlusDevType) {
+ synchronized (mObject) {
+ this.mTwsPlusDevType = twsPlusDevType;
+ if(twsPlusDevType == AbstractionLayer.TWS_PLUS_DEV_TYPE_NONE) {
+ this.peerEbAddress = null;
+ }
+ }
+ }
+
+ /**
+ * @param peerEbAddress the peerEbAddress to set
+ */
+ void setTwsPlusPeerEbAddress(BluetoothDevice device, byte[] peerEbAddress) {
+ synchronized (mObject) {
+ Intent intent;
+
+ /* in case of null null bd address reset the address */
+ if (peerEbAddress != null &&
+ Utils.getAddressStringFromByte(peerEbAddress).equals("00:00:00:00:00:00")) {
+ this.peerEbAddress = null;
+ errorLog(" resetting the peerEbAddress to null");
+ } else {
+ this.peerEbAddress = peerEbAddress;
+ if(device != null && peerEbAddress != null) {
+ errorLog(" Peer EB Address is:" +
+ Utils.getAddressStringFromByte(peerEbAddress));
+ intent = new Intent(ACTION_TWS_PLUS_DEVICE_PAIR);
+ intent.putExtra(EXTRA_TWS_PLUS_DEVICE1, mDevice);
+ intent.putExtra(EXTRA_TWS_PLUS_DEVICE2, device);
+ sAdapterService.sendBroadcast(intent,
+ AdapterService.BLUETOOTH_ADMIN_PERM);
+ }
+ }
+ }
+ }
+
+ /**
+ * @param peerEbAddress the peerEbAddress to set
+ */
+ void setTwsPlusAutoConnect(BluetoothDevice device, boolean autoConnect) {
+ synchronized (mObject) {
+ this.autoConnect = autoConnect;
+ debugLog("sendUuidIntent as Auto connect " + autoConnect );
+ }
+ }
+ /*
* @param mBondState the mBondState to set
*/
void setBondState(int mBondState) {
@@ -375,7 +494,9 @@
sAdapterService.sendBroadcast(intent, AdapterService.BLUETOOTH_ADMIN_PERM);
//Remove the outstanding UUID request
- sSdpTracker.remove(device);
+ if (sSdpTracker.contains(device)) {
+ sSdpTracker.remove(device);
+ }
}
/**
@@ -490,6 +611,11 @@
device = getDeviceProperties(bdDevice);
}
+ if (device == null) {
+ errorLog("device null ");
+ return;
+ }
+
if (types.length <= 0) {
errorLog("No properties to update");
return;
@@ -513,6 +639,7 @@
intent.putExtra(BluetoothDevice.EXTRA_DEVICE, bdDevice);
intent.putExtra(BluetoothDevice.EXTRA_NAME, device.mName);
intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
+ intent.setFlags(Intent.FLAG_RECEIVER_FOREGROUND);
sAdapterService.sendBroadcast(intent, sAdapterService.BLUETOOTH_PERM);
debugLog("Remote Device name is: " + device.mName);
break;
@@ -547,7 +674,9 @@
break;
}
device.mUuids = newUuids;
- if (sAdapterService.getState() == BluetoothAdapter.STATE_ON) {
+ if ((sAdapterService.getState() == BluetoothAdapter.STATE_ON) &&
+ device.autoConnect ) {
+ debugLog("sendUuidIntent as Auto connect is set ");
sAdapterService.deviceUuidUpdated(bdDevice);
sendUuidIntent(bdDevice, device);
}
@@ -618,13 +747,6 @@
"aclStateChangeCallback: Adapter State: " + BluetoothAdapter.nameForState(state)
+ " Connected: " + device);
} else {
- if (device.getBondState() == BluetoothDevice.BOND_BONDING) {
- // Send PAIRING_CANCEL intent to dismiss any dialog requesting bonding.
- intent = new Intent(BluetoothDevice.ACTION_PAIRING_CANCEL);
- intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
- intent.setPackage(sAdapterService.getString(R.string.pairing_ui_package));
- sAdapterService.sendBroadcast(intent, sAdapterService.BLUETOOTH_PERM);
- }
if (state == BluetoothAdapter.STATE_ON || state == BluetoothAdapter.STATE_TURNING_OFF) {
intent = new Intent(BluetoothDevice.ACTION_ACL_DISCONNECTED);
} else if (state == BluetoothAdapter.STATE_BLE_ON
diff --git a/src/com/android/bluetooth/btservice/ServiceFactory.java b/src/com/android/bluetooth/btservice/ServiceFactory.java
index fe79a5c..c520b9a 100644
--- a/src/com/android/bluetooth/btservice/ServiceFactory.java
+++ b/src/com/android/bluetooth/btservice/ServiceFactory.java
@@ -17,6 +17,7 @@
package com.android.bluetooth.btservice;
import com.android.bluetooth.a2dp.A2dpService;
+import com.android.bluetooth.a2dpsink.A2dpSinkService;
import com.android.bluetooth.avrcp.AvrcpTargetService;
import com.android.bluetooth.hearingaid.HearingAidService;
import com.android.bluetooth.hfp.HeadsetService;
@@ -50,6 +51,10 @@
return HearingAidService.getHearingAidService();
}
+ public A2dpSinkService getA2dpSinkService() {
+ return A2dpSinkService.getA2dpSinkService();
+ }
+
public AvrcpTargetService getAvrcpTargetService() {
return AvrcpTargetService.get();
}
diff --git a/src/com/android/bluetooth/gatt/AdvertiseHelper.java b/src/com/android/bluetooth/gatt/AdvertiseHelper.java
index 1c1b4dc..a71de5b 100644
--- a/src/com/android/bluetooth/gatt/AdvertiseHelper.java
+++ b/src/com/android/bluetooth/gatt/AdvertiseHelper.java
@@ -39,6 +39,7 @@
private static final int SERVICE_DATA_32_BIT_UUID = 0X20;
private static final int SERVICE_DATA_128_BIT_UUID = 0X21;
private static final int MANUFACTURER_SPECIFIC_DATA = 0XFF;
+ private static final int TRANSPORT_DISCOVERY_DATA = 0X26;
public static byte[] advertiseDataToBytes(AdvertiseData data, String name) {
@@ -166,6 +167,13 @@
}
}
+ byte[] transportDiscoveryData = data.getTransportDiscoveryData();
+ if (transportDiscoveryData != null && (transportDiscoveryData.length > 0)) {
+ ret.write(transportDiscoveryData.length + 1);
+ ret.write(TRANSPORT_DISCOVERY_DATA);
+ ret.write(transportDiscoveryData, 0, transportDiscoveryData.length);
+ }
+
return ret.toByteArray();
}
}
diff --git a/src/com/android/bluetooth/gatt/AdvertiseManager.java b/src/com/android/bluetooth/gatt/AdvertiseManager.java
index 85917a4..11a8ba1 100644
--- a/src/com/android/bluetooth/gatt/AdvertiseManager.java
+++ b/src/com/android/bluetooth/gatt/AdvertiseManager.java
@@ -394,6 +394,29 @@
callback.onPeriodicAdvertisingEnabled(advertiserId, enable, status);
}
+ void stopAdvertisingSets() {
+ Log.d(TAG, "stopAdvertisingSets()");
+ for (Map.Entry<IBinder, AdvertiserInfo> entry : mAdvertisers.entrySet()) {
+ Integer advertiser_id = entry.getValue().id;
+ IAdvertisingSetCallback callback = entry.getValue().callback;
+ IBinder binder = toBinder(callback);
+ binder.unlinkToDeath(entry.getValue().deathRecipient, 0);
+
+ if (advertiser_id < 0) {
+ Log.i(TAG, "stopAdvertisingSets() - advertiser not finished registration yet");
+ continue;
+ }
+
+ stopAdvertisingSetNative(advertiser_id);
+
+ try {
+ callback.onAdvertisingSetStopped(advertiser_id);
+ } catch (RemoteException e) {
+ Log.i(TAG, "error sending onAdvertisingSetStopped callback", e);
+ }
+ }
+ }
+
static {
classInitNative();
}
diff --git a/src/com/android/bluetooth/gatt/ContextMap.java b/src/com/android/bluetooth/gatt/ContextMap.java
index d54a25a..9267f78 100644
--- a/src/com/android/bluetooth/gatt/ContextMap.java
+++ b/src/com/android/bluetooth/gatt/ContextMap.java
@@ -27,6 +27,8 @@
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.Collections;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@@ -162,10 +164,10 @@
}
/** Our internal application list */
- private List<App> mApps = new ArrayList<App>();
+ private List<App> mApps = Collections.synchronizedList(new ArrayList<App>());
/** Internal map to keep track of logging information by app name */
- HashMap<Integer, AppScanStats> mAppScanStats = new HashMap<Integer, AppScanStats>();
+ Map<Integer, AppScanStats> mAppScanStats = new ConcurrentHashMap<Integer, AppScanStats>();
/** Internal list of connected devices **/
Set<Connection> mConnections = new HashSet<Connection>();
@@ -264,7 +266,6 @@
Connection connection = i.next();
if (connection.connId == connId) {
i.remove();
- break;
}
}
}
diff --git a/src/com/android/bluetooth/gatt/GattDebugUtils.java b/src/com/android/bluetooth/gatt/GattDebugUtils.java
index 232477b..cc6ab3b 100644
--- a/src/com/android/bluetooth/gatt/GattDebugUtils.java
+++ b/src/com/android/bluetooth/gatt/GattDebugUtils.java
@@ -73,6 +73,10 @@
return false;
}
+ if (intent == null) {
+ Log.d(TAG, "received NULL intent in GattService. Return.");
+ return true;
+ }
String action = intent.getAction();
Log.d(TAG, "handleDebugAction() action=" + action);
diff --git a/src/com/android/bluetooth/gatt/GattService.java b/src/com/android/bluetooth/gatt/GattService.java
index 5f2b42e..bddb0a5 100644
--- a/src/com/android/bluetooth/gatt/GattService.java
+++ b/src/com/android/bluetooth/gatt/GattService.java
@@ -98,7 +98,7 @@
private static final int ADVT_STATE_ONLOST = 1;
private static final int ET_LEGACY_MASK = 0x10;
-
+ private static final int ET_CONNECTABLE_MASK = 0x01;
private static final UUID HID_SERVICE_UUID =
UUID.fromString("00001812-0000-1000-8000-00805F9B34FB");
@@ -182,6 +182,7 @@
private AppOpsManager mAppOps;
private static GattService sGattService;
+ private boolean mNativeAvailable;
/**
* Reliable write queue
@@ -189,6 +190,8 @@
private Set<String> mReliableQueue = new HashSet<String>();
static {
+ if (DBG) Log.d(TAG, "classInitNative called");
+ System.loadLibrary("bluetooth_jni");
classInitNative();
}
@@ -203,6 +206,7 @@
Log.d(TAG, "start()");
}
initializeNative();
+ mNativeAvailable = true;
mAdapter = BluetoothAdapter.getDefaultAdapter();
mAppOps = getSystemService(AppOpsManager.class);
mAdvertiseManager = new AdvertiseManager(this, AdapterService.getAdapterService());
@@ -229,14 +233,18 @@
mServerMap.clear();
mHandleMap.clear();
mReliableQueue.clear();
- if (mAdvertiseManager != null) {
- mAdvertiseManager.cleanup();
- }
- if (mScanManager != null) {
- mScanManager.cleanup();
- }
- if (mPeriodicScanManager != null) {
- mPeriodicScanManager.cleanup();
+ if (mNativeAvailable) {
+ mNativeAvailable = false;
+ cleanupNative();
+ if (mAdvertiseManager != null) {
+ mAdvertiseManager.cleanup();
+ }
+ if (mScanManager != null) {
+ mScanManager.cleanup();
+ }
+ if (mPeriodicScanManager != null) {
+ mPeriodicScanManager.cleanup();
+ }
}
return true;
}
@@ -246,15 +254,19 @@
if (DBG) {
Log.d(TAG, "cleanup()");
}
- cleanupNative();
- if (mAdvertiseManager != null) {
- mAdvertiseManager.cleanup();
- }
- if (mScanManager != null) {
- mScanManager.cleanup();
- }
- if (mPeriodicScanManager != null) {
- mPeriodicScanManager.cleanup();
+
+ if (mNativeAvailable) {
+ mNativeAvailable = false;
+ cleanupNative();
+ if (mAdvertiseManager != null) {
+ mAdvertiseManager.cleanup();
+ }
+ if (mScanManager != null) {
+ mScanManager.cleanup();
+ }
+ if (mPeriodicScanManager != null) {
+ mPeriodicScanManager.cleanup();
+ }
}
}
@@ -1604,6 +1616,7 @@
throws RemoteException {
ScannerMap.App app = mScannerMap.getById(client.scannerId);
if (app == null) {
+ Log.e(TAG, "app not found from id(" + client.scannerId + ") for received callback");
return;
}
if (client.filters == null || client.filters.isEmpty()) {
@@ -1649,7 +1662,7 @@
BluetoothDevice device = mAdapter.getRemoteDevice(address);
int rssi = record[8];
long timestampNanos = now - parseTimestampNanos(extractBytes(record, 9, 2));
- results.add(new ScanResult(device, ScanRecord.parseFromBytes(new byte[0]), rssi,
+ results.add(getScanResultInstance(device, ScanRecord.parseFromBytes(new byte[0]), rssi,
timestampNanos));
}
return results;
@@ -1697,7 +1710,7 @@
if (DBG) {
Log.d(TAG, "ScanRecord : " + Arrays.toString(scanRecord));
}
- results.add(new ScanResult(device, ScanRecord.parseFromBytes(scanRecord), rssi,
+ results.add(getScanResultInstance(device, ScanRecord.parseFromBytes(scanRecord), rssi,
timestampNanos));
}
return results;
@@ -1754,7 +1767,7 @@
BluetoothAdapter.getDefaultAdapter().getRemoteDevice(trackingInfo.getAddress());
int advertiserState = trackingInfo.getAdvState();
ScanResult result =
- new ScanResult(device, ScanRecord.parseFromBytes(trackingInfo.getResult()),
+ getScanResultInstance(device, ScanRecord.parseFromBytes(trackingInfo.getResult()),
trackingInfo.getRSSIValue(), SystemClock.elapsedRealtimeNanos());
for (ScanClient client : mScanManager.getRegularScanQueue()) {
@@ -1894,7 +1907,8 @@
}
}
}
-
+ if (VDBG) Log.v(TAG, "getDevicesMatchingConnectionStates: State = "
+ + Arrays.toString(states) + ", deviceList = " + deviceList);
return deviceList;
}
@@ -1935,7 +1949,7 @@
void startScan(int scannerId, ScanSettings settings, List<ScanFilter> filters,
List<List<ResultStorageDescriptor>> storages, String callingPackage) {
if (DBG) {
- Log.d(TAG, "start scan with filters");
+ Log.d(TAG, "start scan with filters. callingPackage: " + callingPackage);
}
UserHandle callingUser = UserHandle.of(UserHandle.getCallingUserId());
enforceAdminPermission();
@@ -1978,7 +1992,8 @@
void registerPiAndStartScan(PendingIntent pendingIntent, ScanSettings settings,
List<ScanFilter> filters, String callingPackage) {
if (DBG) {
- Log.d(TAG, "start scan with filters, for PendingIntent");
+ Log.d(TAG, "start scan with filters, for PendingIntent. callingPackage: "
+ + callingPackage);
}
enforceAdminPermission();
if (needsPrivilegedPermissionForScan(settings)) {
@@ -2065,8 +2080,9 @@
if (app != null) {
app.recordScanStop(client.scannerId);
}
-
- mScanManager.stopScan(client);
+ if (mScanManager != null) {
+ mScanManager.stopScan(client);
+ }
}
void stopScan(PendingIntent intent, String callingPackage) {
@@ -2099,6 +2115,21 @@
}
}
+ boolean isScanClient(int clientIf) {
+ for (ScanClient client : mScanManager.getRegularScanQueue()) {
+ if (client.scannerId == clientIf) {
+ return true;
+ }
+ }
+ for (ScanClient client : mScanManager.getBatchScanQueue()) {
+ if (client.scannerId == clientIf) {
+ return true;
+ }
+ }
+ if (VDBG) Log.v(TAG, "clientIf: " + clientIf + " is not a ScanClient");
+ return false;
+ }
+
void unregAll() {
for (Integer appId : mClientMap.getAllAppsIds()) {
if (DBG) {
@@ -2106,6 +2137,25 @@
}
unregisterClient(appId);
}
+ for (Integer appId : mServerMap.getAllAppsIds()) {
+ if (DBG) Log.d(TAG, "unreg:" + appId);
+ unregisterServer(appId);
+ }
+ for (Integer appId : mScannerMap.getAllAppsIds()) {
+ if (DBG) Log.d(TAG, "unreg:" + appId);
+ if (isScanClient(appId)) {
+ ScanClient client = new ScanClient(appId);
+ stopScan(client);
+ unregisterScanner(appId);
+ }
+ }
+ if (mAdvertiseManager != null) {
+ mAdvertiseManager.stopAdvertisingSets();
+ }
+ }
+
+ public void setAptXLowLatencyMode(boolean enabled){
+ mScanManager.setAptXLowLatencyMode(enabled);
}
/**************************************************************************
@@ -2656,6 +2706,7 @@
ServerMap.App app = mServerMap.getById(serverIf);
if (app == null) {
+ Log.e(TAG, "app not found from id(" + serverIf + ") for received callback");
return;
}
@@ -2684,6 +2735,7 @@
ServerMap.App app = mServerMap.getById(entry.serverIf);
if (app == null) {
+ Log.e(TAG, "app not found from id(" + entry.serverIf + ") for received callback");
return;
}
@@ -2706,6 +2758,7 @@
ServerMap.App app = mServerMap.getById(entry.serverIf);
if (app == null) {
+ Log.e(TAG, "app not found from id(" + entry.serverIf + ") for received callback");
return;
}
@@ -2730,6 +2783,7 @@
ServerMap.App app = mServerMap.getById(entry.serverIf);
if (app == null) {
+ Log.e(TAG, "app not found from id(" + entry.serverIf + ") for received callback");
return;
}
@@ -2754,6 +2808,7 @@
ServerMap.App app = mServerMap.getById(entry.serverIf);
if (app == null) {
+ Log.e(TAG, "app not found from id(" + entry.serverIf + ") for received callback");
return;
}
@@ -2770,6 +2825,7 @@
ServerMap.App app = mServerMap.getByConnId(connId);
if (app == null) {
+ Log.e(TAG, "app not found from connId(" + connId + ") for received callback");
return;
}
@@ -2789,11 +2845,13 @@
String address = mServerMap.addressByConnId(connId);
if (address == null) {
+ Log.e(TAG, "address not found for given connId:" + connId);
return;
}
ServerMap.App app = mServerMap.getByConnId(connId);
if (app == null) {
+ Log.e(TAG, "app not found from connId(" + connId + ") for received callback");
return;
}
@@ -2814,6 +2872,7 @@
ServerMap.App app = mServerMap.getByConnId(connId);
if (app == null) {
+ Log.e(TAG, "app not found from connId(" + connId + ") for received callback");
return;
}
@@ -2834,11 +2893,13 @@
String address = mServerMap.addressByConnId(connId);
if (address == null) {
+ Log.e(TAG, "address not found for given connId: " + connId);
return;
}
ServerMap.App app = mServerMap.getByConnId(connId);
if (app == null) {
+ Log.e(TAG, "app not found from connId(" + connId + ") for received callback");
return;
}
@@ -2992,7 +3053,9 @@
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
if (VDBG) {
- Log.d(TAG, "sendResponse() - address=" + address);
+ Log.d(TAG, "sendResponse() - address=" + address + " serverIf: " + serverIf
+ + "requestId: " + requestId + " status: " + status + " value: "
+ + Arrays.toString(value));
}
int handle = 0;
@@ -3011,11 +3074,13 @@
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
if (VDBG) {
- Log.d(TAG, "sendNotification() - address=" + address + " handle=" + handle);
+ Log.d(TAG, "sendNotification() - address = " + address + " handle = " + handle
+ + " confirm = " + confirm + " value = " + Arrays.toString(value));
}
Integer connId = mServerMap.connIdByAddress(serverIf, address);
if (connId == null || connId == 0) {
+ Log.e(TAG, "couldn't find connId for given address. Return");
return;
}
@@ -3137,6 +3202,8 @@
handleList.add(entry.handle);
}
+ if (VDBG) Log.v(TAG, "delete Services handleList : " + handleList);
+
/* Now actually delete the services.... */
for (Integer handle : handleList) {
gattServerDeleteServiceNative(serverIf, handle);
@@ -3233,7 +3300,17 @@
}
}
- /**************************************************************************
+ private ScanResult getScanResultInstance(BluetoothDevice device, ScanRecord scanRecord,
+ int rssi, long timestampNanos) {
+ int eventType = (ScanResult.DATA_COMPLETE << 5) | ET_LEGACY_MASK | ET_CONNECTABLE_MASK;
+ int txPower = 127;
+ int periodicAdvertisingInterval = 0;
+ return new ScanResult(device, eventType, BluetoothDevice.PHY_LE_1M, ScanResult.PHY_UNUSED,
+ ScanResult.SID_NOT_PRESENT, txPower, rssi, periodicAdvertisingInterval,
+ scanRecord, timestampNanos);
+ }
+
+ /**************************************************************************
* GATT Test functions
*************************************************************************/
diff --git a/src/com/android/bluetooth/gatt/GattServiceConfig.java b/src/com/android/bluetooth/gatt/GattServiceConfig.java
index 290d15d..3ffce38 100644
--- a/src/com/android/bluetooth/gatt/GattServiceConfig.java
+++ b/src/com/android/bluetooth/gatt/GattServiceConfig.java
@@ -16,12 +16,15 @@
package com.android.bluetooth.gatt;
+import android.util.Log;
+
/**
* GattService configuration.
*/
/*package*/ class GattServiceConfig {
- public static final boolean DBG = false;
- public static final boolean VDBG = false;
+ public static final String LOG_TAG = "BluetoothGatt";
+ public static final boolean DBG = true;
+ public static final boolean VDBG = Log.isLoggable(LOG_TAG, Log.VERBOSE);;
public static final String TAG_PREFIX = "BtGatt.";
public static final boolean DEBUG_ADMIN = true;
}
diff --git a/src/com/android/bluetooth/gatt/ScanFilterQueue.java b/src/com/android/bluetooth/gatt/ScanFilterQueue.java
index 6c47711..61133e1 100644
--- a/src/com/android/bluetooth/gatt/ScanFilterQueue.java
+++ b/src/com/android/bluetooth/gatt/ScanFilterQueue.java
@@ -39,6 +39,7 @@
public static final int TYPE_LOCAL_NAME = 4;
public static final int TYPE_MANUFACTURER_DATA = 5;
public static final int TYPE_SERVICE_DATA = 6;
+ public static final int TYPE_TRANSPORT_DISCOVERY_DATA = 7;
// Max length is 31 - 3(flags) - 2 (one byte for length and one byte for type).
private static final int MAX_LEN_PER_FIELD = 26;
@@ -57,6 +58,9 @@
public int company_mask;
public byte[] data;
public byte[] data_mask;
+ public int org_id;
+ public int tds_flags;
+ public int tds_flags_mask;
}
private Set<Entry> mEntries = new HashSet<Entry>();
@@ -143,6 +147,16 @@
mEntries.add(entry);
}
+ void addTransportDiscoveryData(int orgId, int TDSFlags, int TDSFlagsMask, byte[] wifiNANHash) {
+ Entry entry = new Entry();
+ entry.type = TYPE_TRANSPORT_DISCOVERY_DATA;
+ entry.org_id = orgId;
+ entry.tds_flags = TDSFlags;
+ entry.tds_flags_mask = TDSFlagsMask;
+ entry.data = wifiNANHash;
+ mEntries.add(entry);
+ }
+
Entry pop() {
if (mEntries.isEmpty()) {
return null;
@@ -218,6 +232,10 @@
addServiceData(serviceData, serviceDataMask);
}
}
+ if (filter.getOrgId() >= 0) {
+ addTransportDiscoveryData(filter.getOrgId(), filter.getTDSFlags(),
+ filter.getTDSFlagsMask(), filter.getWifiNANHash());
+ }
}
private byte[] concate(ParcelUuid serviceDataUuid, byte[] serviceData) {
diff --git a/src/com/android/bluetooth/gatt/ScanManager.java b/src/com/android/bluetooth/gatt/ScanManager.java
index 0736978..79c8251 100644
--- a/src/com/android/bluetooth/gatt/ScanManager.java
+++ b/src/com/android/bluetooth/gatt/ScanManager.java
@@ -20,6 +20,7 @@
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
import android.bluetooth.le.ScanCallback;
import android.bluetooth.le.ScanFilter;
import android.bluetooth.le.ScanSettings;
@@ -49,6 +50,7 @@
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
+import java.util.NoSuchElementException;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
@@ -77,13 +79,19 @@
private static final int MSG_SUSPEND_SCANS = 4;
private static final int MSG_RESUME_SCANS = 5;
private static final int MSG_IMPORTANCE_CHANGE = 6;
+ /*For suspending both unfiltered & filtered scans*/
+ private static final int MSG_SUSPEND_SCAN_ALL = 7;
+ /* To handle display changed events in Handler thread context to avoid ANR */
+ private static final int MSG_HANDLE_DISPLAY_CHANGED = 8;
private static final String ACTION_REFRESH_BATCHED_SCAN =
"com.android.bluetooth.gatt.REFRESH_BATCHED_SCAN";
+
// Timeout for each controller operation.
private static final int OPERATION_TIME_OUT_MILLIS = 500;
- private int mLastConfiguredScanSetting = Integer.MIN_VALUE;
+ private int mLastConfiguredScanSettingLE1M = Integer.MIN_VALUE;
+ private int mLastConfiguredScanSettingLECoded = Integer.MIN_VALUE;
// Scan parameters for batch scan.
private BatchScanParams mBatchScanParms;
@@ -91,6 +99,7 @@
private GattService mService;
private BroadcastReceiver mBatchAlarmReceiver;
private boolean mBatchAlarmReceiverRegistered;
+ private boolean mIsAptXLowLatencyModeEnabled;
private ScanNative mScanNative;
private volatile ClientHandler mHandler;
@@ -117,6 +126,18 @@
}
}
+ private class PhyInfo {
+ public int scanPhy;
+ public int scanModeLE1M;
+ public int scanModeLECoded;
+
+ PhyInfo(int scanPhy, int scanModeLE1M, int scanModeLECoded) {
+ this.scanPhy = scanPhy;
+ this.scanModeLE1M = scanModeLE1M;
+ this.scanModeLECoded = scanModeLECoded;
+ }
+ };
+
ScanManager(GattService service) {
mRegularScanClients =
Collections.newSetFromMap(new ConcurrentHashMap<ScanClient, Boolean>());
@@ -267,6 +288,7 @@
@Override
public void handleMessage(Message msg) {
+ Log.i(TAG, "msg.what = " + msg.what);
switch (msg.what) {
case MSG_START_BLE_SCAN:
handleStartScan((ScanClient) msg.obj);
@@ -289,6 +311,12 @@
case MSG_IMPORTANCE_CHANGE:
handleImportanceChange((UidImportance) msg.obj);
break;
+ case MSG_SUSPEND_SCAN_ALL:
+ handleSuspendScanAll();
+ break;
+ case MSG_HANDLE_DISPLAY_CHANGED:
+ handleScanOnDisplayChanged();
+ break;
default:
// Shouldn't happen.
Log.e(TAG, "received an unkown message : " + msg.what);
@@ -333,13 +361,28 @@
return;
}
+ if (isAptXLowLatencyModeEnabled()) {
+ Log.i(TAG, "Cannot start Scan when aptX LL mode is enabled. This scan will be"
+ + " resumed when aptX LL mode is disabled: " + client.scannerId);
+ mSuspendedScanClients.add(client);
+ if (client.stats != null) {
+ client.stats.recordScanSuspend(client.scannerId);
+ }
+ return;
+ }
+
// Begin scan operations.
if (isBatchClient(client)) {
mBatchClients.add(client);
mScanNative.startBatchScan(client);
} else {
mRegularScanClients.add(client);
- mScanNative.startRegularScan(client);
+ boolean ret = mScanNative.startRegularScan(client);
+ if (!ret) {
+ mRegularScanClients.remove(client);
+ return;
+ }
+
if (!mScanNative.isOpportunisticScanClient(client)) {
mScanNative.configureRegularScanParams();
@@ -355,6 +398,8 @@
void handleStopScan(ScanClient client) {
Utils.enforceAdminPermission(mService);
+ boolean appDied;
+ int scannerId;
if (client == null) {
return;
}
@@ -363,6 +408,22 @@
mSuspendedScanClients.remove(client);
}
+ // The caller may pass a dummy client with only clientIf
+ // and appDied status. Perform the operation on the
+ // actual client in that case.
+ appDied = client.appDied;
+ scannerId = client.scannerId;
+ client = mScanNative.getRegularScanClient(scannerId);
+ if (client == null) {
+ if (DBG) Log.d(TAG, "regular client is null");
+ client = mScanNative.getBatchScanClient(scannerId);
+
+ if(client == null) {
+ if (DBG) Log.d(TAG,"batch client is null");
+ return;
+ }
+ }
+
if (mRegularScanClients.contains(client)) {
mScanNative.stopRegularScan(client);
@@ -373,10 +434,10 @@
if (!mScanNative.isOpportunisticScanClient(client)) {
mScanNative.configureRegularScanParams();
}
- } else {
+ } else if (mBatchClients.contains(client)) {
mScanNative.stopBatchScan(client);
}
- if (client.appDied) {
+ if (appDied) {
if (DBG) {
Log.d(TAG, "app died, unregister scanner - " + client.scannerId);
}
@@ -426,6 +487,18 @@
}
}
}
+ void handleSuspendScanAll() {
+ for (ScanClient client : mRegularScanClients) {
+ if (!mScanNative.isOpportunisticScanClient(client)) {
+ /*Suspend both unfiltered & filtered scans*/
+ if (client.stats != null) {
+ client.stats.recordScanSuspend(client.scannerId);
+ }
+ handleStopScan(client);
+ mSuspendedScanClients.add(client);
+ }
+ }
+ }
void handleResumeScans() {
for (ScanClient client : mSuspendedScanClients) {
@@ -468,6 +541,8 @@
}
public int getCurrentUsedTrackingAdvertisement() {
+ Log.d(TAG, "mCurUsedTrackableAdvertisements: "
+ + mCurUsedTrackableAdvertisements);
return mCurUsedTrackableAdvertisements;
}
@@ -477,6 +552,7 @@
private static final int DELIVERY_MODE_IMMEDIATE = 0;
private static final int DELIVERY_MODE_ON_FOUND_LOST = 1;
private static final int DELIVERY_MODE_BATCH = 2;
+ private static final int DELIVERY_MODE_ROUTE = 8;
private static final int ONFOUND_SIGHTINGS_AGGRESSIVE = 1;
private static final int ONFOUND_SIGHTINGS_STICKY = 4;
@@ -535,6 +611,7 @@
mAlarmManager = (AlarmManager) mService.getSystemService(Context.ALARM_SERVICE);
Intent batchIntent = new Intent(ACTION_REFRESH_BATCHED_SCAN, null);
+ batchIntent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
mBatchScanIntervalIntent = PendingIntent.getBroadcast(mService, 0, batchIntent, 0);
IntentFilter filter = new IntentFilter();
filter.addAction(ACTION_REFRESH_BATCHED_SCAN);
@@ -548,9 +625,13 @@
if (mBatchClients.isEmpty()) {
return;
}
- // Note this actually flushes all pending batch data.
- if (mBatchClients.iterator().hasNext()) {
- flushBatchScanResults(mBatchClients.iterator().next());
+ try {
+ // Note this actually flushes all pending batch data.
+ if (mBatchClients.iterator().hasNext()) {
+ flushBatchScanResults(mBatchClients.iterator().next());
+ }
+ } catch (NoSuchElementException e) {
+ Log.e(TAG, "Element not found: " + e);
}
}
}
@@ -576,40 +657,94 @@
if (DBG) {
Log.d(TAG, "configureRegularScanParams() - queue=" + mRegularScanClients.size());
}
- int curScanSetting = Integer.MIN_VALUE;
+ int curScanSettingLE1M = Integer.MIN_VALUE;
+ int curScanSettingLECoded = Integer.MIN_VALUE;
+ int scanPhy = BluetoothDevice.PHY_LE_1M;
ScanClient client = getAggressiveClient(mRegularScanClients);
- if (client != null) {
- curScanSetting = client.settings.getScanMode();
+ PhyInfo phyInfoResult = getPhyInfo(mRegularScanClients);
+ boolean scanModeChanged = false;
+ int scanWindowLE1M = Integer.MIN_VALUE;
+ int scanIntervalLE1M = Integer.MIN_VALUE;
+ int scanWindowLECoded = Integer.MIN_VALUE;
+ int scanIntervalLECoded = Integer.MIN_VALUE;
+ int[] scanInterval = new int[2];
+ int[] scanWindow = new int[2];
+ int phyCnt = 0;
+
+
+ if (phyInfoResult != null) {
+ curScanSettingLE1M = phyInfoResult.scanModeLE1M;
+ curScanSettingLECoded = phyInfoResult.scanModeLECoded;
+ scanPhy = phyInfoResult.scanPhy;
}
if (DBG) {
- Log.d(TAG, "configureRegularScanParams() - ScanSetting Scan mode=" + curScanSetting
- + " mLastConfiguredScanSetting=" + mLastConfiguredScanSetting);
+ Log.d(TAG, "configureRegularScanParams() - ScanSetting LE 1M Scan mode=" + curScanSettingLE1M
+ + "ScanSetting LE Coded Scan mode=" + curScanSettingLECoded
+ + " mLastConfiguredScanSettingLE1M=" + mLastConfiguredScanSettingLE1M
+ + " mLastConfiguredScanSettingLECoded=" + mLastConfiguredScanSettingLECoded
+ + "scanPhy=" + scanPhy);
}
- if (curScanSetting != Integer.MIN_VALUE
- && curScanSetting != ScanSettings.SCAN_MODE_OPPORTUNISTIC) {
- if (curScanSetting != mLastConfiguredScanSetting) {
- int scanWindow = getScanWindowMillis(client.settings);
- int scanInterval = getScanIntervalMillis(client.settings);
+ /* Check whether scan mode for LE 1M PHY has changed and compute the appropriate
+ * scan interval and scan window values
+ */
+ if ((curScanSettingLE1M != Integer.MIN_VALUE
+ && curScanSettingLE1M != ScanSettings.SCAN_MODE_OPPORTUNISTIC)) {
+ if ((curScanSettingLE1M != mLastConfiguredScanSettingLE1M) ||
+ (curScanSettingLECoded != mLastConfiguredScanSettingLECoded)) {
+ scanModeChanged = true;
+ ScanSettings settings = new ScanSettings.Builder().setScanMode(curScanSettingLE1M).build();
+ scanWindowLE1M = getScanWindowMillis(settings);
+ scanIntervalLE1M = getScanIntervalMillis(settings);
// convert scanWindow and scanInterval from ms to LE scan units(0.625ms)
- scanWindow = Utils.millsToUnit(scanWindow);
- scanInterval = Utils.millsToUnit(scanInterval);
- gattClientScanNative(false);
- if (DBG) {
- Log.d(TAG, "configureRegularScanParams - scanInterval = " + scanInterval
- + "configureRegularScanParams - scanWindow = " + scanWindow);
- }
- gattSetScanParametersNative(client.scannerId, scanInterval, scanWindow);
- gattClientScanNative(true);
- mLastConfiguredScanSetting = curScanSetting;
+ scanWindow[phyCnt] = Utils.millsToUnit(scanWindowLE1M);
+ scanInterval[phyCnt] = Utils.millsToUnit(scanIntervalLE1M);
+ phyCnt++;
}
- } else {
- mLastConfiguredScanSetting = curScanSetting;
+ }
+ else {
+ mLastConfiguredScanSettingLE1M = curScanSettingLE1M;
if (DBG) {
Log.d(TAG, "configureRegularScanParams() - queue emtpy, scan stopped");
}
}
+
+ /* Check whether scan mode for LE Coded PHY has changed and compute the appropriate
+ * scan interval and scan window values
+ */
+ if((curScanSettingLECoded != Integer.MIN_VALUE
+ && curScanSettingLECoded != ScanSettings.SCAN_MODE_OPPORTUNISTIC)) {
+ if ((curScanSettingLECoded != mLastConfiguredScanSettingLECoded) ||
+ (curScanSettingLE1M != mLastConfiguredScanSettingLE1M)) {
+ scanModeChanged = true;
+ ScanSettings settings = new ScanSettings.Builder().setScanMode(curScanSettingLECoded).build();
+ scanWindowLECoded = getScanWindowMillis(settings);
+ scanIntervalLECoded = getScanIntervalMillis(settings);
+ // convert scanWindow and scanInterval from ms to LE scan units(0.625ms)
+ scanWindow[phyCnt] = Utils.millsToUnit(scanWindowLECoded);
+ scanInterval[phyCnt] = Utils.millsToUnit(scanIntervalLECoded);
+ }
+ }
+ else {
+ mLastConfiguredScanSettingLECoded = curScanSettingLECoded;
+ if (DBG) {
+ Log.d(TAG, "configureRegularScanParams() - queue emtpy, scan stopped");
+ }
+ }
+ if(scanModeChanged) {
+ gattClientScanNative(false);
+ if (DBG) {
+ Log.d(TAG, "configureRegularScanParams - scanInterval LE 1M = " + scanIntervalLE1M
+ + "configureRegularScanParams - scanWindow LE 1M= " + scanWindowLE1M
+ + "configureRegularScanParams - scanInterval LE Coded= " + scanIntervalLECoded
+ + "configureRegularScanParams - scanWindow LE Coded= " + scanWindowLECoded);
+ }
+ gattSetScanParametersNative(client.scannerId, scanPhy, scanInterval, scanWindow);
+ gattClientScanNative(true);
+ mLastConfiguredScanSettingLE1M = curScanSettingLE1M;
+ mLastConfiguredScanSettingLECoded = curScanSettingLECoded;
+ }
}
ScanClient getAggressiveClient(Set<ScanClient> cList) {
@@ -626,11 +761,46 @@
return result;
}
- void startRegularScan(ScanClient client) {
+ PhyInfo getPhyInfo(Set<ScanClient> cList) {
+ PhyInfo result = null;
+ int curScanSettingLE1M = Integer.MIN_VALUE;
+ int curScanSettingLECoded = Integer.MIN_VALUE;
+ int curScanPhy = BluetoothDevice.PHY_LE_1M;
+ int aggregateScanPhy = BluetoothDevice.PHY_LE_1M;
+ for (ScanClient client : cList) {
+ // Get the most aggresive scan mode for each PHY
+ curScanPhy = client.settings.getPhy();
+ if (((curScanPhy & BluetoothDevice.PHY_LE_1M)== BluetoothDevice.PHY_LE_1M) &&
+ (client.settings.getScanMode() > curScanSettingLE1M)) {
+ curScanSettingLE1M = client.settings.getScanMode();
+ }
+ if (((curScanPhy & BluetoothDevice.PHY_LE_CODED)== BluetoothDevice.PHY_LE_CODED) &&
+ (client.settings.getScanMode() > curScanSettingLECoded)) {
+ curScanSettingLECoded = client.settings.getScanMode();
+ }
+ aggregateScanPhy |= client.settings.getPhy();
+ }
+ result = new PhyInfo(aggregateScanPhy, curScanSettingLE1M, curScanSettingLECoded);
+ return result;
+ }
+
+ boolean startRegularScan(ScanClient client) {
if (isFilteringSupported() && mFilterIndexStack.isEmpty()
&& mClientFilterIndexMap.isEmpty()) {
initFilterIndexStack();
}
+
+ if (isRoutingScanClient(client) && (client.filters.size() > mFilterIndexStack.size())) {
+ try {
+ mService.onScanManagerErrorCallback(client.scannerId,
+ ScanCallback.SCAN_FAILED_OUT_OF_HARDWARE_RESOURCES);
+ Log.e(TAG, "startRegularScan, routing scan out of HARDWARE_RESOURCES");
+ } catch (RemoteException e) {
+ Log.e(TAG, "startRegularScan, routing scan failed on onScanManagerCallback", e);
+ }
+ return false;
+ }
+
if (isFilteringSupported()) {
configureScanFilters(client);
}
@@ -638,6 +808,7 @@
if (numRegularScanClients() == 1) {
gattClientScanNative(true);
}
+ return true;
}
private int numRegularScanClients() {
@@ -664,7 +835,7 @@
private boolean isExemptFromScanDowngrade(ScanClient client) {
return isOpportunisticScanClient(client) || isFirstMatchScanClient(client)
- || !shouldUseAllPassFilter(client);
+ || !shouldUseAllPassFilter(client) || isRoutingScanClient(client);
}
private boolean isOpportunisticScanClient(ScanClient client) {
@@ -676,6 +847,10 @@
!= 0;
}
+ private boolean isRoutingScanClient(ScanClient client) {
+ return client.settings.getCallbackType() == ScanSettings.CALLBACK_TYPE_SENSOR_ROUTING;
+ }
+
private void resetBatchScan(ScanClient client) {
int scannerId = client.scannerId;
BatchScanParams batchScanParams = getBatchScanParams();
@@ -944,16 +1119,20 @@
0);
waitForCallback();
} else {
+ Log.d(TAG, "Available Filter size: " + mFilterIndexStack.size());
Deque<Integer> clientFilterIndices = new ArrayDeque<Integer>();
for (ScanFilter filter : client.filters) {
ScanFilterQueue queue = new ScanFilterQueue();
queue.addScanFilter(filter);
+ ScanFilterQueue.Entry[] entries = queue.toArray();
int featureSelection = queue.getFeatureSelection();
int filterIndex = mFilterIndexStack.pop();
- resetCountDownLatch();
- gattClientScanFilterAddNative(scannerId, queue.toArray(), filterIndex);
- waitForCallback();
+ if (entries != null && entries.length > 0) {
+ resetCountDownLatch();
+ gattClientScanFilterAddNative(scannerId, entries, filterIndex);
+ waitForCallback();
+ }
resetCountDownLatch();
if (deliveryMode == DELIVERY_MODE_ON_FOUND_LOST) {
@@ -1055,6 +1234,9 @@
if (client == null) {
return true;
}
+ if (isRoutingScanClient(client)) {
+ return false;
+ }
if (client.filters == null || client.filters.isEmpty()) {
return true;
}
@@ -1085,7 +1267,7 @@
onLostTimeout = 10000;
if (DBG) {
Log.d(TAG, "configureFilterParamter " + onFoundTimeout + " " + onLostTimeout + " "
- + onFoundCount + " " + numOfTrackingEntries);
+ + onFoundCount + " " + numOfTrackingEntries + ", deliveryMode=" + deliveryMode);
}
FilterParams filtValue =
new FilterParams(scannerId, filterIndex, featureSelection, LIST_LOGIC_TYPE,
@@ -1107,6 +1289,9 @@
|| (settings.getCallbackType() & ScanSettings.CALLBACK_TYPE_MATCH_LOST) != 0) {
return DELIVERY_MODE_ON_FOUND_LOST;
}
+ if (isRoutingScanClient(client)) {
+ return DELIVERY_MODE_ROUTE;
+ }
return settings.getReportDelayMillis() == 0 ? DELIVERY_MODE_IMMEDIATE
: DELIVERY_MODE_BATCH;
}
@@ -1266,8 +1451,8 @@
private native void gattClientScanNative(boolean start);
- private native void gattSetScanParametersNative(int clientIf, int scanInterval,
- int scanWindow);
+ private native void gattSetScanParametersNative(int clientIf, int scan_phy, int[] scanInterval,
+ int[] scanWindow);
/************************** Filter related native methods ********************************/
private native void gattClientScanFilterAddNative(int clientId,
@@ -1313,6 +1498,23 @@
return false;
}
+ public boolean isAptXLowLatencyModeEnabled() {
+ Log.d(TAG, "isAptXLowLatencyModeEnabled: " + mIsAptXLowLatencyModeEnabled);
+ return mIsAptXLowLatencyModeEnabled;
+ }
+
+ public void setAptXLowLatencyMode(boolean enabled){
+ Log.d(TAG, "setAptXLowLatencyMode: mIsAptXLowLatencyModeEnabled: "
+ + mIsAptXLowLatencyModeEnabled + "enabled: " + enabled);
+ mIsAptXLowLatencyModeEnabled = enabled;
+ if (mIsAptXLowLatencyModeEnabled) {
+ sendMessage(MSG_SUSPEND_SCAN_ALL, null);
+ } else {
+ sendMessage(MSG_RESUME_SCANS, null);
+ }
+ }
+
+
private final DisplayManager.DisplayListener mDisplayListener =
new DisplayManager.DisplayListener() {
@Override
@@ -1323,11 +1525,7 @@
@Override
public void onDisplayChanged(int displayId) {
- if (isScreenOn() && mLocationManager.isLocationEnabled()) {
- sendMessage(MSG_RESUME_SCANS, null);
- } else {
- sendMessage(MSG_SUSPEND_SCANS, null);
- }
+ sendMessage(MSG_HANDLE_DISPLAY_CHANGED, null);
}
};
@@ -1400,4 +1598,12 @@
mScanNative.configureRegularScanParams();
}
}
+
+ private void handleScanOnDisplayChanged() {
+ if (isScreenOn() && mLocationManager.isLocationEnabled()) {
+ sendMessage(MSG_RESUME_SCANS, null);
+ } else {
+ sendMessage(MSG_SUSPEND_SCANS, null);
+ }
+ }
}
diff --git a/src/com/android/bluetooth/hearingaid/HearingAidService.java b/src/com/android/bluetooth/hearingaid/HearingAidService.java
index f29d9b9..8cfd180 100644
--- a/src/com/android/bluetooth/hearingaid/HearingAidService.java
+++ b/src/com/android/bluetooth/hearingaid/HearingAidService.java
@@ -42,6 +42,7 @@
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@@ -786,6 +787,7 @@
int toState = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, -1);
int fromState = intent.getIntExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, -1);
connectionStateChanged(device, fromState, toState);
+
}
}
diff --git a/src/com/android/bluetooth/hearingaid/HearingAidStateMachine.java b/src/com/android/bluetooth/hearingaid/HearingAidStateMachine.java
index 5b8d798..602ca5c 100644
--- a/src/com/android/bluetooth/hearingaid/HearingAidStateMachine.java
+++ b/src/com/android/bluetooth/hearingaid/HearingAidStateMachine.java
@@ -169,8 +169,7 @@
}
break;
case DISCONNECT:
- Log.d(TAG, "Disconnected: DISCONNECT: call native disconnect for " + mDevice);
- mNativeInterface.disconnectHearingAid(mDevice);
+ Log.w(TAG, "Disconnected: DISCONNECT ignored: " + mDevice);
break;
case STACK_EVENT:
HearingAidStackEvent event = (HearingAidStackEvent) message.obj;
@@ -481,7 +480,7 @@
private void processConnectionEvent(int state) {
switch (state) {
case HearingAidStackEvent.CONNECTION_STATE_DISCONNECTED:
- Log.i(TAG, "Disconnected from " + mDevice + " but still in Whitelist");
+ Log.i(TAG, "Disconnected from " + mDevice);
transitionTo(mDisconnected);
break;
case HearingAidStackEvent.CONNECTION_STATE_DISCONNECTING:
diff --git a/src/com/android/bluetooth/hfp/AtPhonebook.java b/src/com/android/bluetooth/hfp/AtPhonebook.java
index 937e767..6e4650d 100644
--- a/src/com/android/bluetooth/hfp/AtPhonebook.java
+++ b/src/com/android/bluetooth/hfp/AtPhonebook.java
@@ -23,8 +23,10 @@
import android.database.Cursor;
import android.net.Uri;
import android.provider.CallLog.Calls;
+import android.provider.ContactsContract.CommonDataKinds;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.provider.ContactsContract.PhoneLookup;
+import android.provider.ContactsContract.Contacts;
import android.telephony.PhoneNumberUtils;
import android.util.Log;
@@ -62,9 +64,27 @@
* BT periphals don't. Limit the number we'll report. */
private static final int MAX_PHONEBOOK_SIZE = 16384;
+ private final String SIM_URI = "content://icc/adn";
+
+ static final String[] SIM_PROJECTION = new String[] {
+ Contacts.DISPLAY_NAME,
+ CommonDataKinds.Phone.NUMBER,
+ CommonDataKinds.Phone.TYPE,
+ CommonDataKinds.Phone.LABEL
+ };
+
+ private static final int NAME_COLUMN_INDEX = 0;
+ private static final int NUMBER_COLUMN_INDEX = 1;
+ private static final int NUMBERTYPE_COLUMN_INDEX = 2;
+
private static final String OUTGOING_CALL_WHERE = Calls.TYPE + "=" + Calls.OUTGOING_TYPE;
private static final String INCOMING_CALL_WHERE = Calls.TYPE + "=" + Calls.INCOMING_TYPE;
private static final String MISSED_CALL_WHERE = Calls.TYPE + "=" + Calls.MISSED_TYPE;
+ private static final String VISIBLE_PHONEBOOK_WHERE = null;
+ private static final String VISIBLE_SIM_PHONEBOOK_WHERE = null;
+
+ public static final int OUTGOING_IMS_TYPE = 1001;
+ public static final int OUTGOING_WIFI_TYPE = 1004;
private class PhonebookResult {
public Cursor cursor; // result set of last query
@@ -88,7 +108,7 @@
private static final String BLUETOOTH_ADMIN_PERM = android.Manifest.permission.BLUETOOTH_ADMIN;
private final HashMap<String, PhonebookResult> mPhonebooks =
- new HashMap<String, PhonebookResult>(4);
+ new HashMap<String, PhonebookResult>(5);
static final int TYPE_UNKNOWN = -1;
static final int TYPE_READ = 0;
@@ -104,6 +124,8 @@
mPhonebooks.put("RC", new PhonebookResult()); // received calls
mPhonebooks.put("MC", new PhonebookResult()); // missed calls
mPhonebooks.put("ME", new PhonebookResult()); // mobile phonebook
+ mPhonebooks.put("SM", new PhonebookResult()); // SIM phonebook
+
mCurrentPhonebook = "ME"; // default to mobile phonebook
mCpbrIndex1 = mCpbrIndex2 = -1;
}
@@ -115,24 +137,32 @@
/** Returns the last dialled number, or null if no numbers have been called */
public String getLastDialledNumber() {
String[] projection = {Calls.NUMBER};
- Cursor cursor = mContentResolver.query(Calls.CONTENT_URI, projection,
- Calls.TYPE + "=" + Calls.OUTGOING_TYPE, null,
- Calls.DEFAULT_SORT_ORDER + " LIMIT 1");
- if (cursor == null) {
- Log.w(TAG, "getLastDialledNumber, cursor is null");
- return null;
- }
+ try {
+ Cursor cursor = mContentResolver.query(Calls.CONTENT_URI, projection,
+ Calls.TYPE + " = " + Calls.OUTGOING_TYPE + " OR " + Calls.TYPE +
+ " = " + OUTGOING_IMS_TYPE + " OR " + Calls.TYPE + " = " +
+ OUTGOING_WIFI_TYPE, null, Calls.DEFAULT_SORT_ORDER +
+ " LIMIT 1");
+ log("Queried the last dialled number for CS, IMS, WIFI calls");
+ if (cursor == null) {
+ Log.w(TAG, "getLastDialledNumber, cursor is null");
+ return null;
+ }
- if (cursor.getCount() < 1) {
+ if (cursor.getCount() < 1) {
+ cursor.close();
+ Log.w(TAG, "getLastDialledNumber, cursor.getCount is 0");
+ return null;
+ }
+ cursor.moveToNext();
+ int column = cursor.getColumnIndexOrThrow(Calls.NUMBER);
+ String number = cursor.getString(column);
cursor.close();
- Log.w(TAG, "getLastDialledNumber, cursor.getCount is 0");
- return null;
+ return number;
+ } catch (Exception e) {
+ Log.e(TAG, "Exception while querying last dialled number", e);
}
- cursor.moveToNext();
- int column = cursor.getColumnIndexOrThrow(Calls.NUMBER);
- String number = cursor.getString(column);
- cursor.close();
- return number;
+ return null;
}
public boolean getCheckingAccessPermission() {
@@ -206,11 +236,6 @@
case TYPE_READ: // Read
log("handleCpbsCommand - read command");
// Return current size and max size
- if ("SM".equals(mCurrentPhonebook)) {
- atCommandResponse = "+CPBS: \"SM\",0," + getMaxPhoneBookSize(0);
- atCommandResult = HeadsetHalConstants.AT_RESPONSE_OK;
- break;
- }
PhonebookResult pbr = getPhonebookResult(mCurrentPhonebook, true);
if (pbr == null) {
atCommandErrorCode = BluetoothCmeError.OPERATION_NOT_SUPPORTED;
@@ -279,21 +304,17 @@
*/
log("handleCpbrCommand - test command");
int size;
- if ("SM".equals(mCurrentPhonebook)) {
- size = 0;
- } else {
- PhonebookResult pbr = getPhonebookResult(mCurrentPhonebook, true); //false);
- if (pbr == null) {
- atCommandErrorCode = BluetoothCmeError.OPERATION_NOT_ALLOWED;
- mNativeInterface.atResponseCode(remoteDevice, atCommandResult,
- atCommandErrorCode);
- break;
- }
- size = pbr.cursor.getCount();
- log("handleCpbrCommand - size = " + size);
- pbr.cursor.close();
- pbr.cursor = null;
+ PhonebookResult pbr = getPhonebookResult(mCurrentPhonebook, true); //false);
+ if (pbr == null) {
+ atCommandErrorCode = BluetoothCmeError.OPERATION_NOT_ALLOWED;
+ mNativeInterface.atResponseCode(remoteDevice, atCommandResult,
+ atCommandErrorCode);
+ break;
}
+ size = pbr.cursor.getCount();
+ log("handleCpbrCommand - size = "+size);
+ pbr.cursor.close();
+ pbr.cursor = null;
if (size == 0) {
/* Sending "+CPBR: (1-0)" can confused some carkits, send "1-1" * instead */
size = 1;
@@ -310,6 +331,7 @@
// AT+CPBR=<index1>[,<index2>]
log("handleCpbrCommand - set/read command");
if (mCpbrIndex1 != -1) {
+ Log.i(TAG, "mCpbrIndex1 :" + mCpbrIndex1);
/* handling a CPBR at the moment, reject this CPBR command */
atCommandErrorCode = BluetoothCmeError.OPERATION_NOT_ALLOWED;
mNativeInterface.atResponseCode(remoteDevice, atCommandResult,
@@ -349,7 +371,9 @@
mCheckingAccessPermission = true;
int permission = checkAccessPermission(remoteDevice);
+ Log.i(TAG, "permission :" + permission);
if (permission == BluetoothDevice.ACCESS_ALLOWED) {
+ Log.i(TAG, "permission to access is granted:" );
mCheckingAccessPermission = false;
atCommandResult = processCpbrCommand(remoteDevice);
mCpbrIndex1 = mCpbrIndex2 = -1;
@@ -357,6 +381,7 @@
atCommandErrorCode);
break;
} else if (permission == BluetoothDevice.ACCESS_REJECTED) {
+ Log.i(TAG, "permission to access is not granted:" );
mCheckingAccessPermission = false;
mCpbrIndex1 = mCpbrIndex2 = -1;
mNativeInterface.atResponseCode(remoteDevice,
@@ -400,6 +425,7 @@
private synchronized boolean queryPhonebook(String pb, PhonebookResult pbr) {
String where;
boolean ancillaryPhonebook = true;
+ boolean simPhonebook = false;
if (pb.equals("ME")) {
ancillaryPhonebook = false;
@@ -410,6 +436,10 @@
where = INCOMING_CALL_WHERE;
} else if (pb.equals("MC")) {
where = MISSED_CALL_WHERE;
+ } else if (pb.equals("SM")) {
+ ancillaryPhonebook = false;
+ simPhonebook = true;
+ where = VISIBLE_SIM_PHONEBOOK_WHERE;
} else {
return false;
}
@@ -420,9 +450,14 @@
}
if (ancillaryPhonebook) {
- pbr.cursor = mContentResolver.query(Calls.CONTENT_URI, CALLS_PROJECTION, where, null,
- Calls.DEFAULT_SORT_ORDER + " LIMIT " + MAX_PHONEBOOK_SIZE);
- if (pbr.cursor == null) {
+ try {
+ pbr.cursor = mContentResolver.query(Calls.CONTENT_URI, CALLS_PROJECTION, where,
+ null, Calls.DEFAULT_SORT_ORDER + " LIMIT " + MAX_PHONEBOOK_SIZE);
+ if (pbr.cursor == null) {
+ return false;
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "Exception while querying the call log database", e);
return false;
}
@@ -432,17 +467,56 @@
pbr.typeColumn = -1;
pbr.nameColumn = -1;
} else {
- final Uri phoneContentUri = DevicePolicyUtils.getEnterprisePhoneUri(mContext);
- pbr.cursor = mContentResolver.query(phoneContentUri, PHONES_PROJECTION, where, null,
- Phone.NUMBER + " LIMIT " + MAX_PHONEBOOK_SIZE);
- if (pbr.cursor == null) {
- return false;
- }
+ Log.i(TAG, "simPhonebook " + simPhonebook);
+ if (simPhonebook) {
+ final Uri mysimUri = Uri.parse(SIM_URI);
+ try {
+ pbr.cursor = mContentResolver.query(mysimUri, SIM_PROJECTION,
+ where, null, null);
+ Log.i(TAG, "querySIMcontactbook where " + where + " uri :" + mysimUri);
+ if (pbr.cursor == null) {
+ Log.i(TAG, "querying phone contacts on sim returned null.");
+ return false;
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "Exception while querying sim contact book database", e);
+ return false;
+ }
- pbr.numberColumn = pbr.cursor.getColumnIndex(Phone.NUMBER);
- pbr.numberPresentationColumn = -1;
- pbr.typeColumn = pbr.cursor.getColumnIndex(Phone.TYPE);
- pbr.nameColumn = pbr.cursor.getColumnIndex(Phone.DISPLAY_NAME);
+ pbr.numberColumn = NUMBER_COLUMN_INDEX;
+ pbr.numberPresentationColumn = -1;
+ pbr.typeColumn = NUMBERTYPE_COLUMN_INDEX;
+ pbr.nameColumn = NAME_COLUMN_INDEX;
+ Log.i(TAG, " pbr.numberColumn: " + pbr.numberColumn +
+ " pbr.numberPresentationColumn: " + pbr.numberPresentationColumn +
+ " pbr.typeColumn: " + pbr.typeColumn +
+ " pbr.nameColumn: " + pbr.nameColumn);
+ } else {
+ final Uri phoneContentUri = DevicePolicyUtils.getEnterprisePhoneUri(mContext);
+ try {
+ pbr.cursor = mContentResolver.query(phoneContentUri, PHONES_PROJECTION,
+ where, null, Phone.NUMBER + " LIMIT " + MAX_PHONEBOOK_SIZE);
+ Log.i(TAG, "queryPhonebook where " + where + " uri :" + phoneContentUri);
+ if (pbr.cursor == null) {
+ Log.i(TAG, "querying phone contacts on memory returned null.");
+ return false;
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "Exception while querying phone contacts on memory", e);
+ return false;
+ }
+
+ Log.i(TAG, "Phone.NUMBER: " + Phone.NUMBER + " Phone.TYPE :" + Phone.TYPE +
+ "Phone.DISPLAY_NAME :" + Phone.DISPLAY_NAME);
+ pbr.numberColumn = pbr.cursor.getColumnIndex(Phone.NUMBER);
+ pbr.numberPresentationColumn = -1;
+ pbr.typeColumn = pbr.cursor.getColumnIndex(Phone.TYPE);
+ pbr.nameColumn = pbr.cursor.getColumnIndex(Phone.DISPLAY_NAME);
+ Log.i(TAG, " pbr.numberColumn: " + pbr.numberColumn +
+ " pbr.numberPresentationColumn: " + pbr.numberPresentationColumn +
+ " pbr.typeColumn: " + pbr.typeColumn +
+ " pbr.nameColumn: " + pbr.nameColumn);
+ }
}
Log.i(TAG, "Refreshed phonebook " + pb + " with " + pbr.cursor.getCount() + " results");
return true;
@@ -485,12 +559,6 @@
StringBuilder response = new StringBuilder();
String record;
- // Shortcut SM phonebook
- if ("SM".equals(mCurrentPhonebook)) {
- atCommandResult = HeadsetHalConstants.AT_RESPONSE_OK;
- return atCommandResult;
- }
-
// Check phonebook
PhonebookResult pbr = getPhonebookResult(mCurrentPhonebook, true); //false);
if (pbr == null) {
@@ -528,18 +596,24 @@
// try caller id lookup
// TODO: This code is horribly inefficient. I saw it
// take 7 seconds to process 100 missed calls.
- Cursor c = mContentResolver.query(
- Uri.withAppendedPath(PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI, number),
- new String[]{
+ try {
+ Cursor c = mContentResolver.query(
+ Uri.withAppendedPath(PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI,
+ number), new String[]{
PhoneLookup.DISPLAY_NAME, PhoneLookup.TYPE
- }, null, null, null);
- if (c != null) {
- if (c.moveToFirst()) {
- name = c.getString(0);
- type = c.getInt(1);
+ }, null, null, null);
+ if (c != null) {
+ if (c.moveToFirst()) {
+ name = c.getString(0);
+ type = c.getInt(1);
+ }
+ c.close();
}
- c.close();
+ } catch (Exception e) {
+ Log.e(TAG, "Exception while querying phonebook database", e);
+ return HeadsetHalConstants.AT_RESPONSE_ERROR;
}
+
if (DBG && name == null) {
log("Caller ID lookup failed for " + number);
}
diff --git a/src/com/android/bluetooth/hfp/HeadsetA2dpSync.java b/src/com/android/bluetooth/hfp/HeadsetA2dpSync.java
new file mode 100644
index 0000000..7fb2e2d
--- /dev/null
+++ b/src/com/android/bluetooth/hfp/HeadsetA2dpSync.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) 2018, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package com.android.bluetooth.hfp;
+
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothProfile;
+import android.bluetooth.BluetoothA2dp;
+import android.bluetooth.BluetoothAdapter;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import com.android.bluetooth.hearingaid.HearingAidService;
+import java.util.List;
+
+/**
+ * Defines methods used for synchronization between HFP and A2DP
+ */
+public class HeadsetA2dpSync {
+ private static final String TAG = HeadsetA2dpSync.class.getSimpleName();
+
+ // system inteface
+ private HeadsetSystemInterface mSystemInterface;
+ private HeadsetService mHeadsetService;
+ // Hash for storing the A2DP states
+ private ConcurrentHashMap<BluetoothDevice, Integer> mA2dpConnState =
+ new ConcurrentHashMap<BluetoothDevice, Integer>();
+
+ // internal variables.
+ private int mA2dpSuspendTriggered;// to keep track if A2dp was supended by HFP.
+ private BluetoothDevice mDummyDevice = null;
+
+ //reason for a2dp suspended.
+ public static final int A2DP_SUSPENDED_NOT_TRIGGERED = 0;
+ public static final int A2DP_SUSPENDED_BY_CS_CALL = 1;
+ public static final int A2DP_SUSPENDED_BY_VOIP_CALL = 2;
+ public static final int A2DP_SUSPENDED_BY_VR = 3;
+ // State for a2dp Device
+ // current implementation is only concerned about DISCONNECTED, CONNECTED and PLAYING.
+ public static final int A2DP_DISCONNECTED = 0;// this implies no connection
+ public static final int A2DP_CONNECTING = 1;
+ public static final int A2DP_CONNECTED = 2;// this implies connected but not playing
+ public static final int A2DP_DISCONNECTING = 3;
+ public static final int A2DP_PLAYING = 4;// this implies connected and PLaying
+ public static final int A2DP_SUSPENDED = 5;
+
+ HeadsetA2dpSync(HeadsetSystemInterface systemInterface,HeadsetService service) {
+ mSystemInterface = systemInterface;
+ mHeadsetService = service;
+ mA2dpSuspendTriggered = A2DP_SUSPENDED_NOT_TRIGGERED;// initialize with not suspended.
+ String dummyAddress = "AA:BB:CC:DD:EE:00";
+ mDummyDevice = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(dummyAddress);
+ }
+
+ /* check if any of the a2dp device is playing
+ * TODO: Remove if not required.
+ */
+ /* check if any device is in PLAYING/CONNECTED state
+ * return types:
+ * A2DP_DISCONNECTED: NO Device COnnected
+ * A2DP_CONNECTED: All Devices are in Connected state, none in playing state
+ * A2DP_PLAYING: Atlease one device in playing state
+ */
+ public int isA2dpPlaying() {
+ int a2dpState = A2DP_DISCONNECTED;
+ for(Integer value: mA2dpConnState.values()) {
+ if(value == A2DP_CONNECTED) {
+ a2dpState = value;
+ }
+ if(value == A2DP_PLAYING) {
+ a2dpState = value;
+ Log.d(TAG," isA2dpPlaying returns = " + a2dpState);
+ return a2dpState;
+ }
+ }
+ Log.d(TAG," isA2dpPlaying returns = " + a2dpState);
+ return a2dpState;
+ }
+ /* check and suspend A2DP
+ * return: true in case we have to wait for suepnd confirmation
+ * false in case we don't have to wait for suepnd confirmation
+ * If A2DP is connected, call A2dpSuspended=true ( so that A2DP can't start while call
+ * is acvtive), but we don't have to wait for suspend confirmation in this case
+ * If A2DP is playing, call A2dpSuspended=true, and wait for suspend confirm
+ * if A2DP is not connected, don't do anything.
+ * caller need to send reason for suspend request( VR/CS-CALL/VOIP-CALL)
+ */
+ public boolean suspendA2DP(int reason, BluetoothDevice device){
+ int a2dpState = isA2dpPlaying();
+
+ List<BluetoothDevice> HAActiveDevices = null;
+ HearingAidService mHaService = HearingAidService.getHearingAidService();
+ if (mHaService != null) {
+ HAActiveDevices = mHaService.getActiveDevices();
+ }
+ if (HAActiveDevices != null && (HAActiveDevices.get(0) != null
+ || HAActiveDevices.get(1) != null)) {
+ Log.d(TAG,"Ignore suspendA2DP if active device is HearingAid");
+ return false;
+ }
+
+ Log.d(TAG," suspendA2DP currPlayingState = "+ a2dpState + " for reason " + reason
+ + "mA2dpSuspendTriggered = " + mA2dpSuspendTriggered + " for device " + device);
+ if (mA2dpSuspendTriggered != A2DP_SUSPENDED_NOT_TRIGGERED) {
+ // A2DPSuspend was triggered already, don't need to do anything.
+ if(a2dpState == A2DP_PLAYING) {
+ // we are still waiting for suspend from a2dp.Caller shld wait
+ return true;
+ } else {
+ // not playing, caller need not wait.
+ return false;
+ }
+ }
+ // not device in connected state, nothing to do. Caller shld not wait
+ if(a2dpState == A2DP_DISCONNECTED) {
+ Log.d(TAG," A2DP not Connected, nothing to do ");
+ return false;
+ }
+ if(a2dpState == A2DP_CONNECTED) {
+ mA2dpSuspendTriggered = reason;
+ mSystemInterface.getAudioManager().setParameters("A2dpSuspended=true");
+ Log.d(TAG," A2DP Connected,don't wait for suspend ");
+ return false;
+ }
+ if(a2dpState == A2DP_PLAYING) {
+ mA2dpSuspendTriggered = reason;
+ mSystemInterface.getAudioManager().setParameters("A2dpSuspended=true");
+ Log.d(TAG," A2DP Playing ,wait for suspend ");
+ return true;
+ }
+ return false;
+ }
+
+ /*
+ *This api will be called by SMs, to make A2dpSuspended=false
+ */
+ public boolean releaseA2DP(BluetoothDevice device) {
+ Log.d(TAG," releaseA2DP mA2dpSuspendTriggered " + mA2dpSuspendTriggered +
+ " by device " + device);
+ if(mA2dpSuspendTriggered == A2DP_SUSPENDED_NOT_TRIGGERED) {
+ return true;
+ }
+ if (mHeadsetService.isInCall() || mHeadsetService.isRinging() ||
+ mHeadsetService.isAudioOn()) {
+ Log.d(TAG," Call/Ring/SCO on for some other stateMachine, bail out ");
+ return true;
+ }
+ // A2DP Suspend was triggered by HFP.
+ mA2dpSuspendTriggered = A2DP_SUSPENDED_NOT_TRIGGERED;
+ mSystemInterface.getAudioManager().setParameters("A2dpSuspended=false");
+ return true;
+ }
+
+ public void updateA2DPPlayingState(Intent intent) {
+ int currState = intent.getIntExtra(BluetoothProfile.EXTRA_STATE,
+ BluetoothA2dp.STATE_NOT_PLAYING);
+ int prevState = intent.getIntExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE,
+ BluetoothA2dp.STATE_NOT_PLAYING);
+ BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+
+ Log.d(TAG," updateA2DPPlayingState device: " + device + " transition " +
+ prevState + "->" + currState);
+
+ // if device is not there and state=DISCONNECTED, bail out
+ if(!mA2dpConnState.containsKey(device)) {
+ Log.e(TAG," Got PLay_UPdate without Connectoin Update, this shld not happen "+ device);
+ }
+ switch(currState) {
+ case BluetoothA2dp.STATE_NOT_PLAYING:
+ if (mA2dpConnState.containsKey(device)) {
+ mA2dpConnState.put(device, A2DP_CONNECTED);
+ }
+ /*
+ * send message to statemachine. We send message to SMs
+ * only when all devices moved to SUSPENDED.
+ */
+ int a2dpState = isA2dpPlaying();
+ if ((a2dpState == A2DP_DISCONNECTED) ||
+ (a2dpState == A2DP_CONNECTED)) {
+ mHeadsetService.sendA2dpStateChangeUpdate(a2dpState);
+ }
+ break;
+ case BluetoothA2dp.STATE_PLAYING:
+ if (mA2dpConnState.containsKey(device)) {
+ mA2dpConnState.put(device, A2DP_PLAYING);
+ }
+ // if call/ ring is ongoing and we received playing,
+ // we need to suspend
+ if (mHeadsetService.isInCall() || mHeadsetService.isRinging()) {
+ Log.d(TAG," CALL/Ring is active ");
+ suspendA2DP(A2DP_SUSPENDED_BY_CS_CALL, mDummyDevice);
+ }
+ break;
+ }
+ Log.d(TAG," device: " + device + " state = " + mA2dpConnState.get(device));
+ }
+ /*
+ * BookKeeping of A2dp Device State, based on intents from A2DPStateMachine.
+ */
+ public void updateA2DPConnectionState(Intent intent) {
+ int currState = intent.getIntExtra(BluetoothProfile.EXTRA_STATE,
+ BluetoothProfile.STATE_DISCONNECTED);
+ int prevState = intent.getIntExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE,
+ BluetoothProfile.STATE_DISCONNECTED);
+ BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+
+ Log.d(TAG," updateA2DPConnectionState device: " + device + " transition " +
+ prevState + "->" + currState);
+
+ // if device is not there and state=DISCONNECTED, bail out
+ if(!mA2dpConnState.containsKey(device) &&
+ (currState == BluetoothProfile.STATE_DISCONNECTED)) {
+ Log.e(TAG," Got Disc for device not in entry "+ device);
+ return;
+ }
+ switch(currState) {
+ case BluetoothProfile.STATE_DISCONNECTED:
+ mA2dpConnState.remove(device);
+ break;
+ // treating everything else as Connected
+ case BluetoothProfile.STATE_DISCONNECTING:
+ case BluetoothProfile.STATE_CONNECTING:
+ mA2dpConnState.put(device, A2DP_CONNECTED);
+ break;
+ case BluetoothProfile.STATE_CONNECTED:
+ mA2dpConnState.put(device, A2DP_CONNECTED);
+ if (mHeadsetService.isInCall() || mHeadsetService.isRinging()) {
+ Log.d(TAG," CALL is active/ringing, A2DP got connected, suspending");
+ suspendA2DP(A2DP_SUSPENDED_BY_CS_CALL, mDummyDevice);
+ }
+ break;
+ }
+ Log.d(TAG," device: " + device + " state = " + mA2dpConnState.get(device));
+ }
+}
diff --git a/src/com/android/bluetooth/hfp/HeadsetPhoneState.java b/src/com/android/bluetooth/hfp/HeadsetPhoneState.java
index 941ec14..23baac4 100644
--- a/src/com/android/bluetooth/hfp/HeadsetPhoneState.java
+++ b/src/com/android/bluetooth/hfp/HeadsetPhoneState.java
@@ -33,11 +33,11 @@
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.IccCardConstants;
import com.android.internal.telephony.TelephonyIntents;
+import com.android.internal.telephony.PhoneConstants;
import java.util.HashMap;
import java.util.Objects;
-
/**
* Class that manages Telephony states
*
@@ -72,6 +72,18 @@
private int mCindRoam = HeadsetHalConstants.SERVICE_TYPE_HOME;
// HFP 1.6 CIND battchg value
private int mCindBatteryCharge;
+ // Current Call Number
+ private String mCindNumber;
+ //Current Phone Number Type
+ private int mType = 0;
+ // if its a CS call
+ private boolean mIsCsCall = true;
+ // SIM is absent
+ private int SIM_ABSENT = 0;
+ // SIM is present
+ private int SIM_PRESENT = 1;
+ // Array to keep the SIM status
+ private int[] mSimStatus;
private final HashMap<BluetoothDevice, Integer> mDeviceEventMap = new HashMap<>();
private PhoneStateListener mPhoneStateListener;
@@ -85,12 +97,33 @@
Objects.requireNonNull(mTelephonyManager, "TELEPHONY_SERVICE is null");
// Register for SubscriptionInfo list changes which is guaranteed to invoke
// onSubscriptionInfoChanged and which in turns calls loadInBackgroud.
- mSubscriptionManager = SubscriptionManager.from(mHeadsetService);
+ mSubscriptionManager = (SubscriptionManager) mHeadsetService.
+ getSystemService(Context.TELEPHONY_SUBSCRIPTION_SERVICE);
Objects.requireNonNull(mSubscriptionManager, "TELEPHONY_SUBSCRIPTION_SERVICE is null");
// Initialize subscription on the handler thread
mOnSubscriptionsChangedListener = new HeadsetPhoneStateOnSubscriptionChangedListener(
headsetService.getStateMachinesThreadLooper());
mSubscriptionManager.addOnSubscriptionsChangedListener(mOnSubscriptionsChangedListener);
+ IntentFilter simStateChangedFilter =
+ new IntentFilter(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
+ mSimStatus = new int [mTelephonyManager.getPhoneCount()];
+ //Record the SIM states upon BT reset
+ try {
+ for (int i = 0; i < mSimStatus.length; i++) {
+ if (mTelephonyManager.getSimState(i) ==
+ TelephonyManager.SIM_STATE_READY) {
+ Log.d(TAG, "The sim in i: " + i + " is present");
+ mSimStatus[i] = SIM_PRESENT;
+ } else {
+ Log.d(TAG, "The sim in i: " + i + " is absent");
+ mSimStatus[i] = SIM_ABSENT;
+ }
+ }
+ mHeadsetService.registerReceiver(mPhoneStateChangeReceiver, simStateChangedFilter);
+ } catch (Exception e) {
+ Log.w(TAG, "Unable to register phone state change receiver and unable to get" +
+ " sim states", e);
+ }
}
/**
@@ -102,6 +135,11 @@
stopListenForPhoneState();
}
mSubscriptionManager.removeOnSubscriptionsChangedListener(mOnSubscriptionsChangedListener);
+ try {
+ mHeadsetService.unregisterReceiver(mPhoneStateChangeReceiver);
+ } catch (Exception e) {
+ Log.w(TAG, "Unable to unregister phone state change receiver", e);
+ }
}
@Override
@@ -160,13 +198,22 @@
return;
}
Log.i(TAG, "startListenForPhoneState(), subId=" + subId + ", enabled_events=" + events);
- mPhoneStateListener = new HeadsetPhoneStateListener(
- mHeadsetService.getStateMachinesThreadLooper());
- mTelephonyManager.listen(mPhoneStateListener, events);
- if ((events & PhoneStateListener.LISTEN_SIGNAL_STRENGTHS) != 0) {
- mTelephonyManager.setRadioIndicationUpdateMode(
- TelephonyManager.INDICATION_FILTER_SIGNAL_STRENGTH,
- TelephonyManager.INDICATION_UPDATE_MODE_IGNORE_SCREEN_OFF);
+ if (mTelephonyManager == null) {
+ Log.e(TAG, "mTelephonyManager is null, "
+ + "cannot start listening for phone state changes");
+ } else {
+ mPhoneStateListener = new HeadsetPhoneStateListener(
+ mHeadsetService.getStateMachinesThreadLooper());
+ try {
+ mTelephonyManager.listen(mPhoneStateListener, events);
+ if ((events & PhoneStateListener.LISTEN_SIGNAL_STRENGTHS) != 0) {
+ mTelephonyManager.setRadioIndicationUpdateMode(
+ TelephonyManager.INDICATION_FILTER_SIGNAL_STRENGTH,
+ TelephonyManager.INDICATION_UPDATE_MODE_IGNORE_SCREEN_OFF);
+ }
+ } catch (Exception e) {
+ Log.w(TAG, "Exception while registering for signal strength notifications", e);
+ }
}
}
@@ -177,13 +224,78 @@
}
Log.i(TAG, "stopListenForPhoneState(), stopping listener, enabled_events="
+ getTelephonyEventsToListen());
- mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
- mTelephonyManager.setRadioIndicationUpdateMode(
- TelephonyManager.INDICATION_FILTER_SIGNAL_STRENGTH,
- TelephonyManager.INDICATION_UPDATE_MODE_NORMAL);
+ if (mTelephonyManager == null) {
+ Log.e(TAG, "mTelephonyManager is null, "
+ + "cannot send request to stop listening or update radio to normal state");
+ } else {
+ try {
+ mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
+ mTelephonyManager.setRadioIndicationUpdateMode(
+ TelephonyManager.INDICATION_FILTER_SIGNAL_STRENGTH,
+ TelephonyManager.INDICATION_UPDATE_MODE_NORMAL);
+ } catch (Exception e) {
+ Log.w(TAG, "exception while registering for signal strength notifications", e);
+ }
+ }
mPhoneStateListener = null;
}
+ public boolean isValidPhoneId(int phoneId) {
+ return phoneId >= 0 && phoneId < mTelephonyManager.getPhoneCount();
+ }
+
+ private final BroadcastReceiver mPhoneStateChangeReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ Log.d(TAG, "onReceive: " + intent.getAction());
+ final String stateExtra = intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE);
+ if (TelephonyIntents.ACTION_SIM_STATE_CHANGED.equals(intent.getAction())) {
+ // This is a sticky broadcast, so if it's already been loaded,
+ // this'll execute immediately.
+
+ // TODO (b/122116049) during platform update, a case emerged for an incoming
+ // slotId value of -1; it would likely be beneficial to code defensively
+ // because of this case's possibility from the caller, but the current root
+ // cause is as of yet unidentified
+ if (IccCardConstants.INTENT_VALUE_ICC_LOADED.equals(stateExtra)) {
+ final int phoneId = intent.getIntExtra(PhoneConstants.PHONE_KEY,
+ SubscriptionManager.getDefaultVoicePhoneId());
+ if (isValidPhoneId(phoneId) != true) {
+ Log.d(TAG, "Received invalid phoneId " + phoneId +" for SIM loaded, no action");
+ return;
+ }
+ Log.d(TAG, "SIM loaded, making mIsSimStateLoaded to true for phoneId = "
+ + phoneId);
+ mSimStatus[phoneId] = SIM_PRESENT;
+ mIsSimStateLoaded = true;
+ sendDeviceStateChanged();
+ } else if (IccCardConstants.INTENT_VALUE_ICC_ABSENT.equals(stateExtra)
+ || IccCardConstants.INTENT_VALUE_ICC_UNKNOWN.equals(stateExtra)
+ || IccCardConstants.INTENT_VALUE_ICC_CARD_IO_ERROR.equals(stateExtra)) {
+ final int phoneId = intent.getIntExtra(PhoneConstants.PHONE_KEY,
+ SubscriptionManager.getDefaultVoicePhoneId());
+ if (isValidPhoneId(phoneId) != true) {
+ Log.d(TAG, "Received invalid phoneId " + phoneId +" for SIM unloaded, no action");
+ return;
+ }
+ Log.d(TAG, "SIM unloaded, making mIsSimStateLoaded to false for phoneId = "
+ + phoneId);
+ mSimStatus[phoneId] = SIM_ABSENT;
+ mIsSimStateLoaded = false;
+ for (int i = 0; i < mSimStatus.length; i++) {
+ if (mSimStatus[i] == SIM_PRESENT) {
+ Log.d(TAG, "SIM is loaded in either of the slots, making" +
+ " mIsSimStateLoaded to true");
+ mIsSimStateLoaded = true;
+ break;
+ }
+ }
+ sendDeviceStateChanged();
+ }
+ }
+ }
+ };
+
int getCindService() {
return mCindService;
}
@@ -197,6 +309,16 @@
mNumActive = numActive;
}
+ boolean getIsCsCall() {
+ Log.d(TAG, "In getIsCsCall, mIsCsCall: " + mIsCsCall);
+ return mIsCsCall;
+ }
+
+ void setIsCsCall(boolean isCsCall) {
+ Log.d(TAG, "In setIsCsCall, mIsCsCall: " + isCsCall);
+ mIsCsCall = isCsCall;
+ }
+
int getCallState() {
return mCallState;
}
@@ -219,6 +341,22 @@
return mCindSignal;
}
+ void setNumber(String mNumberCall ) {
+ mCindNumber = mNumberCall;
+ }
+
+ String getNumber() {
+ return mCindNumber;
+ }
+
+ void setType(int mTypeCall) {
+ mType = mTypeCall;
+ }
+
+ int getType() {
+ return mType;
+ }
+
int getCindRoam() {
return mCindRoam;
}
@@ -251,7 +389,7 @@
// use the service indicator, but only the signal indicator
int signal = service == HeadsetHalConstants.NETWORK_STATE_AVAILABLE ? mCindSignal : 0;
- Log.d(TAG, "sendDeviceStateChanged. mService=" + mCindService + " mIsSimStateLoaded="
+ Log.d(TAG, "sendDeviceStateChanged. mService=" + service + " mIsSimStateLoaded="
+ mIsSimStateLoaded + " mSignal=" + signal + " mRoam=" + mCindRoam
+ " mBatteryCharge=" + mCindBatteryCharge);
mHeadsetService.onDeviceStateChanged(
@@ -280,7 +418,9 @@
@Override
public synchronized void onServiceStateChanged(ServiceState serviceState) {
+ Log.d(TAG, "Enter onServiceStateChanged");
mServiceState = serviceState;
+ int prevService = mCindService;
int cindService = (serviceState.getState() == ServiceState.STATE_IN_SERVICE)
? HeadsetHalConstants.NETWORK_STATE_AVAILABLE
: HeadsetHalConstants.NETWORK_STATE_NOT_AVAILABLE;
@@ -297,34 +437,28 @@
// If this is due to a SIM insertion, we want to defer sending device state changed
// until all the SIM config is loaded.
if (cindService == HeadsetHalConstants.NETWORK_STATE_NOT_AVAILABLE) {
- mIsSimStateLoaded = false;
sendDeviceStateChanged();
- return;
}
- IntentFilter simStateChangedFilter =
- new IntentFilter(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
- mHeadsetService.registerReceiver(new BroadcastReceiver() {
- @Override
- public void onReceive(Context context, Intent intent) {
- if (TelephonyIntents.ACTION_SIM_STATE_CHANGED.equals(intent.getAction())) {
- // This is a sticky broadcast, so if it's already been loaded,
- // this'll execute immediately.
- if (IccCardConstants.INTENT_VALUE_ICC_LOADED.equals(
- intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE))) {
- mIsSimStateLoaded = true;
- sendDeviceStateChanged();
- mHeadsetService.unregisterReceiver(this);
- }
- }
- }
- }, simStateChangedFilter);
+ //Update the signal strength when the service state changes
+ if (prevService == HeadsetHalConstants.NETWORK_STATE_NOT_AVAILABLE &&
+ cindService == HeadsetHalConstants.NETWORK_STATE_AVAILABLE &&
+ mCindSignal == 0) {
+ Log.d(TAG, "Service is available and signal strength was zero, updating the "+
+ "current signal strength");
+ mCindSignal = mTelephonyManager.getSignalStrength().getLevel() + 1;
+ // +CIND "signal" indicator is always between 0 to 5
+ mCindSignal = Integer.max(Integer.min(mCindSignal, 5), 0);
+ sendDeviceStateChanged();
+ }
+ Log.d(TAG, "Exit onServiceStateChanged");
}
@Override
public void onSignalStrengthsChanged(SignalStrength signalStrength) {
int prevSignal = mCindSignal;
if (mCindService == HeadsetHalConstants.NETWORK_STATE_NOT_AVAILABLE) {
+ Log.d(TAG, "Service is not available, signal strength is set to zero");
mCindSignal = 0;
} else {
mCindSignal = signalStrength.getLevel() + 1;
@@ -333,6 +467,7 @@
mCindSignal = Integer.max(Integer.min(mCindSignal, 5), 0);
// This results in a lot of duplicate messages, hence this check
if (prevSignal != mCindSignal) {
+ Log.d(TAG, "Updating the signal strength change to the apps");
sendDeviceStateChanged();
}
}
diff --git a/src/com/android/bluetooth/hfp/HeadsetService.java b/src/com/android/bluetooth/hfp/HeadsetService.java
old mode 100644
new mode 100755
index 1dbafd0..421ec73
--- a/src/com/android/bluetooth/hfp/HeadsetService.java
+++ b/src/com/android/bluetooth/hfp/HeadsetService.java
@@ -19,7 +19,10 @@
import static android.Manifest.permission.MODIFY_PHONE_STATE;
import android.annotation.Nullable;
+import android.bluetooth.BluetoothA2dp;
import android.bluetooth.BluetoothDevice;
+
+import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothHeadset;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothUuid;
@@ -53,9 +56,12 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
+import java.util.concurrent.Executor;
import java.util.HashMap;
import java.util.List;
import java.util.Objects;
+import android.telecom.TelecomManager;
+
/**
* Provides Bluetooth Headset and Handsfree profile, as a service in the Bluetooth application.
@@ -86,7 +92,7 @@
*/
public class HeadsetService extends ProfileService {
private static final String TAG = "HeadsetService";
- private static final boolean DBG = false;
+ private static final boolean DBG = true;
private static final String DISABLE_INBAND_RINGING_PROPERTY =
"persist.bluetooth.disableinbandringing";
private static final ParcelUuid[] HEADSET_UUIDS = {BluetoothUuid.HSP, BluetoothUuid.Handsfree};
@@ -95,6 +101,7 @@
private static final int DIALING_OUT_TIMEOUT_MS = 10000;
private int mMaxHeadsetConnections = 1;
+ private int mSetMaxConfig;
private BluetoothDevice mActiveDevice;
private AdapterService mAdapterService;
private HandlerThread mStateMachinesThread;
@@ -102,6 +109,7 @@
private final HashMap<BluetoothDevice, HeadsetStateMachine> mStateMachines = new HashMap<>();
private HeadsetNativeInterface mNativeInterface;
private HeadsetSystemInterface mSystemInterface;
+ private HeadsetA2dpSync mHfpA2dpSyncInterface;
private boolean mAudioRouteAllowed = true;
// Indicates whether SCO audio needs to be forced to open regardless ANY OTHER restrictions
private boolean mForceScoAudio;
@@ -117,6 +125,12 @@
private boolean mStarted;
private boolean mCreated;
private static HeadsetService sHeadsetService;
+ private boolean mDisconnectAll;
+ private boolean mIsTwsPlusEnabled = false;
+ private boolean mIsTwsPlusShoEnabled = false;
+ private vendorhfservice mVendorHf;
+ private Context mContext = null;
+ private AudioServerStateCallback mServerStateCallback = new AudioServerStateCallback();
@Override
public IProfileServiceBinder initBinder() {
@@ -130,13 +144,15 @@
throw new IllegalStateException("create() called twice");
}
mCreated = true;
+ mVendorHf = new vendorhfservice(this);
}
@Override
protected boolean start() {
Log.i(TAG, "start()");
- if (mStarted) {
- throw new IllegalStateException("start() called twice");
+ if (sHeadsetService != null) {
+ Log.w(TAG, "HeadsetService is already running");
+ return true;
}
// Step 1: Get adapter service, should never be null
mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(),
@@ -148,7 +164,41 @@
mSystemInterface = HeadsetObjectsFactory.getInstance().makeSystemInterface(this);
mSystemInterface.init();
// Step 4: Initialize native interface
- mMaxHeadsetConnections = mAdapterService.getMaxConnectedAudioDevices();
+ mSetMaxConfig = mMaxHeadsetConnections = mAdapterService.getMaxConnectedAudioDevices();
+ if(mAdapterService.isVendorIntfEnabled()) {
+ String twsPlusEnabled = SystemProperties.get("persist.vendor.btstack.enable.twsplus");
+ String twsPlusShoEnabled =
+ SystemProperties.get("persist.vendor.btstack.enable.twsplussho");
+
+ if (!twsPlusEnabled.isEmpty() && "true".equals(twsPlusEnabled)) {
+ mIsTwsPlusEnabled = true;
+ }
+ if (!twsPlusShoEnabled.isEmpty() && "true".equals(twsPlusShoEnabled)) {
+ if (mIsTwsPlusEnabled) {
+ mIsTwsPlusShoEnabled = true;
+ } else {
+ Log.e(TAG, "no TWS+ SHO without TWS+ support!");
+ mIsTwsPlusShoEnabled = false;
+ }
+ }
+ Log.i(TAG, "mIsTwsPlusEnabled: " + mIsTwsPlusEnabled);
+ Log.i(TAG, "mIsTwsPlusShoEnabled: " + mIsTwsPlusShoEnabled);
+ if (mIsTwsPlusEnabled && mMaxHeadsetConnections < 2){
+ //set MaxConn to 2 if TWSPLUS enabled
+ mMaxHeadsetConnections = 2;
+ }
+ if (mIsTwsPlusShoEnabled && mMaxHeadsetConnections < 3) {
+ //set MaxConn to 3 if TWSPLUS enabled
+ mMaxHeadsetConnections = 3;
+ }
+ //Only if the User set config 1 and TWS+ is enabled leaves
+ //these maxConn at 2 and setMaxConfig to 1. this is to avoid
+ //connecting to more than 1 legacy device even though max conns
+ //is set 2 or 3because of TWS+ requirement
+ Log.d(TAG, "Max_HFP_Connections " + mMaxHeadsetConnections);
+ Log.d(TAG, "mSetMaxConfig " + mSetMaxConfig);
+ }
+
mNativeInterface = HeadsetObjectsFactory.getInstance().getNativeInterface();
// Add 1 to allow a pending device to be connecting or disconnecting
mNativeInterface.init(mMaxHeadsetConnections + 1, isInbandRingingEnabled());
@@ -164,10 +214,27 @@
filter.addAction(AudioManager.VOLUME_CHANGED_ACTION);
filter.addAction(BluetoothDevice.ACTION_CONNECTION_ACCESS_REPLY);
filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
+ filter.addAction(BluetoothA2dp.ACTION_PLAYING_STATE_CHANGED);
+ filter.addAction(BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED);
+ filter.addAction(TelecomManager.ACTION_CALL_TYPE);
registerReceiver(mHeadsetReceiver, filter);
// Step 7: Mark service as started
+
setHeadsetService(this);
mStarted = true;
+
+ mHfpA2dpSyncInterface = new HeadsetA2dpSync(mSystemInterface, this);
+ if (mVendorHf != null) {
+ mVendorHf.init();
+ mVendorHf.enableSwb(isSwbEnabled());
+ }
+
+ Log.d(TAG, "registering audio server state callback");
+ mContext = getApplicationContext();
+ Executor exec = mContext.getMainExecutor();
+ mSystemInterface.getAudioManager().setAudioServerStateCallback(exec, mServerStateCallback);
+
+ Log.i(TAG, " HeadsetService Started ");
return true;
}
@@ -191,16 +258,30 @@
mInbandRingingRuntimeDisable = false;
mForceScoAudio = false;
mAudioRouteAllowed = true;
- mMaxHeadsetConnections = 1;
+ if(mAdapterService.isVendorIntfEnabled()) {
+ //to enable TWS
+ if (mIsTwsPlusEnabled) {
+ mMaxHeadsetConnections = 2;
+ } else {
+ mMaxHeadsetConnections = 1;
+ }
+ } else {
+ mMaxHeadsetConnections = 1;
+ }
mVoiceRecognitionStarted = false;
mVirtualCallStarted = false;
if (mDialingOutTimeoutEvent != null) {
- mStateMachinesThread.getThreadHandler().removeCallbacks(mDialingOutTimeoutEvent);
+ if (mStateMachinesThread != null) {
+ mStateMachinesThread.getThreadHandler()
+ .removeCallbacks(mDialingOutTimeoutEvent);
+ }
mDialingOutTimeoutEvent = null;
}
if (mVoiceRecognitionTimeoutEvent != null) {
- mStateMachinesThread.getThreadHandler()
+ if (mStateMachinesThread != null) {
+ mStateMachinesThread.getThreadHandler()
.removeCallbacks(mVoiceRecognitionTimeoutEvent);
+ }
mVoiceRecognitionTimeoutEvent = null;
if (mSystemInterface.getVoiceRecognitionWakeLock().isHeld()) {
mSystemInterface.getVoiceRecognitionWakeLock().release();
@@ -216,11 +297,13 @@
mNativeInterface.cleanup();
// Step 3: Destroy system interface
mSystemInterface.stop();
- // Step 2: Stop handler thread
- mStateMachinesThread.quitSafely();
- mStateMachinesThread = null;
- // Step 1: Clear
synchronized (mStateMachines) {
+ // Step 2: Stop handler thread
+ if (mStateMachinesThread != null) {
+ mStateMachinesThread.quitSafely();
+ }
+ mStateMachinesThread = null;
+ // Step 1: Clear
mAdapterService = null;
}
return true;
@@ -232,6 +315,9 @@
if (!mCreated) {
Log.w(TAG, "cleanup() called before create()");
}
+ if (mVendorHf != null) {
+ mVendorHf.cleanup();
+ }
mCreated = false;
}
@@ -252,13 +338,30 @@
*/
@VisibleForTesting
public Looper getStateMachinesThreadLooper() {
- return mStateMachinesThread.getLooper();
+ if (mStateMachinesThread != null) {
+ return mStateMachinesThread.getLooper();
+ }
+ return null;
}
interface StateMachineTask {
void execute(HeadsetStateMachine stateMachine);
}
+ // send message to all statemachines in connecting and connected state.
+ private void doForEachConnectedConnectingStateMachine(StateMachineTask task) {
+ synchronized (mStateMachines) {
+ for (BluetoothDevice device :
+ getDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES)) {
+ HeadsetStateMachine stateMachine = mStateMachines.get(device);
+ if (stateMachine == null) {
+ continue;
+ }
+ task.execute(stateMachine);
+ }
+ }
+ }
+
private boolean doForStateMachine(BluetoothDevice device, StateMachineTask task) {
synchronized (mStateMachines) {
HeadsetStateMachine stateMachine = mStateMachines.get(device);
@@ -273,15 +376,21 @@
private void doForEachConnectedStateMachine(StateMachineTask task) {
synchronized (mStateMachines) {
for (BluetoothDevice device : getConnectedDevices()) {
- task.execute(mStateMachines.get(device));
+ HeadsetStateMachine stateMachine = mStateMachines.get(device);
+ if (stateMachine == null) {
+ continue;
+ }
+ task.execute(stateMachine);
}
}
}
void onDeviceStateChanged(HeadsetDeviceState deviceState) {
- doForEachConnectedStateMachine(
+ synchronized (mStateMachines) {
+ doForEachConnectedStateMachine(
stateMachine -> stateMachine.sendMessage(HeadsetStateMachine.DEVICE_STATE_CHANGED,
deviceState));
+ }
}
/**
@@ -301,11 +410,15 @@
case HeadsetHalConstants.CONNECTION_STATE_CONNECTING: {
// Create new state machine if none is found
if (stateMachine == null) {
- stateMachine = HeadsetObjectsFactory.getInstance()
+ if (mStateMachinesThread != null) {
+ stateMachine = HeadsetObjectsFactory.getInstance()
.makeStateMachine(stackEvent.device,
mStateMachinesThread.getLooper(), this, mAdapterService,
mNativeInterface, mSystemInterface);
- mStateMachines.put(stackEvent.device, stateMachine);
+ mStateMachines.put(stackEvent.device, stateMachine);
+ } else {
+ Log.w(TAG, "messageFromNative: mStateMachinesThread is null");
+ }
}
break;
}
@@ -319,6 +432,30 @@
}
}
+ private class AudioServerStateCallback extends AudioManager.AudioServerStateCallback {
+ @Override
+ public void onAudioServerDown() {
+ Log.d(TAG, "notifying onAudioServerDown");
+ }
+
+ @Override
+ public void onAudioServerUp() {
+ Log.d(TAG, "notifying onAudioServerUp");
+ if (isAudioOn()) {
+ Log.d(TAG, "onAudioServerUp: Audio is On, Notify HeadsetStateMachine");
+ synchronized (mStateMachines) {
+ for (HeadsetStateMachine stateMachine : mStateMachines.values()) {
+ if (stateMachine.getAudioState()
+ == BluetoothHeadset.STATE_AUDIO_CONNECTED) {
+ stateMachine.onAudioServerUp();
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
private final BroadcastReceiver mHeadsetReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
@@ -343,8 +480,10 @@
case AudioManager.VOLUME_CHANGED_ACTION: {
int streamType = intent.getIntExtra(AudioManager.EXTRA_VOLUME_STREAM_TYPE, -1);
if (streamType == AudioManager.STREAM_BLUETOOTH_SCO) {
- doForEachConnectedStateMachine(stateMachine -> stateMachine.sendMessage(
+ synchronized (mStateMachines) {
+ doForEachConnectedStateMachine(stateMachine -> stateMachine.sendMessage(
HeadsetStateMachine.INTENT_SCO_VOLUME_CHANGED, intent));
+ }
}
break;
}
@@ -391,6 +530,23 @@
}
break;
}
+ case BluetoothA2dp.ACTION_PLAYING_STATE_CHANGED: {
+ logD("Received BluetoothA2dp Play State changed");
+ mHfpA2dpSyncInterface.updateA2DPPlayingState(intent);
+ break;
+ }
+ case BluetoothA2dp.ACTION_CONNECTION_STATE_CHANGED: {
+ logD("Received BluetoothA2dp Connection State changed");
+ mHfpA2dpSyncInterface.updateA2DPConnectionState(intent);
+ break;
+ }
+ case TelecomManager.ACTION_CALL_TYPE: {
+ logD("Received BluetoothHeadset action call type");
+ synchronized (mStateMachines) {
+ doForEachConnectedStateMachine(stateMachine -> stateMachine.sendMessage(
+ HeadsetStateMachine.UPDATE_CALL_TYPE, intent));
+ }
+ }
default:
Log.w(TAG, "Unknown action " + action);
}
@@ -466,6 +622,15 @@
return service.getDevicesMatchingConnectionStates(states);
}
+ public List<BluetoothDevice> getAllDevicesMatchingConnectionStates(int[] states) {
+ HeadsetService service = getService();
+ if (service == null) {
+ return new ArrayList<BluetoothDevice>(0);
+ }
+ return service.getAllDevicesMatchingConnectionStates(states);
+ }
+
+
@Override
public int getConnectionState(BluetoothDevice device) {
HeadsetService service = getService();
@@ -678,26 +843,169 @@
sHeadsetService = instance;
}
+ public BluetoothDevice getTwsPlusConnectedPeer(BluetoothDevice device) {
+ AdapterService adapterService = AdapterService.getAdapterService();
+ if (!adapterService.isTwsPlusDevice(device)) {
+ logD("getTwsPlusConnectedPeer: Not a TWS+ device");
+ return null;
+ }
+ List<BluetoothDevice> connDevices = getConnectedDevices();
+
+ int size = connDevices.size();
+ for(int i = 0; i < size; i++) {
+ BluetoothDevice ConnectedDevice = connDevices.get(i);
+ if (adapterService.getTwsPlusPeerAddress(device).equals(ConnectedDevice.getAddress())) {
+ return ConnectedDevice;
+ }
+ }
+ return null;
+ }
+
+ private BluetoothDevice getConnectedOrConnectingTwspDevice() {
+ List<BluetoothDevice> connDevices =
+ getAllDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES);
+ int size = connDevices.size();
+ for(int i = 0; i < size; i++) {
+ BluetoothDevice ConnectedDevice = connDevices.get(i);
+ if (mAdapterService.isTwsPlusDevice(ConnectedDevice)) {
+ logD("getConnectedorConnectingTwspDevice: found" + ConnectedDevice);
+ return ConnectedDevice;
+ }
+ }
+ return null;
+ }
+
+ /*
+ * This function determines possible connections allowed with both Legacy
+ * TWS+ earbuds.
+ * N is the maximum audio connections set (defaults to 5)
+ * In TWS+ connections
+ * - There can be only ONE set of TWS+ earbud connected at any point
+ * of time
+ * - Once one of the TWS+ earbud is connected, another slot will be
+ * reserved for the TWS+ peer earbud. Hence there can be maximum
+ * of N-2 legacy device connections when an earbud is connected.
+ * - If user wants to connect to another TWS+ earbud set. Existing TWS+
+ * connection need to be removed explicitly
+ * In Legacy(Non-TWS+) Connections
+ * -Maximum allowed connections N set by user is used to determine number
+ * of Legacy connections
+ */
+ private boolean isConnectionAllowed(BluetoothDevice device,
+ List<BluetoothDevice> connDevices
+ ) {
+ AdapterService adapterService = AdapterService.getAdapterService();
+ boolean allowSecondHfConnection = false;
+ int reservedSlotForTwspPeer = 0;
+
+ if (!mIsTwsPlusEnabled && adapterService.isTwsPlusDevice(device)) {
+ logD("No TWSPLUS connections as It is not Enabled");
+ return false;
+ }
+
+ if (connDevices.size() == 0) {
+ allowSecondHfConnection = true;
+ } else {
+ BluetoothDevice connectedOrConnectingTwspDev =
+ getConnectedOrConnectingTwspDevice();
+ if (connectedOrConnectingTwspDev != null) {
+ // There is TWSP connected earbud
+ if (adapterService.isTwsPlusDevice(device)) {
+ if (adapterService.getTwsPlusPeerAddress
+ (device).equals(
+ connectedOrConnectingTwspDev.getAddress())) {
+ //Allow connection only if the outgoing
+ //is peer of TWS connected earbud
+ allowSecondHfConnection = true;
+ } else {
+ allowSecondHfConnection = false;
+ }
+ } else {
+ reservedSlotForTwspPeer = 0;
+ if (getTwsPlusConnectedPeer(
+ connectedOrConnectingTwspDev) == null) {
+ //Peer of Connected Tws+ device is not Connected
+ //yet, reserve one slot
+ reservedSlotForTwspPeer = 1;
+ }
+ if (connDevices.size() <
+ (mMaxHeadsetConnections - reservedSlotForTwspPeer)
+ && mIsTwsPlusShoEnabled) {
+ allowSecondHfConnection = true;
+ } else {
+ allowSecondHfConnection = false;
+ if (!mIsTwsPlusShoEnabled) {
+ logD("Not Allowed as TWS+ SHO is not enabled");
+ } else {
+ logD("Max Connections have reached");
+ }
+ }
+ }
+ } else {
+ //There is no TWSP connected device
+ if (adapterService.isTwsPlusDevice(device)) {
+ if (mIsTwsPlusShoEnabled) {
+ //outgoing connection is TWSP
+ if ((mMaxHeadsetConnections-connDevices.size()) >= 2) {
+ allowSecondHfConnection = true;
+ } else {
+ allowSecondHfConnection = false;
+ logD("Not enough available slots for TWSP");
+ }
+ } else {
+ allowSecondHfConnection = false;
+ }
+ } else {
+ //Outgoing connection is legacy device
+ //For legacy case use the config set by User
+ if (connDevices.size() < mSetMaxConfig) {
+ allowSecondHfConnection = true;
+ } else {
+ allowSecondHfConnection = false;
+ }
+ }
+ }
+ Log.v(TAG, "isTwsPlusDevice for " + device +
+ "is"+ adapterService.isTwsPlusDevice(device));
+ Log.v(TAG, "TWS Peer Addr: " +
+ adapterService.getTwsPlusPeerAddress(device));
+ if (connectedOrConnectingTwspDev != null) {
+ Log.v(TAG, "Connected or Connecting device"
+ + connectedOrConnectingTwspDev.getAddress());
+ } else {
+ Log.v(TAG, "No Connected TWSP devices");
+ }
+ }
+
+ Log.v(TAG, "allowSecondHfConnection: " + allowSecondHfConnection);
+ Log.v(TAG, "DisconnectAll: " + mDisconnectAll);
+ return allowSecondHfConnection;
+ }
+
public boolean connect(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH ADMIN permission");
if (getPriority(device) == BluetoothProfile.PRIORITY_OFF) {
Log.w(TAG, "connect: PRIORITY_OFF, device=" + device + ", " + Utils.getUidPidString());
return false;
}
- ParcelUuid[] featureUuids = mAdapterService.getRemoteUuids(device);
- if (!BluetoothUuid.containsAnyUuid(featureUuids, HEADSET_UUIDS)) {
- Log.e(TAG, "connect: Cannot connect to " + device + ": no headset UUID, "
- + Utils.getUidPidString());
- return false;
- }
synchronized (mStateMachines) {
+ ParcelUuid[] featureUuids = mAdapterService.getRemoteUuids(device);
+ if (!BluetoothUuid.containsAnyUuid(featureUuids, HEADSET_UUIDS)) {
+ Log.e(TAG, "connect: Cannot connect to " + device + ": no headset UUID, "
+ + Utils.getUidPidString());
+ return false;
+ }
Log.i(TAG, "connect: device=" + device + ", " + Utils.getUidPidString());
HeadsetStateMachine stateMachine = mStateMachines.get(device);
if (stateMachine == null) {
- stateMachine = HeadsetObjectsFactory.getInstance()
+ if (mStateMachinesThread != null) {
+ stateMachine = HeadsetObjectsFactory.getInstance()
.makeStateMachine(device, mStateMachinesThread.getLooper(), this,
mAdapterService, mNativeInterface, mSystemInterface);
- mStateMachines.put(device, stateMachine);
+ mStateMachines.put(device, stateMachine);
+ } else {
+ Log.w(TAG, "connect: mStateMachinesThread is null");
+ }
}
int connectionState = stateMachine.getConnectionState();
if (connectionState == BluetoothProfile.STATE_CONNECTED
@@ -707,11 +1015,23 @@
return false;
}
List<BluetoothDevice> connectingConnectedDevices =
- getDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES);
+ getAllDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES);
boolean disconnectExisting = false;
- if (connectingConnectedDevices.size() >= mMaxHeadsetConnections) {
+ mDisconnectAll = false;
+ if (connectingConnectedDevices.size() == 0) {
+ Log.e(TAG, "No Connected devices!");
+ }
+ if (!isConnectionAllowed(device, connectingConnectedDevices)) {
// When there is maximum one device, we automatically disconnect the current one
- if (mMaxHeadsetConnections == 1) {
+ if (mSetMaxConfig == 1) {
+ if (!mIsTwsPlusEnabled && mAdapterService.isTwsPlusDevice(device)) {
+ Log.w(TAG, "Connection attemp to TWS+ when not enabled, Rejecting it");
+ return false;
+ } else {
+ disconnectExisting = true;
+ }
+ } else if (mDisconnectAll) {
+ //In Dual HF case
disconnectExisting = true;
} else {
Log.w(TAG, "Max connection has reached, rejecting connection to " + device);
@@ -729,7 +1049,7 @@
return true;
}
- boolean disconnect(BluetoothDevice device) {
+ public boolean disconnect(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
Log.i(TAG, "disconnect: device=" + device + ", " + Utils.getUidPidString());
synchronized (mStateMachines) {
@@ -750,6 +1070,18 @@
return true;
}
+ public boolean isInCall() {
+ boolean isCallOngoing = mSystemInterface.isInCall();
+ Log.d(TAG," isInCall " + isCallOngoing);
+ return isCallOngoing;
+ }
+
+ public boolean isRinging() {
+ boolean isRingOngoing = mSystemInterface.isRinging();
+ Log.d(TAG," isRinging " + isRingOngoing);
+ return isRingOngoing;
+ }
+
public List<BluetoothDevice> getConnectedDevices() {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
ArrayList<BluetoothDevice> devices = new ArrayList<>();
@@ -764,6 +1096,39 @@
}
/**
+ * Helper method to get all devices with matching connection state
+ *
+ */
+ private List<BluetoothDevice> getAllDevicesMatchingConnectionStates(int[] states) {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ ArrayList<BluetoothDevice> devices = new ArrayList<>();
+ if (states == null) {
+ Log.e(TAG, "->States is null");
+ return devices;
+ }
+ synchronized (mStateMachines) {
+ final BluetoothDevice[] bondedDevices = mAdapterService.getBondedDevices();
+ if (bondedDevices == null) {
+ Log.e(TAG, "->Bonded device is null");
+ return devices;
+ }
+ for (BluetoothDevice device : bondedDevices) {
+
+ int connectionState = getConnectionState(device);
+ Log.e(TAG, "Connec state for: " + device + "is" + connectionState);
+ for (int state : states) {
+ if (connectionState == state) {
+ devices.add(device);
+ Log.e(TAG, "Adding device: " + device);
+ break;
+ }
+ }
+ }
+ }
+ return devices;
+ }
+
+ /**
* Same as the API method {@link BluetoothHeadset#getDevicesMatchingConnectionStates(int[])}
*
* @param states an array of states from {@link BluetoothProfile}
@@ -782,10 +1147,7 @@
return devices;
}
for (BluetoothDevice device : bondedDevices) {
- final ParcelUuid[] featureUuids = mAdapterService.getRemoteUuids(device);
- if (!BluetoothUuid.containsAnyUuid(featureUuids, HEADSET_UUIDS)) {
- continue;
- }
+
int connectionState = getConnectionState(device);
for (int state : states) {
if (connectionState == state) {
@@ -813,8 +1175,12 @@
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
Log.i(TAG, "setPriority: device=" + device + ", priority=" + priority + ", "
+ Utils.getUidPidString());
- mAdapterService.getDatabase()
+ AdapterService adapterService = AdapterService.getAdapterService();
+ if (adapterService != null)
+ adapterService.getDatabase()
.setProfilePriority(device, BluetoothProfile.HEADSET, priority);
+ else
+ Log.i(TAG, "adapter service is null");
return true;
}
@@ -865,15 +1231,20 @@
+ ", fall back to requesting device");
device = mVoiceRecognitionTimeoutEvent.mVoiceRecognitionDevice;
}
- mStateMachinesThread.getThreadHandler()
- .removeCallbacks(mVoiceRecognitionTimeoutEvent);
+ if (mStateMachinesThread != null) {
+ mStateMachinesThread.getThreadHandler()
+ .removeCallbacks(mVoiceRecognitionTimeoutEvent);
+ } else {
+ Log.w(TAG, "startVoiceRecognition: mStateMachinesThread is null");
+ }
mVoiceRecognitionTimeoutEvent = null;
if (mSystemInterface.getVoiceRecognitionWakeLock().isHeld()) {
mSystemInterface.getVoiceRecognitionWakeLock().release();
}
pendingRequestByHeadset = true;
}
- if (!Objects.equals(device, mActiveDevice) && !setActiveDevice(device)) {
+ if (!Objects.equals(device, mActiveDevice) &&
+ !mAdapterService.isTwsPlusDevice(device) && !setActiveDevice(device)) {
Log.w(TAG, "startVoiceRecognition: failed to set " + device + " as active");
return false;
}
@@ -895,7 +1266,10 @@
} else {
stateMachine.sendMessage(HeadsetStateMachine.VOICE_RECOGNITION_START, device);
}
- stateMachine.sendMessage(HeadsetStateMachine.CONNECT_AUDIO, device);
+ }
+ /* VR calls always use SWB if supported on remote*/
+ if(isSwbEnabled()) {
+ enableSwbCodec(true);
}
return true;
}
@@ -909,6 +1283,21 @@
+ " is not active, use active device " + mActiveDevice + " instead");
device = mActiveDevice;
}
+ if (mAdapterService.isTwsPlusDevice(device) &&
+ !isAudioConnected(device)) {
+ BluetoothDevice peerDevice = getTwsPlusConnectedPeer(device);
+ if (peerDevice != null && isAudioConnected(peerDevice)) {
+ Log.w(TAG, "startVoiceRecognition: requested TWS+ device " + device
+ + " is not audio connected, use TWS+ peer device " + peerDevice
+ + " instead");
+ device = peerDevice;
+ } else {
+ Log.w(TAG, "stopVoiceRecognition: both earbuds are not audio connected, resume A2DP");
+ mVoiceRecognitionStarted = false;
+ mHfpA2dpSyncInterface.releaseA2DP(null);
+ return false;
+ }
+ }
final HeadsetStateMachine stateMachine = mStateMachines.get(device);
if (stateMachine == null) {
Log.w(TAG, "stopVoiceRecognition: " + device + " is never connected");
@@ -926,16 +1315,35 @@
}
mVoiceRecognitionStarted = false;
stateMachine.sendMessage(HeadsetStateMachine.VOICE_RECOGNITION_STOP, device);
- stateMachine.sendMessage(HeadsetStateMachine.DISCONNECT_AUDIO, device);
+
+ if (isAudioOn()) {
+ stateMachine.sendMessage(HeadsetStateMachine.DISCONNECT_AUDIO, device);
+ } else {
+ Log.w(TAG, "SCO is not connected and VR stopped, resuming A2DP");
+ stateMachine.sendMessage(HeadsetStateMachine.RESUME_A2DP);
+ }
}
return true;
}
- boolean isAudioOn() {
+ public boolean isAudioOn() {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
- return getNonIdleAudioDevices().size() > 0;
+ int numConnectedAudioDevices = getNonIdleAudioDevices().size();
+ Log.d(TAG," isAudioOn: The number of audio connected devices "
+ + numConnectedAudioDevices);
+ return numConnectedAudioDevices > 0;
}
+ public boolean isScoOrCallActive() {
+ Log.d(TAG, "isScoOrCallActive(): Call Active:" + mSystemInterface.isInCall() +
+ "Call is Ringing:" + mSystemInterface.isInCall() +
+ "SCO is Active:" + isAudioOn());
+ if (mSystemInterface.isInCall() || (mSystemInterface.isRinging()) || isAudioOn()) {
+ return true;
+ } else {
+ return false;
+ }
+ }
boolean isAudioConnected(BluetoothDevice device) {
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
synchronized (mStateMachines) {
@@ -1067,6 +1475,9 @@
Log.w(TAG, "setActiveDevice: disconnectAudio failed on " + mActiveDevice);
}
}
+ if (!mNativeInterface.setActiveDevice(null)) {
+ Log.w(TAG, "setActiveDevice: Cannot set active device as null in native layer");
+ }
mActiveDevice = null;
broadcastActiveDevice(null);
return true;
@@ -1080,13 +1491,52 @@
+ " as active, device is not connected");
return false;
}
+ if (mActiveDevice != null && mAdapterService.isTwsPlusDevice(device) &&
+ mAdapterService.isTwsPlusDevice(mActiveDevice) &&
+ !Objects.equals(device, mActiveDevice) &&
+ getConnectionState(mActiveDevice) == BluetoothProfile.STATE_CONNECTED) {
+ Log.d(TAG,"Ignore setActiveDevice request");
+ return false;
+ }
+
if (!mNativeInterface.setActiveDevice(device)) {
Log.e(TAG, "setActiveDevice: Cannot set " + device + " as active in native layer");
return false;
}
BluetoothDevice previousActiveDevice = mActiveDevice;
mActiveDevice = device;
- if (getAudioState(previousActiveDevice) != BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
+ int audioStateOfPrevActiveDevice = BluetoothHeadset.STATE_AUDIO_DISCONNECTED;
+ boolean activeSwitchBetweenEbs = false;
+ if (previousActiveDevice != null &&
+ mAdapterService.isTwsPlusDevice(previousActiveDevice)) {
+ BluetoothDevice peerDevice =
+ getTwsPlusConnectedPeer(previousActiveDevice);
+ if (mActiveDevice != null &&
+ mAdapterService.isTwsPlusDevice(mActiveDevice)) {
+ Log.d(TAG, "Active device switch b/n ebs");
+ activeSwitchBetweenEbs = true;
+ } else {
+ if (getAudioState(previousActiveDevice) !=
+ BluetoothHeadset.STATE_AUDIO_DISCONNECTED ||
+ getAudioState(peerDevice) !=
+ BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
+ audioStateOfPrevActiveDevice =
+ BluetoothHeadset.STATE_AUDIO_CONNECTED;
+ }
+ }
+ if (audioStateOfPrevActiveDevice ==
+ BluetoothHeadset.STATE_AUDIO_CONNECTED &&
+ getAudioState(previousActiveDevice) ==
+ BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
+ Log.w(TAG, "Update previousActiveDevice with" + peerDevice);
+ previousActiveDevice = peerDevice;
+ }
+ } else {
+ audioStateOfPrevActiveDevice =
+ getAudioState(previousActiveDevice);
+ }
+ if (!activeSwitchBetweenEbs && audioStateOfPrevActiveDevice !=
+ BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
if (!disconnectAudio(previousActiveDevice)) {
Log.e(TAG, "setActiveDevice: fail to disconnectAudio from "
+ previousActiveDevice);
@@ -1096,13 +1546,16 @@
}
broadcastActiveDevice(mActiveDevice);
} else if (shouldPersistAudio()) {
- broadcastActiveDevice(mActiveDevice);
- if (!connectAudio(mActiveDevice)) {
- Log.e(TAG, "setActiveDevice: fail to connectAudio to " + mActiveDevice);
- mActiveDevice = previousActiveDevice;
- mNativeInterface.setActiveDevice(previousActiveDevice);
- return false;
+ boolean isPts = SystemProperties.getBoolean("vendor.bt.pts.certification", false);
+ if (!isPts) {
+ if (!connectAudio(mActiveDevice)) {
+ Log.e(TAG, "setActiveDevice: fail to connectAudio to " + mActiveDevice);
+ mActiveDevice = previousActiveDevice;
+ mNativeInterface.setActiveDevice(previousActiveDevice);
+ return false;
+ }
}
+ broadcastActiveDevice(mActiveDevice);
} else {
broadcastActiveDevice(mActiveDevice);
}
@@ -1156,9 +1609,12 @@
return true;
}
if (isAudioOn()) {
- Log.w(TAG, "connectAudio: audio is not idle, current audio devices are "
- + Arrays.toString(getNonIdleAudioDevices().toArray()));
- return false;
+ //SCO is connecting or connected.
+ //Return true to telephony
+ Log.w(TAG, "connectAudio: audio is not idle, current audio devices are: "
+ + Arrays.toString(getNonIdleAudioDevices().toArray()) +
+ " ,returning true");
+ return true;
}
stateMachine.sendMessage(HeadsetStateMachine.CONNECT_AUDIO, device);
}
@@ -1220,6 +1676,13 @@
}
}
+ boolean isVRStarted() {
+ enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
+ synchronized (mStateMachines) {
+ return mVoiceRecognitionStarted;
+ }
+ }
+
private boolean startScoUsingVirtualVoiceCall() {
enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission");
Log.i(TAG, "startScoUsingVirtualVoiceCall: " + Utils.getUidPidString());
@@ -1252,6 +1715,7 @@
return false;
}
mVirtualCallStarted = true;
+ mSystemInterface.getHeadsetPhoneState().setIsCsCall(false);
// Send virtual phone state changed to initialize SCO
phoneStateChanged(0, 0, HeadsetHalConstants.CALL_STATE_DIALING, "", 0, "", true);
phoneStateChanged(0, 0, HeadsetHalConstants.CALL_STATE_ALERTING, "", 0, "", true);
@@ -1299,6 +1763,23 @@
}
}
+ public boolean isTwsPlusActive(BluetoothDevice device) {
+ boolean ret = false;
+ if (mAdapterService.isTwsPlusDevice(device)) {
+ if (device.equals(getActiveDevice())) {
+ ret = true;
+ } else {
+ BluetoothDevice peerTwsDevice = mAdapterService.getTwsPlusPeerDevice(device);
+ if (peerTwsDevice != null &&
+ peerTwsDevice.equals(getActiveDevice())) {
+ ret = true;
+ }
+ }
+ }
+ Log.d(TAG, "isTwsPlusActive returns" + ret);
+ return ret;
+ }
+
/**
* Dial an outgoing call as requested by the remote device
*
@@ -1324,7 +1805,8 @@
return false;
}
}
- if (!setActiveDevice(fromDevice)) {
+ if (!isTwsPlusActive(fromDevice) &&
+ !setActiveDevice(fromDevice)) {
Log.e(TAG, "dialOutgoingCall failed to set active device to " + fromDevice);
return false;
}
@@ -1333,8 +1815,12 @@
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
mDialingOutTimeoutEvent = new DialingOutTimeoutEvent(fromDevice);
- mStateMachinesThread.getThreadHandler()
+ if (mStateMachinesThread != null) {
+ mStateMachinesThread.getThreadHandler()
.postDelayed(mDialingOutTimeoutEvent, DIALING_OUT_TIMEOUT_MS);
+ } else {
+ Log.w(TAG, "dialOutgoingCall: mStateMachinesThread is null");
+ }
return true;
}
}
@@ -1413,7 +1899,7 @@
+ ", already pending by " + mVoiceRecognitionTimeoutEvent);
return false;
}
- if (!setActiveDevice(fromDevice)) {
+ if (!isTwsPlusActive(fromDevice) && !setActiveDevice(fromDevice)) {
Log.w(TAG, "startVoiceRecognitionByHeadset: failed to set " + fromDevice
+ " as active");
return false;
@@ -1438,11 +1924,19 @@
return false;
}
mVoiceRecognitionTimeoutEvent = new VoiceRecognitionTimeoutEvent(fromDevice);
- mStateMachinesThread.getThreadHandler()
+ if (mStateMachinesThread != null) {
+ mStateMachinesThread.getThreadHandler()
.postDelayed(mVoiceRecognitionTimeoutEvent, sStartVrTimeoutMs);
+ } else {
+ Log.w(TAG, "startVoiceRecognitionByHeadset: mStateMachinesThread is null");
+ }
if (!mSystemInterface.getVoiceRecognitionWakeLock().isHeld()) {
mSystemInterface.getVoiceRecognitionWakeLock().acquire(sStartVrTimeoutMs);
}
+ /* VR calls always use SWB if supported on remote*/
+ if(isSwbEnabled()) {
+ enableSwbCodec(true);
+ }
return true;
}
}
@@ -1464,14 +1958,23 @@
if (mSystemInterface.getVoiceRecognitionWakeLock().isHeld()) {
mSystemInterface.getVoiceRecognitionWakeLock().release();
}
- mStateMachinesThread.getThreadHandler()
+ if (mStateMachinesThread != null) {
+ mStateMachinesThread.getThreadHandler()
.removeCallbacks(mVoiceRecognitionTimeoutEvent);
+ } else {
+ Log.w(TAG, "stopVoiceRecognitionByHeadset: mStateMachinesThread is null");
+ }
mVoiceRecognitionTimeoutEvent = null;
}
if (mVoiceRecognitionStarted) {
- if (!disconnectAudio()) {
- Log.w(TAG, "stopVoiceRecognitionByHeadset: failed to disconnect audio from "
+ if (isAudioOn()) {
+ if (!disconnectAudio()) {
+ Log.w(TAG, "stopVoiceRecognitionByHeadset: failed to disconnect audio from "
+ fromDevice);
+ }
+ } else {
+ Log.w(TAG, "stopVoiceRecognitionByHeadset: No SCO connected, resume A2DP");
+ mHfpA2dpSyncInterface.releaseA2DP(null);
}
mVoiceRecognitionStarted = false;
}
@@ -1487,6 +1990,10 @@
int type, String name, boolean isVirtualCall) {
enforceCallingOrSelfPermission(MODIFY_PHONE_STATE, "Need MODIFY_PHONE_STATE permission");
synchronized (mStateMachines) {
+ if (mStateMachinesThread == null) {
+ Log.w(TAG, "mStateMachinesThread is null, returning");
+ return;
+ }
// Should stop all other audio mode in this case
if ((numActive + numHeld) > 0 || callState != HeadsetHalConstants.CALL_STATE_IDLE) {
if (!isVirtualCall && mVirtualCallStarted) {
@@ -1497,6 +2004,12 @@
// stop voice recognition if there is any incoming call
stopVoiceRecognition(mActiveDevice);
}
+ } else {
+ // ignore CS non-call state update when virtual call started
+ if (!isVirtualCall && mVirtualCallStarted) {
+ Log.i(TAG, "Ignore CS non-call state update");
+ return;
+ }
}
if (mDialingOutTimeoutEvent != null) {
// Send result to state machine when dialing starts
@@ -1516,38 +2029,61 @@
}
}
}
- }
- mStateMachinesThread.getThreadHandler().post(() -> {
- boolean isCallIdleBefore = mSystemInterface.isCallIdle();
- mSystemInterface.getHeadsetPhoneState().setNumActiveCall(numActive);
- mSystemInterface.getHeadsetPhoneState().setNumHeldCall(numHeld);
- mSystemInterface.getHeadsetPhoneState().setCallState(callState);
- // Suspend A2DP when call about is about to become active
- if (callState != HeadsetHalConstants.CALL_STATE_DISCONNECTED
- && !mSystemInterface.isCallIdle() && isCallIdleBefore) {
- mSystemInterface.getAudioManager().setParameters("A2dpSuspended=true");
- }
- });
- doForEachConnectedStateMachine(
- stateMachine -> stateMachine.sendMessage(HeadsetStateMachine.CALL_STATE_CHANGED,
+ mStateMachinesThread.getThreadHandler().post(() -> {
+ mSystemInterface.getHeadsetPhoneState().setNumActiveCall(numActive);
+ mSystemInterface.getHeadsetPhoneState().setNumHeldCall(numHeld);
+ mSystemInterface.getHeadsetPhoneState().setCallState(callState);
+ });
+ List<BluetoothDevice> availableDevices =
+ getDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES);
+ if(availableDevices.size() > 0) {
+ Log.i(TAG, "Update the phoneStateChanged status to connecting and " +
+ "connected devices");
+ doForEachConnectedConnectingStateMachine(
+ stateMachine -> stateMachine.sendMessage(HeadsetStateMachine.CALL_STATE_CHANGED,
new HeadsetCallState(numActive, numHeld, callState, number, type, name)));
- mStateMachinesThread.getThreadHandler().post(() -> {
- if (callState == HeadsetHalConstants.CALL_STATE_IDLE
- && mSystemInterface.isCallIdle() && !isAudioOn()) {
- // Resume A2DP when call ended and SCO is not connected
- mSystemInterface.getAudioManager().setParameters("A2dpSuspended=false");
+ mStateMachinesThread.getThreadHandler().post(() -> {
+ if (!(mSystemInterface.isInCall() || mSystemInterface.isRinging())) {
+ Log.i(TAG, "no call, sending resume A2DP message to state machines");
+ for (BluetoothDevice device : availableDevices) {
+ HeadsetStateMachine stateMachine = mStateMachines.get(device);
+ if (stateMachine == null) {
+ Log.w(TAG, "phoneStateChanged: device " + device +
+ " was never connected/connecting");
+ continue;
+ }
+ stateMachine.sendMessage(HeadsetStateMachine.RESUME_A2DP);
+ }
+ }
+ });
+ } else {
+ mStateMachinesThread.getThreadHandler().post(() -> {
+ if (!(mSystemInterface.isInCall() || mSystemInterface.isRinging())) {
+ //If no device is connected, resume A2DP if there is no call
+ Log.i(TAG, "No device is connected and no call, " +
+ "set A2DPsuspended to false");
+ mHfpA2dpSyncInterface.releaseA2DP(null);
+ } else {
+ //if call/ ring is ongoing, suspendA2DP to true
+ Log.i(TAG, "No device is connected and call/ring is ongoing, " +
+ "set A2DPsuspended to true");
+ mHfpA2dpSyncInterface.suspendA2DP(HeadsetA2dpSync.
+ A2DP_SUSPENDED_BY_CS_CALL, null);
+ }
+ });
}
- });
-
+ }
}
private void clccResponse(int index, int direction, int status, int mode, boolean mpty,
String number, int type) {
enforceCallingOrSelfPermission(MODIFY_PHONE_STATE, "Need MODIFY_PHONE_STATE permission");
- doForEachConnectedStateMachine(
+ synchronized (mStateMachines) {
+ doForEachConnectedStateMachine(
stateMachine -> stateMachine.sendMessage(HeadsetStateMachine.SEND_CCLC_RESPONSE,
new HeadsetClccResponse(index, direction, status, mode, mpty, number,
type)));
+ }
}
private boolean sendVendorSpecificResultCode(BluetoothDevice device, String command,
@@ -1576,9 +2112,12 @@
}
boolean isInbandRingingEnabled() {
+ boolean returnVal;
enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
- return BluetoothHeadset.isInbandRingingSupported(this) && !SystemProperties.getBoolean(
- DISABLE_INBAND_RINGING_PROPERTY, false) && !mInbandRingingRuntimeDisable;
+ returnVal = BluetoothHeadset.isInbandRingingSupported(this) && !SystemProperties.getBoolean(
+ DISABLE_INBAND_RINGING_PROPERTY, true) && !mInbandRingingRuntimeDisable;
+ Log.d(TAG, "isInbandRingingEnabled returning: " + returnVal);
+ return returnVal;
}
/**
@@ -1597,7 +2136,7 @@
getDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES);
if (fromState != BluetoothProfile.STATE_CONNECTED
&& toState == BluetoothProfile.STATE_CONNECTED) {
- if (audioConnectableDevices.size() > 1) {
+ if (audioConnectableDevices.size() > 1 && isInbandRingingEnabled()) {
mInbandRingingRuntimeDisable = true;
doForEachConnectedStateMachine(
stateMachine -> stateMachine.sendMessage(HeadsetStateMachine.SEND_BSIR,
@@ -1607,17 +2146,50 @@
}
if (fromState != BluetoothProfile.STATE_DISCONNECTED
&& toState == BluetoothProfile.STATE_DISCONNECTED) {
- if (audioConnectableDevices.size() <= 1) {
+ if (audioConnectableDevices.size() <= 1 ) {
mInbandRingingRuntimeDisable = false;
- doForEachConnectedStateMachine(
+ if(isInbandRingingEnabled()) {
+ doForEachConnectedStateMachine(
stateMachine -> stateMachine.sendMessage(HeadsetStateMachine.SEND_BSIR,
- 1));
+ 1));
+ }
}
if (device.equals(mActiveDevice)) {
- setActiveDevice(null);
+ AdapterService adapterService = AdapterService.getAdapterService();
+ if (adapterService.isTwsPlusDevice(device)) {
+ //if the disconnected device is a tws+ device
+ // and if peer device is connected, set the peer
+ // as an active device
+ BluetoothDevice peerDevice = getTwsPlusConnectedPeer(device);
+ if (peerDevice != null) {
+ setActiveDevice(peerDevice);
+ }
+ } else {
+ setActiveDevice(null);
+ }
}
}
}
+
+ // if active device is null, SLC connected, make this device as active.
+ if (fromState == BluetoothProfile.STATE_CONNECTING &&
+ toState == BluetoothProfile.STATE_CONNECTED &&
+ mActiveDevice == null) {
+ Log.i(TAG, "onConnectionStateChangedFromStateMachine: SLC connected, no active"
+ + " is present. Setting active device to " + device);
+ setActiveDevice(device);
+ }
+ }
+
+ public HeadsetA2dpSync getHfpA2DPSyncInterface(){
+ return mHfpA2dpSyncInterface;
+ }
+
+ public void sendA2dpStateChangeUpdate(int state) {
+ Log.d(TAG," sendA2dpStateChange newState = " + state);
+ doForEachConnectedConnectingStateMachine(
+ stateMachine -> stateMachine.sendMessage(HeadsetStateMachine.A2DP_STATE_CHANGED,
+ state));
}
/**
@@ -1638,8 +2210,19 @@
}
private boolean shouldCallAudioBeActive() {
- return mSystemInterface.isInCall() || (mSystemInterface.isRinging()
- && isInbandRingingEnabled());
+ boolean retVal = false;
+ // When the call is active/held, the call audio must be active
+ if (mSystemInterface.getHeadsetPhoneState().getNumActiveCall() > 0 ||
+ mSystemInterface.getHeadsetPhoneState().getNumHeldCall() > 0 ) {
+ Log.d(TAG, "shouldCallAudioBeActive(): returning true, since call is active/held");
+ return true;
+ }
+ // When call is in ringing state, SCO should not be accepted if
+ // in-band ringtone is not enabled
+ retVal = (mSystemInterface.isInCall() && !mSystemInterface.isRinging() )||
+ (mSystemInterface.isRinging() && isInbandRingingEnabled());
+ Log.d(TAG, "shouldCallAudioBeActive() returning " + retVal);
+ return retVal;
}
/**
@@ -1666,34 +2249,83 @@
@VisibleForTesting
public void onAudioStateChangedFromStateMachine(BluetoothDevice device, int fromState,
int toState) {
+ Log.w(TAG, "onAudioStateChangedFromStateMachine: " + fromState + "->" + toState);
synchronized (mStateMachines) {
if (toState == BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
- if (fromState != BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
- if (mActiveDevice != null && !mActiveDevice.equals(device)
- && shouldPersistAudio()) {
- if (!connectAudio(mActiveDevice)) {
- Log.w(TAG, "onAudioStateChangedFromStateMachine, failed to connect"
- + " audio to new " + "active device " + mActiveDevice
- + ", after " + device + " is disconnected from SCO");
+ //Transfer SCO is not needed for TWS+ devices
+ if (mAdapterService != null && mAdapterService.isTwsPlusDevice(device) &&
+ mActiveDevice != null &&
+ mAdapterService.isTwsPlusDevice(mActiveDevice) &&
+ isAudioOn()) {
+ Log.w(TAG, "Sco transfer is not needed btween earbuds");
+ } else {
+ // trigger SCO after SCO disconnected with previous active
+ // device
+ Log.w(TAG, "onAudioStateChangedFromStateMachine:"
+ + "shouldPersistAudio() returns"
+ + shouldPersistAudio());
+ if (mAdapterService != null && mAdapterService.isTwsPlusDevice(device) &&
+ isAudioOn()) {
+ Log.w(TAG, "TWS: Don't stop VR or VOIP");
+ } else {
+ if (mVoiceRecognitionStarted) {
+ if (!stopVoiceRecognitionByHeadset(device)) {
+ Log.w(TAG,"onAudioStateChangedFromStateMachine:"
+ + " failed to stop voice"
+ + " recognition");
+ } else {
+ final HeadsetStateMachine stateMachine
+ = mStateMachines.get(device);
+ if (stateMachine != null) {
+ Log.d(TAG, "onAudioStateChanged" +
+ "FromStateMachine: send +bvra:0");
+ stateMachine.sendMessage(
+ HeadsetStateMachine.VOICE_RECOGNITION_STOP,
+ device);
+ }
+ }
+ }
+ if (mVirtualCallStarted) {
+ if (!stopScoUsingVirtualVoiceCall()) {
+ Log.w(TAG,"onAudioStateChangedFromStateMachine:"
+ + " failed to stop virtual "
+ + " voice call");
+ }
}
}
- }
- if (mVoiceRecognitionStarted) {
- if (!stopVoiceRecognitionByHeadset(device)) {
- Log.w(TAG, "onAudioStateChangedFromStateMachine: failed to stop voice "
- + "recognition");
+
+ if (mActiveDevice != null &&
+ !mActiveDevice.equals(device) &&
+ shouldPersistAudio()) {
+ if (mAdapterService != null && mAdapterService.isTwsPlusDevice(device)
+ && isAudioOn()) {
+ Log.d(TAG, "TWS: Wait for both eSCO closed");
+ } else {
+ if (mAdapterService != null && mAdapterService.isTwsPlusDevice(device) &&
+ isTwsPlusActive(mActiveDevice)) {
+ /* If the device for which SCO got disconnected
+ is a TwsPlus device and TWS+ set is active
+ device. This should be the case where User
+ transferred from BT to Phone Speaker from
+ Call UI*/
+ Log.d(TAG,"don't transfer SCO. It is an" +
+ "explicit voice transfer from UI");
+ return;
+ }
+ Log.d(TAG, "onAudioStateChangedFromStateMachine:"
+ + " triggering SCO with device "
+ + mActiveDevice);
+ if (!connectAudio(mActiveDevice)) {
+ Log.w(TAG, "onAudioStateChangedFromStateMachine,"
+ + " failed to connect"
+ + " audio to new " + "active device "
+ + mActiveDevice
+ + ", after " + device
+ + " is disconnected from SCO");
+ }
+ }
}
}
- if (mVirtualCallStarted) {
- if (!stopScoUsingVirtualVoiceCall()) {
- Log.w(TAG, "onAudioStateChangedFromStateMachine: failed to stop virtual "
- + "voice call");
- }
- }
- // Unsuspend A2DP when SCO connection is gone and call state is idle
- if (mSystemInterface.isCallIdle()) {
- mSystemInterface.getAudioManager().setParameters("A2dpSuspended=false");
- }
}
}
}
@@ -1717,35 +2349,37 @@
*/
public boolean okToAcceptConnection(BluetoothDevice device) {
// Check if this is an incoming connection in Quiet mode.
+ boolean isPts = SystemProperties.getBoolean("vendor.bt.pts.certification", false);
if (mAdapterService.isQuietModeEnabled()) {
Log.w(TAG, "okToAcceptConnection: return false as quiet mode enabled");
return false;
}
- // Check priority and accept or reject the connection.
- int priority = getPriority(device);
- int bondState = mAdapterService.getBondState(device);
- // Allow this connection only if the device is bonded. Any attempt to connect while
- // bonding would potentially lead to an unauthorized connection.
- if (bondState != BluetoothDevice.BOND_BONDED) {
- Log.w(TAG, "okToAcceptConnection: return false, bondState=" + bondState);
- return false;
- } else if (priority != BluetoothProfile.PRIORITY_UNDEFINED
- && priority != BluetoothProfile.PRIORITY_ON
- && priority != BluetoothProfile.PRIORITY_AUTO_CONNECT) {
- // Otherwise, reject the connection if priority is not valid.
- Log.w(TAG, "okToAcceptConnection: return false, priority=" + priority);
- return false;
+ if(!isPts) {
+ // Check priority and accept or reject the connection.
+ int priority = getPriority(device);
+ int bondState = mAdapterService.getBondState(device);
+ // Allow this connection only if the device is bonded. Any attempt to connect while
+ // bonding would potentially lead to an unauthorized connection.
+ if (bondState != BluetoothDevice.BOND_BONDED) {
+ Log.w(TAG, "okToAcceptConnection: return false, bondState=" + bondState);
+ return false;
+ } else if (priority != BluetoothProfile.PRIORITY_UNDEFINED
+ && priority != BluetoothProfile.PRIORITY_ON
+ && priority != BluetoothProfile.PRIORITY_AUTO_CONNECT) {
+ // Otherwise, reject the connection if priority is not valid.
+ Log.w(TAG, "okToAcceptConnection: return false, priority=" + priority);
+ return false;
+ }
}
List<BluetoothDevice> connectingConnectedDevices =
- getDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES);
- if (connectingConnectedDevices.size() >= mMaxHeadsetConnections) {
- Log.w(TAG, "Maximum number of connections " + mMaxHeadsetConnections
+ getAllDevicesMatchingConnectionStates(CONNECTING_CONNECTED_STATES);
+ if (!isConnectionAllowed(device, connectingConnectedDevices)) {
+ Log.w(TAG, "Maximum number of connections " + mSetMaxConfig
+ " was reached, rejecting connection from " + device);
return false;
}
return true;
}
-
/**
* Checks if SCO should be connected at current system state
*
@@ -1754,10 +2388,13 @@
*/
public boolean isScoAcceptable(BluetoothDevice device) {
synchronized (mStateMachines) {
- if (device == null || !device.equals(mActiveDevice)) {
- Log.w(TAG, "isScoAcceptable: rejected SCO since " + device
+ //allow 2nd eSCO from non-active tws+ earbud as well
+ if (!mAdapterService.isTwsPlusDevice(device)) {
+ if (device == null || !device.equals(mActiveDevice)) {
+ Log.w(TAG, "isScoAcceptable: rejected SCO since " + device
+ " is not the current active device " + mActiveDevice);
- return false;
+ return false;
+ }
}
if (mForceScoAudio) {
return true;
@@ -1766,6 +2403,15 @@
Log.w(TAG, "isScoAcceptable: rejected SCO since audio route is not allowed");
return false;
}
+ /* if in-band ringtone is not enabled and if there is
+ no active/held/dialling/alerting call, return false */
+ if (isRinging() && !isInbandRingingEnabled() &&
+ !(mSystemInterface.getHeadsetPhoneState().getNumActiveCall() > 0 ||
+ mSystemInterface.getHeadsetPhoneState().getNumHeldCall() > 0 )) {
+ Log.w(TAG, "isScoAcceptable: rejected SCO since MT call in ringing," +
+ "in-band ringing not enabled");
+ return false;
+ }
if (mVoiceRecognitionStarted || mVirtualCallStarted) {
return true;
}
@@ -1839,6 +2485,25 @@
}
}
+ public void enableSwbCodec(boolean enable) {
+ mVendorHf.enableSwb(enable);
+ }
+
+ public boolean isSwbEnabled() {
+ if(mAdapterService.isSWBVoicewithAptxAdaptiveAG()) {
+ return mAdapterService.isSwbEnabled();
+ }
+ return false;
+ }
+
+ public boolean isSwbPmEnabled() {
+ if(mAdapterService.isSWBVoicewithAptxAdaptiveAG() &&
+ mAdapterService.isSwbEnabled()) {
+ return mAdapterService.isSwbPmEnabled();
+ }
+ return false;
+ }
+
private static void logD(String message) {
if (DBG) {
Log.d(TAG, message);
diff --git a/src/com/android/bluetooth/hfp/HeadsetStackEvent.java b/src/com/android/bluetooth/hfp/HeadsetStackEvent.java
index 328ac08..1bd5ae4 100644
--- a/src/com/android/bluetooth/hfp/HeadsetStackEvent.java
+++ b/src/com/android/bluetooth/hfp/HeadsetStackEvent.java
@@ -45,6 +45,8 @@
public static final int EVENT_TYPE_BIND = 18;
public static final int EVENT_TYPE_BIEV = 19;
public static final int EVENT_TYPE_BIA = 20;
+ public static final int EVENT_TYPE_SWB = 21;
+ public static final int EVENT_TYPE_TWSP_BATTERY_STATE = 22;
public final int type;
public final int valueInt;
@@ -177,6 +179,10 @@
return "EVENT_TYPE_BIEV";
case EVENT_TYPE_BIA:
return "EVENT_TYPE_BIA";
+ case EVENT_TYPE_SWB:
+ return "EVENT_TYPE_SWB";
+ case EVENT_TYPE_TWSP_BATTERY_STATE:
+ return "EVENT_TYPE_TWSP_BATTERY_STATE";
default:
return "UNKNOWN";
}
diff --git a/src/com/android/bluetooth/hfp/HeadsetStateMachine.java b/src/com/android/bluetooth/hfp/HeadsetStateMachine.java
index e92688f..9c0e9db 100644
--- a/src/com/android/bluetooth/hfp/HeadsetStateMachine.java
+++ b/src/com/android/bluetooth/hfp/HeadsetStateMachine.java
@@ -28,12 +28,20 @@
import android.os.Looper;
import android.os.Message;
import android.os.SystemClock;
+import android.os.SystemProperties;
import android.os.UserHandle;
import android.telephony.PhoneNumberUtils;
import android.telephony.PhoneStateListener;
import android.text.TextUtils;
import android.util.Log;
+import android.os.SystemProperties;
+import android.net.ConnectivityManager;
+import android.net.NetworkCapabilities;
+import android.net.ConnectivityManager.NetworkCallback;
+import android.net.NetworkInfo;
+import android.net.Network;
import android.util.StatsLog;
+import android.os.Build;
import com.android.bluetooth.btservice.AdapterService;
import com.android.bluetooth.btservice.ProfileService;
@@ -46,9 +54,13 @@
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
+import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.Scanner;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.Iterator;
+import android.telecom.TelecomManager;
/**
* A Bluetooth Handset StateMachine
@@ -73,11 +85,15 @@
@VisibleForTesting
public class HeadsetStateMachine extends StateMachine {
private static final String TAG = "HeadsetStateMachine";
- private static final boolean DBG = false;
+ private static final boolean DBG = true;
+ // TODO(b/122040733) variable created as a placeholder to make build green after merge conflict; re-address
+ private static final String MERGE_PLACEHOLDER = "";
private static final String HEADSET_NAME = "bt_headset_name";
private static final String HEADSET_NREC = "bt_headset_nrec";
private static final String HEADSET_WBS = "bt_wbs";
+ private static final String HEADSET_SWB = "bt_swb";
+ private static final String HEADSET_SWB_DISABLE = "65535";
private static final String HEADSET_AUDIO_FEATURE_ON = "on";
private static final String HEADSET_AUDIO_FEATURE_OFF = "off";
@@ -87,6 +103,7 @@
static final int DISCONNECT_AUDIO = 4;
static final int VOICE_RECOGNITION_START = 5;
static final int VOICE_RECOGNITION_STOP = 6;
+ static final int HEADSET_SWB_MAX_CODEC_IDS = 8;
// message.obj is an intent AudioManager.VOLUME_CHANGED_ACTION
// EXTRA_VOLUME_STREAM_TYPE is STREAM_BLUETOOTH_SCO
@@ -100,20 +117,80 @@
static final int DIALING_OUT_RESULT = 14;
static final int VOICE_RECOGNITION_RESULT = 15;
+ static final int QUERY_PHONE_STATE_AT_SLC = 18;
+ static final int SEND_INCOMING_CALL_IND = 19;
+ static final int VOIP_CALL_STATE_CHANGED_ALERTING = 20;
+ static final int VOIP_CALL_STATE_CHANGED_ACTIVE = 21;
+ static final int CS_CALL_STATE_CHANGED_ALERTING = 22;
+ static final int CS_CALL_STATE_CHANGED_ACTIVE = 23;
+ static final int A2DP_STATE_CHANGED = 24;
+ static final int UPDATE_CALL_TYPE = 25;
+ static final int RESUME_A2DP = 26;
+
static final int STACK_EVENT = 101;
private static final int CLCC_RSP_TIMEOUT = 104;
+ private static final int PROCESS_CPBR = 105;
private static final int CONNECT_TIMEOUT = 201;
private static final int CLCC_RSP_TIMEOUT_MS = 5000;
+ private static final int QUERY_PHONE_STATE_CHANGED_DELAYED = 100;
// NOTE: the value is not "final" - it is modified in the unit tests
@VisibleForTesting static int sConnectTimeoutMs = 30000;
private static final HeadsetAgIndicatorEnableState DEFAULT_AG_INDICATOR_ENABLE_STATE =
new HeadsetAgIndicatorEnableState(true, true, true, true);
+ // delay call indicators and some remote devices are not able to handle
+ // indicators back to back, especially in VOIP scenarios.
+ /* Delay between call dialling, alerting updates for VOIP call */
+ private static final int VOIP_CALL_ALERTING_DELAY_TIME_MSEC = 800;
+ /* Delay between call alerting, active updates for VOIP call */
+ private static final int VOIP_CALL_ACTIVE_DELAY_TIME_MSEC =
+ VOIP_CALL_ALERTING_DELAY_TIME_MSEC + 50;
+ private int CS_CALL_ALERTING_DELAY_TIME_MSEC = 800;
+ private int CS_CALL_ACTIVE_DELAY_TIME_MSEC = 10;
+ private static final int INCOMING_CALL_IND_DELAY = 200;
+ private static final int MAX_RETRY_CONNECT_COUNT = 2;
+ // Blacklist remote device addresses to send incoimg call indicators with delay of 200ms
+ private static final String [] BlacklistDeviceAddrToDelayCallInd =
+ {"00:15:83", /* Beiqi Carkit */
+ "2a:eb:00", /* BIAC Carkit */
+ "30:53:00", /* BIAC series */
+ "00:17:53", /* ADAYO Carkit */
+ "40:ef:4c", /* Road Rover Carkit */
+ "00:07:04", /* Tiguan RNS315 */
+ };
+ private static final String [] BlacklistDeviceForSendingVOIPCallIndsBackToBack =
+ {"f4:15:fd"}; /* Rongwei 360 Car */
+ private static final String VOIP_CALL_NUMBER = "10000000";
+
+ //VR app launched successfully
+ private static final int VR_SUCCESS = 1;
+
+ //VR app failed to launch
+ private static final int VR_FAILURE = 0;
+
private final BluetoothDevice mDevice;
+ // maintain call states in state machine as well
+ private final HeadsetCallState mStateMachineCallState =
+ new HeadsetCallState(0, 0, 0, "", 0, "");
+
+ private NetworkCallback mDefaultNetworkCallback = new NetworkCallback() {
+ @Override
+ public void onAvailable(Network network) {
+ mIsAvailable = true;
+ Log.d(TAG, "The current Network: "+network+" is avialable: "+mIsAvailable);
+ }
+ @Override
+ public void onLost(Network network) {
+ mIsAvailable = false;
+ Log.d(TAG, "The current Network:"+network+" is lost, mIsAvailable: "
+ +mIsAvailable);
+ }
+ };
+
// State machine states
private final Disconnected mDisconnected = new Disconnected();
private final Connecting mConnecting = new Connecting();
@@ -123,18 +200,37 @@
private final AudioConnecting mAudioConnecting = new AudioConnecting();
private final AudioDisconnecting mAudioDisconnecting = new AudioDisconnecting();
private HeadsetStateBase mPrevState;
+ private HeadsetStateBase mCurrentState;
+
+ // used for synchronizing mCurrentState set/get
+ private final Object mLock = new Object();
// Run time dependencies
private final HeadsetService mHeadsetService;
private final AdapterService mAdapterService;
private final HeadsetNativeInterface mNativeInterface;
private final HeadsetSystemInterface mSystemInterface;
+ private ConnectivityManager mConnectivityManager;
// Runtime states
private int mSpeakerVolume;
private int mMicVolume;
private boolean mDeviceSilenced;
private HeadsetAgIndicatorEnableState mAgIndicatorEnableState;
+ private boolean mA2dpSuspend;
+ private boolean mIsCsCall = true;
+ private boolean mPendingScoForVR = false;
+ private boolean mIsCallIndDelay = false;
+ private boolean mIsBlacklistedDevice = false;
+ private int retryConnectCount = 0;
+
+ private static boolean mIsAvailable = false;
+
+ //ConcurrentLinkeQueue is used so that it is threadsafe
+ private ConcurrentLinkedQueue<HeadsetCallState> mPendingCallStates =
+ new ConcurrentLinkedQueue<HeadsetCallState>();
+ private ConcurrentLinkedQueue<HeadsetCallState> mDelayedCSCallStates =
+ new ConcurrentLinkedQueue<HeadsetCallState>();
// The timestamp when the device entered connecting/connected state
private long mConnectingTimestampMs = Long.MIN_VALUE;
// Audio Parameters like NREC
@@ -144,9 +240,19 @@
// HSP specific
private boolean mNeedDialingOutReply;
+ // Hash for storing the A2DP connection states
+ private HashMap<BluetoothDevice, Integer> mA2dpConnState =
+ new HashMap<BluetoothDevice, Integer>();
+ // Hash for storing the A2DP play states
+ private HashMap<BluetoothDevice, Integer> mA2dpPlayState =
+ new HashMap<BluetoothDevice, Integer>();
+
// Keys are AT commands, and values are the company IDs.
private static final Map<String, Integer> VENDOR_SPECIFIC_AT_COMMAND_COMPANY_ID;
+ /* Retry outgoing connection after this time if the first attempt fails */
+ private static final int RETRY_CONNECT_TIME_SEC = 2500;
+
static {
VENDOR_SPECIFIC_AT_COMMAND_COMPANY_ID = new HashMap<>();
VENDOR_SPECIFIC_AT_COMMAND_COMPANY_ID.put(
@@ -179,6 +285,8 @@
mDeviceSilenced = false;
// Create phonebook helper
mPhonebook = new AtPhonebook(mHeadsetService, mNativeInterface);
+ mConnectivityManager = (ConnectivityManager)
+ mHeadsetService.getSystemService(mHeadsetService.CONNECTIVITY_SERVICE);
// Initialize state machine
addState(mDisconnected);
addState(mConnecting);
@@ -188,6 +296,17 @@
addState(mAudioConnecting);
addState(mAudioDisconnecting);
setInitialState(mDisconnected);
+
+ if (isDeviceBlacklistedForSendingCallIndsBackToBack()) {
+ CS_CALL_ALERTING_DELAY_TIME_MSEC = 0;
+ CS_CALL_ACTIVE_DELAY_TIME_MSEC = 0;
+ Log.w(TAG, "alerting delay " + CS_CALL_ALERTING_DELAY_TIME_MSEC +
+ " active delay " + CS_CALL_ACTIVE_DELAY_TIME_MSEC);
+ }
+
+
+ mConnectivityManager.registerDefaultNetworkCallback(mDefaultNetworkCallback);
+ Log.i(TAG," Exiting HeadsetStateMachine constructor for device :" + device);
}
static HeadsetStateMachine make(BluetoothDevice device, Looper looper,
@@ -196,6 +315,7 @@
HeadsetStateMachine stateMachine =
new HeadsetStateMachine(device, looper, headsetService, adapterService,
nativeInterface, systemInterface);
+ Log.i(TAG," Starting StateMachine device: " + device);
stateMachine.start();
Log.i(TAG, "Created state machine " + stateMachine + " for " + device);
return stateMachine;
@@ -207,20 +327,40 @@
Log.w(TAG, "destroy(), stateMachine is null");
return;
}
- stateMachine.quitNow();
stateMachine.cleanup();
+ stateMachine.quitNow();
}
public void cleanup() {
+ Log.i(TAG," destroy, current state " + getCurrentHeadsetStateMachineState());
+ if (getCurrentHeadsetStateMachineState() == mAudioOn) {
+ mAudioOn.broadcastAudioState(mDevice, BluetoothHeadset.STATE_AUDIO_CONNECTED,
+ BluetoothHeadset.STATE_AUDIO_DISCONNECTED);
+ mAudioOn.broadcastConnectionState(mDevice, BluetoothProfile.STATE_CONNECTED,
+ BluetoothProfile.STATE_DISCONNECTED);
+ }
+ if(getCurrentHeadsetStateMachineState() == mConnected){
+ mConnected.broadcastConnectionState(mDevice, BluetoothProfile.STATE_CONNECTED,
+ BluetoothProfile.STATE_DISCONNECTED);
+ }
+ if(getCurrentHeadsetStateMachineState() == mConnecting){
+ mConnecting.broadcastConnectionState(mDevice, BluetoothProfile.STATE_CONNECTING,
+ BluetoothProfile.STATE_DISCONNECTED);
+ }
if (mPhonebook != null) {
mPhonebook.cleanup();
}
+ if (getAudioState() == BluetoothHeadset.STATE_AUDIO_CONNECTED &&
+ !mSystemInterface.getHeadsetPhoneState().getIsCsCall()) {
+ sendVoipConnectivityNetworktype(false);
+ }
+ mConnectivityManager.unregisterNetworkCallback(mDefaultNetworkCallback);
mAudioParams.clear();
}
public void dump(StringBuilder sb) {
ProfileService.println(sb, " mCurrentDevice: " + mDevice);
- ProfileService.println(sb, " mCurrentState: " + getCurrentState());
+ ProfileService.println(sb, " mCurrentState: " + mCurrentState);
ProfileService.println(sb, " mPrevState: " + mPrevState);
ProfileService.println(sb, " mConnectionState: " + getConnectionState());
ProfileService.println(sb, " mAudioState: " + getAudioState());
@@ -256,6 +396,11 @@
throw new IllegalStateException("mPrevState is null on enter()");
}
enforceValidConnectionStateTransition();
+
+ synchronized(mLock) {
+ mCurrentState = this;
+ Log.e(TAG, "Setting mCurrentState as " + mCurrentState);
+ }
}
@Override
@@ -424,6 +569,13 @@
}
+ public HeadsetStateBase getCurrentHeadsetStateMachineState() {
+ synchronized(mLock) {
+ Log.e(TAG, "returning mCurrentState as " + mCurrentState);
+ return mCurrentState;
+ }
+ }
+
class Disconnected extends HeadsetStateBase {
@Override
int getConnectionStateInt() {
@@ -443,12 +595,21 @@
updateAgIndicatorEnableState(null);
mNeedDialingOutReply = false;
mAudioParams.clear();
+
+ // reset call information
+ mStateMachineCallState.mNumActive = 0;
+ mStateMachineCallState.mNumHeld = 0;
+ mStateMachineCallState.mCallState = 0;
+ mStateMachineCallState.mNumber = "";
+ mStateMachineCallState.mType = 0;
+
broadcastStateTransitions();
// Remove the state machine for unbonded devices
if (mPrevState != null
&& mAdapterService.getBondState(mDevice) == BluetoothDevice.BOND_NONE) {
getHandler().post(() -> mHeadsetService.removeStateMachine(mDevice));
}
+ mIsBlacklistedDevice = false;
}
@Override
@@ -462,6 +623,13 @@
"CONNECT failed, device=" + device + ", currentDevice=" + mDevice);
break;
}
+
+ stateLogD(" retryConnectCount = " + retryConnectCount);
+ if (retryConnectCount >= MAX_RETRY_CONNECT_COUNT) {
+ // max attempts reached, reset it to 0
+ retryConnectCount = 0;
+ break;
+ }
if (!mNativeInterface.connectHfp(device)) {
stateLogE("CONNECT failed for connectHfp(" + device + ")");
// No state transition is involved, fire broadcast immediately
@@ -469,6 +637,7 @@
BluetoothProfile.STATE_DISCONNECTED);
break;
}
+ retryConnectCount++;
transitionTo(mConnecting);
break;
case DISCONNECT:
@@ -480,6 +649,10 @@
case DEVICE_STATE_CHANGED:
stateLogD("Ignoring DEVICE_STATE_CHANGED event");
break;
+ case UPDATE_CALL_TYPE:
+ stateLogD("UPDATE_CALL_TYPE event");
+ processIntentUpdateCallType((Intent) message.obj);
+ break;
case STACK_EVENT:
HeadsetStackEvent event = (HeadsetStackEvent) message.obj;
stateLogD("STACK_EVENT: " + event);
@@ -559,6 +732,19 @@
super.enter();
mConnectingTimestampMs = SystemClock.uptimeMillis();
sendMessageDelayed(CONNECT_TIMEOUT, mDevice, sConnectTimeoutMs);
+ mSystemInterface.queryPhoneState();
+ // update call states in StateMachine
+ mStateMachineCallState.mNumActive =
+ mSystemInterface.getHeadsetPhoneState().getNumActiveCall();
+ mStateMachineCallState.mNumHeld =
+ mSystemInterface.getHeadsetPhoneState().getNumHeldCall();
+ mStateMachineCallState.mCallState =
+ mSystemInterface.getHeadsetPhoneState().getCallState();
+ mStateMachineCallState.mNumber =
+ mSystemInterface.getHeadsetPhoneState().getNumber();
+ mStateMachineCallState.mType =
+ mSystemInterface.getHeadsetPhoneState().getType();
+
broadcastStateTransitions();
}
@@ -581,12 +767,35 @@
transitionTo(mDisconnected);
break;
}
- case CALL_STATE_CHANGED:
- stateLogD("ignoring CALL_STATE_CHANGED event");
- break;
case DEVICE_STATE_CHANGED:
stateLogD("ignoring DEVICE_STATE_CHANGED event");
break;
+ case A2DP_STATE_CHANGED:
+ stateLogD("A2DP_STATE_CHANGED event");
+ processIntentA2dpPlayStateChanged(message.arg1);
+ break;
+ case CALL_STATE_CHANGED: {
+ HeadsetCallState callState = (HeadsetCallState) message.obj;
+ processCallState(callState, false);
+ break;
+ }
+ case UPDATE_CALL_TYPE:
+ stateLogD("UPDATE_CALL_TYPE event");
+ processIntentUpdateCallType((Intent) message.obj);
+ break;
+ case RESUME_A2DP: {
+ /* If the call started/ended by the time A2DP suspend ack
+ * is received, send the call indicators before resuming
+ * A2DP.
+ */
+ if (mPendingCallStates.size() == 0) {
+ stateLogD("RESUME_A2DP evt, resuming A2DP");
+ mHeadsetService.getHfpA2DPSyncInterface().releaseA2DP(mDevice);
+ } else {
+ stateLogW("RESUME_A2DP evt, pending call states to be sent, not resuming");
+ }
+ break;
+ }
case STACK_EVENT:
HeadsetStackEvent event = (HeadsetStackEvent) message.obj;
stateLogD("STACK_EVENT: " + event);
@@ -608,6 +817,10 @@
case HeadsetStackEvent.EVENT_TYPE_BIND:
processAtBind(event.valueString, event.device);
break;
+ case HeadsetStackEvent.EVENT_TYPE_TWSP_BATTERY_STATE:
+ processTwsBatteryState(event.valueString,
+ event.device);
+ break;
// Unexpected AT commands, we only handle them for comparability reasons
case HeadsetStackEvent.EVENT_TYPE_VR_STATE_CHANGED:
stateLogW("Unexpected VR event, device=" + event.device + ", state="
@@ -628,8 +841,7 @@
processAtCops(event.device);
break;
case HeadsetStackEvent.EVENT_TYPE_AT_CLCC:
- Log.w(TAG, "Connecting: Unexpected CLCC event for" + event.device);
- processAtClcc(event.device);
+ stateLogW("Connecting: Unexpected CLCC event for" + event.device);
break;
case HeadsetStackEvent.EVENT_TYPE_UNKNOWN_AT:
stateLogW("Unexpected unknown AT event for" + event.device + ", cmd="
@@ -657,6 +869,9 @@
stateLogW("Unexpected hangup event for " + event.device);
mSystemInterface.hangupCall(event.device);
break;
+ case HeadsetStackEvent.EVENT_TYPE_SWB:
+ processSWBEvent(event.valueInt);
+ break;
default:
stateLogE("Unexpected event: " + event);
break;
@@ -675,6 +890,17 @@
switch (state) {
case HeadsetHalConstants.CONNECTION_STATE_DISCONNECTED:
stateLogW("Disconnected");
+ processWBSEvent(HeadsetHalConstants.BTHF_WBS_NO);
+ stateLogD(" retryConnectCount = " + retryConnectCount);
+ if(retryConnectCount == 1 && !hasDeferredMessages(DISCONNECT)) {
+ Log.d(TAG,"No deferred Disconnect, retry once more ");
+ sendMessageDelayed(CONNECT, mDevice, RETRY_CONNECT_TIME_SEC);
+ } else if (retryConnectCount >= MAX_RETRY_CONNECT_COUNT ||
+ hasDeferredMessages(DISCONNECT)) {
+ // we already tried twice.
+ Log.d(TAG,"Already tried twice or has deferred Disconnect");
+ retryConnectCount = 0;
+ }
transitionTo(mDisconnected);
break;
case HeadsetHalConstants.CONNECTION_STATE_CONNECTED:
@@ -682,6 +908,7 @@
break;
case HeadsetHalConstants.CONNECTION_STATE_SLC_CONNECTED:
stateLogD("SLC connected");
+ retryConnectCount = 0;
transitionTo(mConnected);
break;
case HeadsetHalConstants.CONNECTION_STATE_CONNECTING:
@@ -825,6 +1052,15 @@
stateLogW("Failed to start voice recognition");
break;
}
+
+ if (mHeadsetService.getHfpA2DPSyncInterface().suspendA2DP(
+ HeadsetA2dpSync.A2DP_SUSPENDED_BY_VR, mDevice) == true) {
+ Log.d(TAG, "mesg VOICE_RECOGNITION_START: A2DP is playing,"+
+ " return and establish SCO after A2DP supended");
+ break;
+ }
+ // create SCO since there is no A2DP playback
+ mNativeInterface.connectAudio(mDevice);
break;
}
case VOICE_RECOGNITION_STOP: {
@@ -841,13 +1077,64 @@
break;
}
case CALL_STATE_CHANGED: {
+ boolean isPts = SystemProperties.getBoolean("vendor.bt.pts.certification", false);
+
HeadsetCallState callState = (HeadsetCallState) message.obj;
- if (!mNativeInterface.phoneStateChange(mDevice, callState)) {
- stateLogW("processCallState: failed to update call state " + callState);
- break;
+ // for PTS, send the indicators as is
+ if (isPts) {
+ if (!mNativeInterface.phoneStateChange(mDevice, callState)) {
+ stateLogW("processCallState: failed to update call state " + callState);
+ break;
+ }
+ }
+ else
+ processCallStatesDelayed(callState, false);
+ break;
+ }
+ case CS_CALL_STATE_CHANGED_ALERTING: {
+ // get the top of the Q
+ HeadsetCallState tempCallState = mDelayedCSCallStates.peek();
+ // top of the queue is call alerting
+ if(tempCallState != null &&
+ tempCallState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING)
+ {
+ stateLogD("alerting message timer expired, send alerting update");
+ //dequeue the alerting call state;
+ mDelayedCSCallStates.poll();
+ processCallState(tempCallState, false);
+ }
+
+ // top of the queue == call active
+ tempCallState = mDelayedCSCallStates.peek();
+ if (tempCallState != null &&
+ tempCallState.mCallState == HeadsetHalConstants.CALL_STATE_IDLE)
+ {
+ stateLogD("alerting message timer expired, send delayed active mesg");
+ //send delayed message for call active;
+ Message msg = obtainMessage(CS_CALL_STATE_CHANGED_ACTIVE);
+ msg.arg1 = 0;
+ sendMessageDelayed(msg, CS_CALL_ACTIVE_DELAY_TIME_MSEC);
}
break;
}
+ case CS_CALL_STATE_CHANGED_ACTIVE: {
+ // get the top of the Q
+ // top of the queue == call active
+ HeadsetCallState tempCallState = mDelayedCSCallStates.peek();
+ if (tempCallState != null &&
+ tempCallState.mCallState == HeadsetHalConstants.CALL_STATE_IDLE)
+ {
+ stateLogD("active message timer expired, send active update");
+ //dequeue the active call state;
+ mDelayedCSCallStates.poll();
+ processCallState(tempCallState, false);
+ }
+ }
+ break;
+ case A2DP_STATE_CHANGED:
+ stateLogD("A2DP_STATE_CHANGED event");
+ processIntentA2dpPlayStateChanged(message.arg1);
+ break;
case DEVICE_STATE_CHANGED:
mNativeInterface.notifyDeviceStatus(mDevice, (HeadsetDeviceState) message.obj);
break;
@@ -878,8 +1165,22 @@
break;
}
mNativeInterface.atResponseCode(mDevice,
- message.arg1 == 1 ? HeadsetHalConstants.AT_RESPONSE_OK
+ message.arg1 == VR_SUCCESS ? HeadsetHalConstants.AT_RESPONSE_OK
: HeadsetHalConstants.AT_RESPONSE_ERROR, 0);
+ if (message.arg1 != VR_SUCCESS) {
+ Log.d(TAG, "VOICE_RECOGNITION_RESULT: not creating SCO since VR app"+
+ " failed to start VR");
+ break;
+ }
+
+ if (mHeadsetService.getHfpA2DPSyncInterface().suspendA2DP(
+ HeadsetA2dpSync.A2DP_SUSPENDED_BY_VR, mDevice) == true) {
+ Log.d(TAG, "mesg VOICE_RECOGNITION_START: A2DP is playing,"+
+ " return and establish SCO after A2DP supended");
+ break;
+ }
+ // create SCO since there is no A2DP playback
+ mNativeInterface.connectAudio(mDevice);
break;
}
case DIALING_OUT_RESULT: {
@@ -899,6 +1200,26 @@
case INTENT_CONNECTION_ACCESS_REPLY:
handleAccessPermissionResult((Intent) message.obj);
break;
+ case PROCESS_CPBR:
+ Intent intent = (Intent) message.obj;
+ processCpbr(intent);
+ break;
+ case SEND_INCOMING_CALL_IND:
+ HeadsetCallState callState =
+ new HeadsetCallState(0, 0, HeadsetHalConstants.CALL_STATE_INCOMING,
+ mSystemInterface.getHeadsetPhoneState().getNumber(),
+ mSystemInterface.getHeadsetPhoneState().getType(),
+ MERGE_PLACEHOLDER);
+ mNativeInterface.phoneStateChange(mDevice, callState);
+ break;
+ case QUERY_PHONE_STATE_AT_SLC:
+ stateLogD("Update call states after SLC is up");
+ mSystemInterface.queryPhoneState();
+ break;
+ case UPDATE_CALL_TYPE:
+ stateLogD("UPDATE_CALL_TYPE event");
+ processIntentUpdateCallType((Intent) message.obj);
+ break;
case STACK_EVENT:
HeadsetStackEvent event = (HeadsetStackEvent) message.obj;
stateLogD("STACK_EVENT: " + event);
@@ -962,6 +1283,10 @@
case HeadsetStackEvent.EVENT_TYPE_BIND:
processAtBind(event.valueString, event.device);
break;
+ case HeadsetStackEvent.EVENT_TYPE_TWSP_BATTERY_STATE:
+ processTwsBatteryState(event.valueString,
+ event.device);
+ break;
case HeadsetStackEvent.EVENT_TYPE_BIEV:
processAtBiev(event.valueInt, event.valueInt2, event.device);
break;
@@ -969,6 +1294,9 @@
updateAgIndicatorEnableState(
(HeadsetAgIndicatorEnableState) event.valueObject);
break;
+ case HeadsetStackEvent.EVENT_TYPE_SWB:
+ processSWBEvent(event.valueInt);
+ break;
default:
stateLogE("Unknown stack event: " + event);
break;
@@ -990,6 +1318,7 @@
break;
case HeadsetHalConstants.CONNECTION_STATE_SLC_CONNECTED:
stateLogE("processConnectionEvent: SLC connected again, shouldn't happen");
+ retryConnectCount = 0;
break;
case HeadsetHalConstants.CONNECTION_STATE_DISCONNECTING:
stateLogI("processConnectionEvent: Disconnecting");
@@ -997,6 +1326,7 @@
break;
case HeadsetHalConstants.CONNECTION_STATE_DISCONNECTED:
stateLogI("processConnectionEvent: Disconnected");
+ processWBSEvent(HeadsetHalConstants.BTHF_WBS_NO);
transitionTo(mDisconnected);
break;
default:
@@ -1028,12 +1358,28 @@
// Reset NREC on connect event. Headset will override later
processNoiseReductionEvent(true);
// Query phone state for initial setup
- mSystemInterface.queryPhoneState();
+ sendMessageDelayed(QUERY_PHONE_STATE_AT_SLC, QUERY_PHONE_STATE_CHANGED_DELAYED);
+ // Checking for the Blacklisted device Addresses
+ mIsBlacklistedDevice = isConnectedDeviceBlacklistedforIncomingCall();
+ if (mSystemInterface.isInCall() || mSystemInterface.isRinging()) {
+ stateLogW("Connected: enter: suspending A2DP for Call since SLC connected");
+ // suspend A2DP since call is there
+ mHeadsetService.getHfpA2DPSyncInterface().suspendA2DP(
+ HeadsetA2dpSync.A2DP_SUSPENDED_BY_CS_CALL, mDevice);
+ }
// Remove pending connection attempts that were deferred during the pending
// state. This is to prevent auto connect attempts from disconnecting
// devices that previously successfully connected.
removeDeferredMessages(CONNECT);
}
+ if ((mPrevState == mAudioOn) || (mPrevState == mAudioDisconnecting)||
+ (mPrevState == mAudioConnecting)) {
+ if (!(mSystemInterface.isInCall() || mSystemInterface.isRinging())) {
+ // SCO disconnected, resume A2DP if there is no call
+ stateLogD("SCO disconnected, set A2DPsuspended to false");
+ mHeadsetService.getHfpA2DPSyncInterface().releaseA2DP(mDevice);
+ }
+ }
broadcastStateTransitions();
}
@@ -1064,9 +1410,25 @@
break;
case CONNECT_AUDIO:
stateLogD("CONNECT_AUDIO, device=" + mDevice);
- mSystemInterface.getAudioManager().setParameters("A2dpSuspended=true");
+ int a2dpState = mHeadsetService.getHfpA2DPSyncInterface().isA2dpPlaying();
+ if (!mHeadsetService.isScoAcceptable(mDevice)|| (a2dpState == HeadsetA2dpSync.A2DP_PLAYING)) {
+ stateLogW("No Active/Held call, no call setup,and no in-band ringing,"
+ + " or A2Dp is playing, not allowing SCO, device=" + mDevice);
+ break;
+ }
+
+ if (mHeadsetService.isSwbEnabled() && mHeadsetService.isSwbPmEnabled()) {
+ if (!mHeadsetService.isVirtualCallStarted() &&
+ mSystemInterface.isHighDefCallInProgress()) {
+ log("CONNECT_AUDIO: enable SWB for HD call ");
+ mHeadsetService.enableSwbCodec(true);
+ } else {
+ log("CONNECT_AUDIO: disable SWB for non-HD or Voip calls");
+ mHeadsetService.enableSwbCodec(false);
+ }
+ }
+
if (!mNativeInterface.connectAudio(mDevice)) {
- mSystemInterface.getAudioManager().setParameters("A2dpSuspended=false");
stateLogE("Failed to connect SCO audio for " + mDevice);
// No state change involved, fire broadcast immediately
broadcastAudioState(mDevice, BluetoothHeadset.STATE_AUDIO_DISCONNECTED,
@@ -1079,6 +1441,19 @@
stateLogD("ignore DISCONNECT_AUDIO, device=" + mDevice);
// ignore
break;
+ case RESUME_A2DP: {
+ /* If the call started/ended by the time A2DP suspend ack
+ * is received, send the call indicators before resuming
+ * A2DP.
+ */
+ if (mPendingCallStates.size() == 0) {
+ stateLogD("RESUME_A2DP evt, resuming A2DP");
+ mHeadsetService.getHfpA2DPSyncInterface().releaseA2DP(mDevice);
+ } else {
+ stateLogW("RESUME_A2DP evt, pending call states to be sent, not resuming");
+ }
+ break;
+ }
default:
return super.processMessage(message);
}
@@ -1100,6 +1475,12 @@
BluetoothHeadset.STATE_AUDIO_DISCONNECTED);
break;
}
+ if (!mSystemInterface.getHeadsetPhoneState().getIsCsCall()) {
+ stateLogI("Sco connected for call other than CS, check network type");
+ sendVoipConnectivityNetworktype(true);
+ } else {
+ stateLogI("Sco connected for CS call, do not check network type");
+ }
stateLogI("processAudioEvent: audio connected");
transitionTo(mAudioOn);
break;
@@ -1118,6 +1499,12 @@
transitionTo(mAudioConnecting);
break;
case HeadsetHalConstants.AUDIO_STATE_DISCONNECTED:
+ if (!(mSystemInterface.isInCall() || mSystemInterface.isRinging())) {
+ // SCO disconnected, resume A2DP if there is no call
+ stateLogD("SCO disconnected, set A2DPsuspended to false");
+ mHeadsetService.getHfpA2DPSyncInterface().releaseA2DP(mDevice);
+ }
+ break;
case HeadsetHalConstants.AUDIO_STATE_DISCONNECTING:
// ignore
break;
@@ -1180,6 +1567,12 @@
// ignore, there is no BluetoothHeadset.STATE_AUDIO_DISCONNECTING
break;
case HeadsetHalConstants.AUDIO_STATE_CONNECTED:
+ if (!mSystemInterface.getHeadsetPhoneState().getIsCsCall()) {
+ stateLogI("Sco connected for call other than CS, check network type");
+ sendVoipConnectivityNetworktype(true);
+ } else {
+ stateLogI("Sco connected for CS call, do not check network type");
+ }
stateLogI("processAudioEvent: audio connected");
transitionTo(mAudioOn);
break;
@@ -1228,6 +1621,9 @@
&& !hasDeferredMessages(DISCONNECT_AUDIO)) {
mHeadsetService.setActiveDevice(mDevice);
}
+ // If current device is TWSPLUS device and peer TWSPLUS device is already
+ // has SCO, dont need to update teh Audio Manager
+
setAudioParameters();
mSystemInterface.getAudioManager().setAudioServerStateCallback(
@@ -1258,14 +1654,24 @@
stateLogW("DISCONNECT, device " + device + " not connected");
break;
}
- // Disconnect BT SCO first
- if (!mNativeInterface.disconnectAudio(mDevice)) {
- stateLogW("DISCONNECT failed, device=" + mDevice);
- // if disconnect BT SCO failed, transition to mConnected state to force
- // disconnect device
+ if (mAdapterService.isTwsPlusDevice(device)) {
+ //for twsplus device, don't disconnect the SCO for app
+ //force the disocnnect of HF and in turn let SCO shutdown
+ //so that SCO SM handles it gracefully
+ if (!mNativeInterface.disconnectHfp(device)) {
+ stateLogW("DISCONNECT failed TWS case, device=" + mDevice);
+ }
+ transitionTo(mDisconnecting);
+ } else {
+ // Disconnect BT SCO first
+ if (!mNativeInterface.disconnectAudio(mDevice)) {
+ stateLogW("DISCONNECT failed, device=" + mDevice);
+ // if disconnect BT SCO failed, transition to mConnected state to force
+ // disconnect device
+ }
+ deferMessage(obtainMessage(DISCONNECT, mDevice));
+ transitionTo(mAudioDisconnecting);
}
- deferMessage(obtainMessage(DISCONNECT, mDevice));
- transitionTo(mAudioDisconnecting);
break;
}
case CONNECT_AUDIO: {
@@ -1309,6 +1715,9 @@
case HeadsetStackEvent.EVENT_TYPE_WBS:
stateLogE("Cannot change WBS state when audio is connected: " + event);
break;
+ case HeadsetStackEvent.EVENT_TYPE_SWB:
+ stateLogE("Cannot change SWB state when audio is connected: " + event);
+ break;
default:
super.processMessage(message);
break;
@@ -1325,6 +1734,22 @@
switch (state) {
case HeadsetHalConstants.AUDIO_STATE_DISCONNECTED:
stateLogI("processAudioEvent: audio disconnected by remote");
+ if (mAdapterService.isTwsPlusDevice(mDevice) && mHeadsetService.isAudioOn()) {
+ //If It is TWSP device, make sure SCO is not active on
+ //any devices before letting Audio knowing about it
+ stateLogI("TWS+ device and other SCO is still Active, no BT_SCO=off");
+ } else {
+ if(mSystemInterface.getAudioManager().isSpeakerphoneOn()) {
+ mSystemInterface.getAudioManager().setSpeakerphoneOn(true);
+ }
+ }
+ if (!mSystemInterface.getHeadsetPhoneState().getIsCsCall()) {
+ stateLogI("Sco disconnected for call other than CS, check network type");
+ sendVoipConnectivityNetworktype(false);
+ mSystemInterface.getHeadsetPhoneState().setIsCsCall(true);
+ } else {
+ stateLogI("Sco disconnected for CS call, do not check network type");
+ }
transitionTo(mConnected);
break;
case HeadsetHalConstants.AUDIO_STATE_DISCONNECTING:
@@ -1339,10 +1764,11 @@
private void processIntentScoVolume(Intent intent, BluetoothDevice device) {
int volumeValue = intent.getIntExtra(AudioManager.EXTRA_VOLUME_STREAM_VALUE, 0);
+ stateLogD(" mSpeakerVolume = " + mSpeakerVolume + " volValue = " + volumeValue);
if (mSpeakerVolume != volumeValue) {
mSpeakerVolume = volumeValue;
mNativeInterface.setVolume(device, HeadsetHalConstants.VOLUME_TYPE_SPK,
- mSpeakerVolume);
+ mSpeakerVolume);
}
}
}
@@ -1391,6 +1817,15 @@
switch (state) {
case HeadsetHalConstants.AUDIO_STATE_DISCONNECTED:
stateLogI("processAudioEvent: audio disconnected");
+ if (mAdapterService.isTwsPlusDevice(mDevice) && mHeadsetService.isAudioOn()) {
+ //If It is TWSP device, make sure SCO is not active on
+ //any devices before letting Audio knowing about it
+ stateLogI("TWS+ device and other SCO is still Active, no BT_SCO=off");
+ } else {
+ if(mSystemInterface.getAudioManager().isSpeakerphoneOn()) {
+ mSystemInterface.getAudioManager().setSpeakerphoneOn(true);
+ }
+ }
transitionTo(mConnected);
break;
case HeadsetHalConstants.AUDIO_STATE_DISCONNECTING:
@@ -1435,7 +1870,8 @@
*/
@VisibleForTesting
public synchronized int getConnectionState() {
- HeadsetStateBase state = (HeadsetStateBase) getCurrentState();
+ //getCurrentState()
+ HeadsetStateBase state = (HeadsetStateBase) getCurrentHeadsetStateMachineState();
if (state == null) {
return BluetoothHeadset.STATE_DISCONNECTED;
}
@@ -1450,7 +1886,8 @@
* {@link BluetoothHeadset#STATE_AUDIO_CONNECTED}
*/
public synchronized int getAudioState() {
- HeadsetStateBase state = (HeadsetStateBase) getCurrentState();
+ //getCurrentState()
+ HeadsetStateBase state = (HeadsetStateBase) getCurrentHeadsetStateMachineState();
if (state == null) {
return BluetoothHeadset.STATE_AUDIO_DISCONNECTED;
}
@@ -1482,6 +1919,14 @@
return true;
}
+ public void onAudioServerUp() {
+ Log.i(TAG, "onAudioSeverUp: restore audio parameters");
+ mSystemInterface.getAudioManager().setBluetoothScoOn(false);
+ mSystemInterface.getAudioManager().setParameters("A2dpSuspended=true");
+ setAudioParameters();
+ mSystemInterface.getAudioManager().setBluetoothScoOn(true);
+ }
+
/*
* Put the AT command, company ID, arguments, and device in an Intent and broadcast it.
*/
@@ -1505,7 +1950,9 @@
HEADSET_NREC + "=" + mAudioParams.getOrDefault(HEADSET_NREC,
HEADSET_AUDIO_FEATURE_OFF),
HEADSET_WBS + "=" + mAudioParams.getOrDefault(HEADSET_WBS,
- HEADSET_AUDIO_FEATURE_OFF)
+ HEADSET_AUDIO_FEATURE_OFF),
+ HEADSET_SWB + "=" + mAudioParams.getOrDefault(HEADSET_SWB,
+ HEADSET_SWB_DISABLE)
});
Log.i(TAG, "setAudioParameters for " + mDevice + ": " + keyValuePairs);
mSystemInterface.getAudioManager().setParameters(keyValuePairs);
@@ -1560,8 +2007,9 @@
}
if ((number == null) || (number.length() == 0)) {
dialNumber = mPhonebook.getLastDialledNumber();
- if (dialNumber == null) {
- Log.w(TAG, "processDialCall, last dial number null");
+ log("dialNumber: " + dialNumber);
+ if ((dialNumber == null) || (dialNumber.length() == 0)) {
+ Log.w(TAG, "processDialCall, last dial number null or empty ");
mNativeInterface.atResponseCode(mDevice, HeadsetHalConstants.AT_RESPONSE_ERROR, 0);
return;
}
@@ -1613,13 +2061,15 @@
private void processVolumeEvent(int volumeType, int volume) {
// Only current active device can change SCO volume
- if (!mDevice.equals(mHeadsetService.getActiveDevice())) {
+ if (!mHeadsetService.isTwsPlusActive(mDevice) &&
+ !mDevice.equals(mHeadsetService.getActiveDevice())) {
Log.w(TAG, "processVolumeEvent, ignored because " + mDevice + " is not active");
return;
}
if (volumeType == HeadsetHalConstants.VOLUME_TYPE_SPK) {
mSpeakerVolume = volume;
- int flag = (getCurrentState() == mAudioOn) ? AudioManager.FLAG_SHOW_UI : 0;
+ int flag = (getCurrentHeadsetStateMachineState() == mAudioOn)
+ ? AudioManager.FLAG_SHOW_UI : 0;
mSystemInterface.getAudioManager()
.setStreamVolume(AudioManager.STREAM_BLUETOOTH_SCO, volume, flag);
} else if (volumeType == HeadsetHalConstants.VOLUME_TYPE_MIC) {
@@ -1630,6 +2080,326 @@
}
}
+ private void processCallStatesDelayed(HeadsetCallState callState, boolean isVirtualCall)
+ {
+ log("Enter processCallStatesDelayed");
+ final HeadsetPhoneState mPhoneState = mSystemInterface.getHeadsetPhoneState();
+ if (callState.mCallState == HeadsetHalConstants.CALL_STATE_DIALING)
+ {
+ // at this point, queue should be empty.
+ processCallState(callState, false);
+ }
+ // update is for call alerting
+ else if (callState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING &&
+ mStateMachineCallState.mNumActive == callState.mNumActive &&
+ mStateMachineCallState.mNumHeld == callState.mNumHeld &&
+ mStateMachineCallState.mCallState == HeadsetHalConstants.CALL_STATE_DIALING)
+ {
+ log("Queue alerting update, send alerting delayed mesg");
+ //Q the call state;
+ mDelayedCSCallStates.add(callState);
+
+ //send delayed message for call alerting;
+ Message msg = obtainMessage(CS_CALL_STATE_CHANGED_ALERTING);
+ msg.arg1 = 0;
+ sendMessageDelayed(msg, CS_CALL_ALERTING_DELAY_TIME_MSEC);
+ }
+ // call moved to active from alerting state
+ else if (mStateMachineCallState.mNumActive == 0 &&
+ callState.mNumActive == 1 &&
+ mStateMachineCallState.mNumHeld == callState.mNumHeld &&
+ (mStateMachineCallState.mCallState == HeadsetHalConstants.CALL_STATE_DIALING ||
+ mStateMachineCallState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING ))
+ {
+ log("Call moved to active state from alerting");
+ // get the top of the Q
+ HeadsetCallState tempCallState = mDelayedCSCallStates.peek();
+
+ //if (top of the Q == alerting)
+ if( tempCallState != null &&
+ tempCallState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING)
+ {
+ log("Call is active, Queue it, top of Queue is alerting");
+ //Q active update;
+ mDelayedCSCallStates.add(callState);
+ }
+ else
+ // Q is empty
+ {
+ log("is Q empty " + mDelayedCSCallStates.isEmpty());
+ log("Call is active, Queue it, send delayed active mesg");
+ //Q active update;
+ mDelayedCSCallStates.add(callState);
+ //send delayed message for call active;
+ Message msg = obtainMessage(CS_CALL_STATE_CHANGED_ACTIVE);
+ msg.arg1 = 0;
+ sendMessageDelayed(msg, CS_CALL_ACTIVE_DELAY_TIME_MSEC);
+ }
+ }
+ // call setup or call ended
+ else if((mStateMachineCallState.mCallState == HeadsetHalConstants.CALL_STATE_DIALING ||
+ mStateMachineCallState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING ) &&
+ callState.mCallState == HeadsetHalConstants.CALL_STATE_IDLE &&
+ mStateMachineCallState.mNumActive == callState.mNumActive &&
+ mStateMachineCallState.mNumHeld == callState.mNumHeld)
+ {
+ log("call setup or call is ended");
+ // get the top of the Q
+ HeadsetCallState tempCallState = mDelayedCSCallStates.peek();
+
+ //if (top of the Q == alerting)
+ if(tempCallState != null &&
+ tempCallState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING)
+ {
+ log("Call is ended, remove delayed alerting mesg");
+ removeMessages(CS_CALL_STATE_CHANGED_ALERTING);
+ //DeQ(alerting);
+ mDelayedCSCallStates.poll();
+ // send 2,3 although the call is ended to make sure that we are sending 2,3 always
+ processCallState(tempCallState, false);
+
+ // update the top of the Q entry so that we process the active
+ // call entry from the Q below
+ tempCallState = mDelayedCSCallStates.peek();
+ }
+
+ //if (top of the Q == active)
+ if (tempCallState != null &&
+ tempCallState.mCallState == HeadsetHalConstants.CALL_STATE_IDLE)
+ {
+ log("Call is ended, remove delayed active mesg");
+ removeMessages(CS_CALL_STATE_CHANGED_ACTIVE);
+ //DeQ(active);
+ mDelayedCSCallStates.poll();
+ }
+ // send current call state which will take care of sending call end indicator
+ processCallState(callState, false);
+ } else {
+ HeadsetCallState tempCallState;
+
+ // if there are pending call states to be sent, send them now
+ if (mDelayedCSCallStates.isEmpty() != true)
+ {
+ log("new call update, removing pending alerting, active messages");
+ // remove pending delayed call states
+ removeMessages(CS_CALL_STATE_CHANGED_ALERTING);
+ removeMessages(CS_CALL_STATE_CHANGED_ACTIVE);
+ }
+
+ while (mDelayedCSCallStates.isEmpty() != true)
+ {
+ tempCallState = mDelayedCSCallStates.poll();
+ if (tempCallState != null)
+ {
+ processCallState(tempCallState, false);
+ }
+ }
+ // it is incoming call or MO call in non-alerting, non-active state.
+ processCallState(callState, isVirtualCall);
+ }
+ log("Exit processCallStatesDelayed");
+ }
+
+ private void processCallState(HeadsetCallState callState, boolean isVirtualCall) {
+ /* If active call is ended, no held call is present, disconnect SCO
+ * and fake the MT Call indicators. */
+ boolean isPts =
+ SystemProperties.getBoolean("vendor.bt.pts.certification", false);
+ if (!isPts) {
+ log("mIsBlacklistedDevice:" + mIsBlacklistedDevice);
+ if (mIsBlacklistedDevice &&
+ mStateMachineCallState.mNumActive == 1 &&
+ callState.mNumActive == 0 &&
+ callState.mNumHeld == 0 &&
+ callState.mCallState == HeadsetHalConstants.CALL_STATE_INCOMING) {
+
+ log("Disconnect SCO since active call is ended," +
+ "only waiting call is there");
+ Message m = obtainMessage(DISCONNECT_AUDIO);
+ m.obj = mDevice;
+ sendMessage(m);
+
+ log("Send Idle call indicators once Active call disconnected.");
+ // TODO: cross check this
+ mStateMachineCallState.mCallState =
+ HeadsetHalConstants.CALL_STATE_IDLE;
+ HeadsetCallState updateCallState = new HeadsetCallState(callState.mNumActive,
+ callState.mNumHeld,
+ HeadsetHalConstants.CALL_STATE_IDLE,
+ callState.mNumber,
+ callState.mType, MERGE_PLACEHOLDER);
+ mNativeInterface.phoneStateChange(mDevice, updateCallState);
+ mIsCallIndDelay = true;
+ }
+
+ /* The device is blacklisted for sending incoming call setup
+ * indicator after SCO disconnection and sending active call end
+ * indicator. While the incoming call setup indicator is in queue,
+ * waiting call moved to active state. Send call setup update first
+ * and remove it from queue. Create SCO since SCO might be in
+ * disconnecting/disconnected state */
+ if (mIsBlacklistedDevice &&
+ callState.mNumActive == 1 &&
+ callState.mNumHeld == 0 &&
+ callState.mCallState == HeadsetHalConstants.CALL_STATE_IDLE &&
+ hasMessages(SEND_INCOMING_CALL_IND)) {
+
+ Log.w(TAG, "waiting call moved to active state while incoming call");
+ Log.w(TAG, "setup indicator is in queue. Send it first and create SCO");
+ //remove call setup indicator from queue.
+ removeMessages(SEND_INCOMING_CALL_IND);
+
+ HeadsetCallState incomingCallSetupState =
+ new HeadsetCallState(0, 0, HeadsetHalConstants.CALL_STATE_INCOMING,
+ mSystemInterface.getHeadsetPhoneState().getNumber(),
+ mSystemInterface.getHeadsetPhoneState().getType(),
+ "");
+ mNativeInterface.phoneStateChange(mDevice, incomingCallSetupState);
+
+ if (mDevice.equals(mHeadsetService.getActiveDevice())) {
+ Message m = obtainMessage(CONNECT_AUDIO);
+ m.obj = mDevice;
+ sendMessage(m);
+ }
+ }
+ }
+ mStateMachineCallState.mNumActive = callState.mNumActive;
+ mStateMachineCallState.mNumHeld = callState.mNumHeld;
+ // get the top of the Q
+ HeadsetCallState tempCallState = mDelayedCSCallStates.peek();
+
+ if ( !isVirtualCall && tempCallState != null &&
+ tempCallState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING &&
+ callState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING) {
+ log("update call state as dialing since alerting update is in Q");
+ log("current call state is " + mStateMachineCallState.mCallState);
+ callState.mCallState = HeadsetHalConstants.CALL_STATE_DIALING;
+ }
+
+ mStateMachineCallState.mCallState = callState.mCallState;
+ mStateMachineCallState.mNumber = callState.mNumber;
+ mStateMachineCallState.mType = callState.mType;
+
+ log("processCallState: mNumActive: " + callState.mNumActive + " mNumHeld: "
+ + callState.mNumHeld + " mCallState: " + callState.mCallState);
+ log("processCallState: mNumber: " + callState.mNumber + " mType: " + callState.mType);
+
+ if (mHeadsetService.isSwbEnabled() && mHeadsetService.isSwbPmEnabled()) {
+ if (mHeadsetService.isVirtualCallStarted()) {
+ log("processCallState: enable SWB for all voip calls ");
+ mHeadsetService.enableSwbCodec(true);
+ } else if((callState.mCallState == HeadsetHalConstants.CALL_STATE_DIALING) ||
+ (callState.mCallState == HeadsetHalConstants.CALL_STATE_INCOMING)) {
+ if (!mSystemInterface.isHighDefCallInProgress()) {
+ log("processCallState: disable SWB for non-HD call ");
+ mHeadsetService.enableSwbCodec(false);
+ } else {
+ log("processCallState: enable SWB for HD call ");
+ mHeadsetService.enableSwbCodec(true);
+ }
+ }
+ }
+
+ processA2dpState(callState);
+ }
+
+ /* This function makes sure that we send a2dp suspend before updating on Incomming call status.
+ There may problem with some headsets if send ring and a2dp is not suspended,
+ so here we suspend stream if active before updating remote.We resume streaming once
+ callstate is idle and there are no active or held calls. */
+
+ private void processA2dpState(HeadsetCallState callState) {
+ int a2dpState = mHeadsetService.getHfpA2DPSyncInterface().isA2dpPlaying();
+ Log.d(TAG, "processA2dpState: isA2dpPlaying() " + a2dpState);
+
+ if ((mSystemInterface.isInCall() || mSystemInterface.isRinging()) &&
+ getConnectionState() == BluetoothHeadset.STATE_CONNECTED) {
+ // if A2DP is playing, add CS call states and return
+ if (mHeadsetService.getHfpA2DPSyncInterface().suspendA2DP(
+ HeadsetA2dpSync.A2DP_SUSPENDED_BY_CS_CALL, mDevice) == true) {
+ Log.d(TAG, "processA2dpState: A2DP is playing, suspending it,"+
+ "cache the call state for future");
+ mPendingCallStates.add(callState);
+ return;
+ }
+ }
+
+ if (getCurrentHeadsetStateMachineState() != mDisconnected) {
+ log("No A2dp playing to suspend, mIsCallIndDelay: " + mIsCallIndDelay +
+ " mPendingCallStates.size(): " + mPendingCallStates.size());
+ //When MO call creation and disconnection done back to back, Make sure to send
+ //the call indicators in a sequential way to remote
+ if (mPendingCallStates.size() != 0) {
+ Log.d(TAG, "Cache the call state, PendingCallStates list is not empty");
+ mPendingCallStates.add(callState);
+ return;
+ }
+ if (mIsCallIndDelay) {
+ mIsCallIndDelay = false;
+ sendMessageDelayed(SEND_INCOMING_CALL_IND, INCOMING_CALL_IND_DELAY);
+ } else {
+ mNativeInterface.phoneStateChange(mDevice, callState);
+ }
+ }
+ }
+
+ private void processIntentUpdateCallType(Intent intent) {
+ mIsCsCall = intent.getBooleanExtra(TelecomManager.EXTRA_CALL_TYPE_CS, true);
+ Log.d(TAG, "processIntentUpdateCallType " + mIsCsCall);
+ final HeadsetPhoneState mPhoneState = mSystemInterface.getHeadsetPhoneState();
+ mPhoneState.setIsCsCall(mIsCsCall);
+ if (getAudioState() == BluetoothHeadset.STATE_AUDIO_CONNECTED) {
+ if (!mPhoneState.getIsCsCall()) {
+ log("processIntentUpdateCallType, Non CS call, check for network type");
+ sendVoipConnectivityNetworktype(true);
+ } else {
+ log("processIntentUpdateCallType, CS call, do not check for network type");
+ }
+ } else {
+ log("processIntentUpdateCallType: Sco not yet connected");
+ }
+ }
+
+ private void processIntentA2dpPlayStateChanged(int a2dpState) {
+ Log.d(TAG, "Enter processIntentA2dpPlayStateChanged(): a2dp state "+
+ a2dpState);
+ if (mHeadsetService.isVRStarted()) {
+ Log.d(TAG, "VR is in started state");
+ if (mDevice.equals(mHeadsetService.getActiveDevice())) {
+ Log.d(TAG, "creating SCO for " + mDevice);
+ mNativeInterface.connectAudio(mDevice);
+ }
+ } else if (mSystemInterface.isInCall() || mHeadsetService.isVirtualCallStarted()){
+ //send incoming phone status to remote device
+ Log.d(TAG, "A2dp is suspended, updating phone states");
+ Iterator<HeadsetCallState> it = mPendingCallStates.iterator();
+ if (it != null) {
+ while (it.hasNext()) {
+ HeadsetCallState callState = it.next();
+ Log.d(TAG, "mIsCallIndDelay: " + mIsCallIndDelay);
+ mNativeInterface.phoneStateChange(mDevice, callState);
+ it.remove();
+ }
+ } else {
+ Log.d(TAG, "There are no pending call state changes");
+ }
+ } else {
+ Log.d(TAG, "A2DP suspended when there is no CS/VOIP calls or VR, resuming A2DP");
+ //When A2DP is suspended and the call is terminated,
+ //clean up the PendingCallStates list
+ Iterator<HeadsetCallState> it = mPendingCallStates.iterator();
+ if (it != null) {
+ while (it.hasNext()) {
+ HeadsetCallState callState = it.next();
+ mNativeInterface.phoneStateChange(mDevice, callState);
+ it.remove();
+ }
+ }
+ mHeadsetService.getHfpA2DPSyncInterface().releaseA2DP(mDevice);
+ }
+ Log.d(TAG, "Exit processIntentA2dpPlayStateChanged()");
+ }
+
private void processNoiseReductionEvent(boolean enable) {
String prevNrec = mAudioParams.getOrDefault(HEADSET_NREC, HEADSET_AUDIO_FEATURE_OFF);
String newNrec = enable ? HEADSET_AUDIO_FEATURE_ON : HEADSET_AUDIO_FEATURE_OFF;
@@ -1646,6 +2416,9 @@
switch (wbsConfig) {
case HeadsetHalConstants.BTHF_WBS_YES:
mAudioParams.put(HEADSET_WBS, HEADSET_AUDIO_FEATURE_ON);
+ if (mHeadsetService.isSwbEnabled()) {
+ mAudioParams.put(HEADSET_SWB, HEADSET_SWB_DISABLE);
+ }
break;
case HeadsetHalConstants.BTHF_WBS_NO:
case HeadsetHalConstants.BTHF_WBS_NONE:
@@ -1659,6 +2432,15 @@
HEADSET_WBS));
}
+ private void processSWBEvent(int swbConfig) {
+ if (swbConfig < HEADSET_SWB_MAX_CODEC_IDS) {
+ mAudioParams.put(HEADSET_SWB, "0");
+ mAudioParams.put(HEADSET_WBS, HEADSET_AUDIO_FEATURE_OFF);
+ } else {
+ mAudioParams.put(HEADSET_SWB, HEADSET_SWB_DISABLE);
+ }
+ }
+
private void processAtChld(int chld, BluetoothDevice device) {
if (mSystemInterface.processChld(chld)) {
mNativeInterface.atResponseCode(device, HeadsetHalConstants.AT_RESPONSE_OK, 0);
@@ -1680,30 +2462,57 @@
}
private void processAtCind(BluetoothDevice device) {
- int call, callSetup;
+ int call, callSetup, call_state, service, signal;
+ // get the top of the Q
+ HeadsetCallState tempCallState = mDelayedCSCallStates.peek();
final HeadsetPhoneState phoneState = mSystemInterface.getHeadsetPhoneState();
/* Handsfree carkits expect that +CIND is properly responded to
Hence we ensure that a proper response is sent
for the virtual call too.*/
if (mHeadsetService.isVirtualCallStarted()) {
- call = 1;
+ call = mStateMachineCallState.mNumActive;
callSetup = 0;
} else {
// regular phone call
- call = phoneState.getNumActiveCall();
- callSetup = phoneState.getNumHeldCall();
+ call = mStateMachineCallState.mNumActive;
+ callSetup = mStateMachineCallState.mNumHeld;
+ }
+ if(tempCallState != null &&
+ tempCallState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING)
+ call_state = HeadsetHalConstants.CALL_STATE_DIALING;
+ else
+ call_state = mStateMachineCallState.mCallState;
+ log("sending call state in CIND resp as " + call_state);
+
+ /* Some Handsfree devices or carkits expect the +CIND to be properly
+ responded with the correct service availablity and signal strength,
+ while the regular call is active or held or in progress.*/
+ if(((!mHeadsetService.isVirtualCallStarted()) &&
+ (mStateMachineCallState.mNumActive > 0) || (mStateMachineCallState.mNumHeld > 0) ||
+ mStateMachineCallState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING ||
+ mStateMachineCallState.mCallState == HeadsetHalConstants.CALL_STATE_DIALING ||
+ mStateMachineCallState.mCallState == HeadsetHalConstants.CALL_STATE_INCOMING) &&
+ (phoneState.getCindService() == HeadsetHalConstants.NETWORK_STATE_NOT_AVAILABLE)) {
+ log("processAtCind: If regular call is in process/active/held while RD connection " +
+ "during BT-ON, update service availablity and signal strength");
+ service = HeadsetHalConstants.NETWORK_STATE_AVAILABLE;
+ signal = 3;
+ } else {
+ service = phoneState.getCindService();
+ signal = phoneState.getCindSignal();
}
- mNativeInterface.cindResponse(device, phoneState.getCindService(), call, callSetup,
- phoneState.getCallState(), phoneState.getCindSignal(), phoneState.getCindRoam(),
+ mNativeInterface.cindResponse(device, service, call, callSetup,
+ call_state, signal, phoneState.getCindRoam(),
phoneState.getCindBatteryCharge());
+ log("Exit processAtCind()");
}
private void processAtCops(BluetoothDevice device) {
String operatorName = mSystemInterface.getNetworkOperator();
- if (operatorName == null) {
- operatorName = "";
+ if (operatorName == null || operatorName.equals("")) {
+ operatorName = "No operator";
}
mNativeInterface.copsResponse(device, operatorName);
}
@@ -1711,12 +2520,21 @@
private void processAtClcc(BluetoothDevice device) {
if (mHeadsetService.isVirtualCallStarted()) {
// In virtual call, send our phone number instead of remote phone number
- String phoneNumber = mSystemInterface.getSubscriberNumber();
+ // some carkits cross-check subscriber number( fetched by AT+CNUM) against
+ // number sent in clcc and reject sco connection.
+ String phoneNumber = VOIP_CALL_NUMBER;
if (phoneNumber == null) {
phoneNumber = "";
}
int type = PhoneNumberUtils.toaFromString(phoneNumber);
- mNativeInterface.clccResponse(device, 1, 0, 0, 0, false, phoneNumber, type);
+ log(" processAtClcc phonenumber = "+ phoneNumber + " type = " + type);
+ // call still in dialling or alerting state
+ if (mStateMachineCallState.mNumActive == 0) {
+ mNativeInterface.clccResponse(device, 1, 0, mStateMachineCallState.mCallState, 0,
+ false, phoneNumber, type);
+ } else {
+ mNativeInterface.clccResponse(device, 1, 0, 0, 0, false, phoneNumber, type);
+ }
mNativeInterface.clccResponse(device, 0, 0, 0, 0, false, "", 0);
} else {
// In Telecom call, ask Telecom to send send remote phone number
@@ -1888,6 +2706,14 @@
processAtCpbs(atCommand.substring(5), commandType, device);
} else if (atCommand.startsWith("+CPBR")) {
processAtCpbr(atCommand.substring(5), commandType, device);
+ } else if (atCommand.startsWith("+CSQ")) {
+ mNativeInterface.atResponseCode(device, HeadsetHalConstants.AT_RESPONSE_ERROR, 0);
+ } else if (atCommand.equals("+CGMI")) {
+ mNativeInterface.atResponseString(device, "+CGMI: \"" + Build.MANUFACTURER + "\"");
+ mNativeInterface.atResponseCode(device, HeadsetHalConstants.AT_RESPONSE_OK, 0);
+ } else if (atCommand.equals("+CGMM")) {
+ mNativeInterface.atResponseString(device, "+CGMM: " + Build.MODEL);
+ mNativeInterface.atResponseCode(device, HeadsetHalConstants.AT_RESPONSE_OK, 0);
} else {
processVendorSpecificAt(atCommand, device);
}
@@ -1897,19 +2723,24 @@
private void processKeyPressed(BluetoothDevice device) {
if (mSystemInterface.isRinging()) {
mSystemInterface.answerCall(device);
- } else if (mSystemInterface.isInCall()) {
- if (getAudioState() == BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
- // Should connect audio as well
- if (!mHeadsetService.setActiveDevice(mDevice)) {
- Log.w(TAG, "processKeyPressed, failed to set active device to " + mDevice);
- }
- } else {
- mSystemInterface.hangupCall(device);
- }
} else if (getAudioState() != BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
if (!mNativeInterface.disconnectAudio(mDevice)) {
Log.w(TAG, "processKeyPressed, failed to disconnect audio from " + mDevice);
}
+ } else if (mSystemInterface.isInCall()) {
+ if (getAudioState() == BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
+ // Should connect audio as well
+ if (mDevice.equals(mHeadsetService.getActiveDevice())) {
+ Log.w(TAG, "processKeyPressed: device "+ mDevice+" is active, create SCO");
+ mNativeInterface.connectAudio(mDevice);
+ } else {
+ //Set active device and create SCO
+ if (!mHeadsetService.setActiveDevice(mDevice)) {
+ Log.w(TAG, "processKeyPressed, failed to set active device to "
+ + mDevice);
+ }
+ }
+ }
} else {
// We have already replied OK to this HSP command, no feedback is needed
if (mHeadsetService.hasDeviceInitiatedDialingOut()) {
@@ -1974,11 +2805,95 @@
}
}
+ /**
+ * Send TWSP Battery State changed intent
+ *
+ * @param device Device whose Battery State Changed
+ * @param batteryState Charging/Discharging [0/1]
+ * @param batteryLevel battery percentage, -1 means invalid
+ */
+ private void sendTwsBatteryStateIntent(BluetoothDevice device,
+ int batteryState, int batteryLevel) {
+ Intent intent = new Intent(
+ BluetoothHeadset.ACTION_HF_TWSP_BATTERY_STATE_CHANGED);
+ intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
+ intent.putExtra(BluetoothHeadset.EXTRA_HF_TWSP_BATTERY_STATE,
+ batteryState);
+ intent.putExtra(BluetoothHeadset.EXTRA_HF_TWSP_BATTERY_LEVEL,
+ batteryLevel);
+ mHeadsetService.sendBroadcast(intent, HeadsetService.BLUETOOTH_PERM);
+ }
+
+ private void processTwsBatteryState(String atString, BluetoothDevice device) {
+ log("processTwsBatteryState: " + atString);
+ int batteryState;
+ int batteryLevel;
+
+ String parts[] = atString.split(",");
+ if (parts.length != 2) {
+ Log.e(TAG, "Invalid battery status event");
+ return;
+ }
+
+ try {
+ batteryState = Integer.parseInt(parts[0]);
+ } catch (NumberFormatException e) {
+ Log.e(TAG, Log.getStackTraceString(new Throwable()));
+ return;
+ }
+
+ try {
+ batteryLevel = Integer.parseInt(parts[1]);
+ } catch (NumberFormatException e) {
+ Log.e(TAG, Log.getStackTraceString(new Throwable()));
+ return;
+ }
+
+ log("processTwsBatteryState: batteryState:" + batteryState
+ + "batteryLevel:" + batteryLevel);
+ sendTwsBatteryStateIntent(device, batteryState, batteryLevel);
+ }
+
private void processAtBiev(int indId, int indValue, BluetoothDevice device) {
log("processAtBiev: ind_id=" + indId + ", ind_value=" + indValue);
sendIndicatorIntent(device, indId, indValue);
}
+ private void processCpbr(Intent intent)
+ {
+ int atCommandResult = 0;
+ int atCommandErrorCode = 0;
+ BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+ log("Enter processCpbr()");
+ // ASSERT: (headset != null) && headSet.isConnected()
+ // REASON: mCheckingAccessPermission is true, otherwise resetAtState
+ // has set mCheckingAccessPermission to false
+ if (intent.getAction().equals(BluetoothDevice.ACTION_CONNECTION_ACCESS_REPLY)) {
+ if (intent.getIntExtra(BluetoothDevice.EXTRA_CONNECTION_ACCESS_RESULT,
+ BluetoothDevice.CONNECTION_ACCESS_NO)
+ == BluetoothDevice.CONNECTION_ACCESS_YES) {
+ if (intent.getBooleanExtra(BluetoothDevice.EXTRA_ALWAYS_ALLOWED, false)) {
+ mDevice.setPhonebookAccessPermission(BluetoothDevice.ACCESS_ALLOWED);
+ }
+ atCommandResult = mPhonebook.processCpbrCommand(device);
+ } else {
+ if (intent.getBooleanExtra(BluetoothDevice.EXTRA_ALWAYS_ALLOWED, false)) {
+ mDevice.setPhonebookAccessPermission(
+ BluetoothDevice.ACCESS_REJECTED);
+ }
+ }
+ }
+ mPhonebook.setCpbrIndex(-1);
+ mPhonebook.setCheckingAccessPermission(false);
+
+ if (atCommandResult >= 0) {
+ mNativeInterface.atResponseCode(device, atCommandResult, atCommandErrorCode);
+ } else {
+ log("processCpbr - RESULT_NONE");
+ }
+ Log.d(TAG, "Exit processCpbr()");
+ }
+
private void processSendClccResponse(HeadsetClccResponse clcc) {
if (!hasMessages(CLCC_RSP_TIMEOUT)) {
return;
@@ -1986,8 +2901,24 @@
if (clcc.mIndex == 0) {
removeMessages(CLCC_RSP_TIMEOUT);
}
- mNativeInterface.clccResponse(mDevice, clcc.mIndex, clcc.mDirection, clcc.mStatus,
- clcc.mMode, clcc.mMpty, clcc.mNumber, clcc.mType);
+ // get the top of the Q
+ HeadsetCallState tempCallState = mDelayedCSCallStates.peek();
+
+ /* Send call state DIALING if call alerting update is still in the Q */
+ if (clcc.mStatus == HeadsetHalConstants.CALL_STATE_ALERTING &&
+ tempCallState != null &&
+ tempCallState.mCallState == HeadsetHalConstants.CALL_STATE_ALERTING) {
+ log("sending call status as DIALING");
+ mNativeInterface.clccResponse(mDevice, clcc.mIndex, clcc.mDirection,
+ HeadsetHalConstants.CALL_STATE_DIALING,
+ clcc.mMode, clcc.mMpty, clcc.mNumber, clcc.mType);
+ } else {
+ log("sending call status as " + clcc.mStatus);
+ mNativeInterface.clccResponse(mDevice, clcc.mIndex, clcc.mDirection,
+ clcc.mStatus,
+ clcc.mMode, clcc.mMpty, clcc.mNumber, clcc.mType);
+ }
+ log("Exit processSendClccResponse()");
}
private void processSendVendorSpecificResultCode(HeadsetVendorSpecificResultCode resultCode) {
@@ -2025,6 +2956,60 @@
mSystemInterface.getHeadsetPhoneState().listenForPhoneState(mDevice, events);
}
+ boolean isConnectedDeviceBlacklistedforIncomingCall() {
+ // Checking for the Blacklisted device Addresses
+ for (int j = 0; j < BlacklistDeviceAddrToDelayCallInd.length;j++) {
+ String addr = BlacklistDeviceAddrToDelayCallInd[j];
+ if (mDevice.toString().toLowerCase().startsWith(addr.toLowerCase())) {
+ log("Remote device address Blacklisted for sending delay");
+ return true;
+ }
+ }
+ return false;
+ }
+
+ boolean isDeviceBlacklistedForSendingCallIndsBackToBack() {
+ // Checking for the Blacklisted device Addresses
+ for (int j = 0; j < BlacklistDeviceForSendingVOIPCallIndsBackToBack.length;j++) {
+ String addr = BlacklistDeviceForSendingVOIPCallIndsBackToBack[j];
+ if (mDevice.toString().toLowerCase().startsWith(addr.toLowerCase())) {
+ Log.w(TAG, "Remote device " + mDevice +
+ " address Blacklisted for sending VOIP call inds back to back");
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private void sendVoipConnectivityNetworktype(boolean isVoipStarted) {
+ Log.d(TAG, "Enter sendVoipConnectivityNetworktype()");
+ Network network = mConnectivityManager.getActiveNetwork();
+ if (network == null) {
+ Log.d(TAG, "No default network is currently active");
+ return;
+ }
+ NetworkCapabilities networkCapabilities =
+ mConnectivityManager.getNetworkCapabilities(network);
+ if (mIsAvailable == false) {
+ Log.d(TAG, "No connected/available connectivity network, don't update soc");
+ return;
+ }
+ if (networkCapabilities == null) {
+ Log.d(TAG, "The capabilities of active network is NULL");
+ return;
+ }
+ if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
+ Log.d(TAG, "Voip/VoLTE started/stopped on n/w TRANSPORT_CELLULAR, don't update to soc");
+ } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+ Log.d(TAG, "Voip/VoLTE started/stopped on n/w TRANSPORT_WIFI, "+
+ "update n/w type & start/stop to soc");
+ mAdapterService.voipNetworkWifiInfo(isVoipStarted, true);
+ } else {
+ Log.d(TAG, "Voip/VoLTE started/stopped on some other n/w, don't update to soc");
+ }
+ Log.d(TAG, "Exit sendVoipConnectivityNetworktype()");
+ }
+
@Override
protected void log(String msg) {
if (DBG) {
@@ -2052,38 +3037,23 @@
}
private void handleAccessPermissionResult(Intent intent) {
- log("handleAccessPermissionResult");
+ log("Enter handleAccessPermissionResult");
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
- if (!mPhonebook.getCheckingAccessPermission()) {
- return;
- }
- int atCommandResult = 0;
- int atCommandErrorCode = 0;
- // HeadsetBase headset = mHandsfree.getHeadset();
- // ASSERT: (headset != null) && headSet.isConnected()
- // REASON: mCheckingAccessPermission is true, otherwise resetAtState
- // has set mCheckingAccessPermission to false
- if (intent.getAction().equals(BluetoothDevice.ACTION_CONNECTION_ACCESS_REPLY)) {
- if (intent.getIntExtra(BluetoothDevice.EXTRA_CONNECTION_ACCESS_RESULT,
- BluetoothDevice.CONNECTION_ACCESS_NO)
- == BluetoothDevice.CONNECTION_ACCESS_YES) {
- if (intent.getBooleanExtra(BluetoothDevice.EXTRA_ALWAYS_ALLOWED, false)) {
- mDevice.setPhonebookAccessPermission(BluetoothDevice.ACCESS_ALLOWED);
- }
- atCommandResult = mPhonebook.processCpbrCommand(device);
- } else {
- if (intent.getBooleanExtra(BluetoothDevice.EXTRA_ALWAYS_ALLOWED, false)) {
- mDevice.setPhonebookAccessPermission(BluetoothDevice.ACCESS_REJECTED);
- }
+ if (mPhonebook != null) {
+ if (!mPhonebook.getCheckingAccessPermission()) {
+ return;
+ }
+
+ Message m = obtainMessage(PROCESS_CPBR);
+ m.obj = intent;
+ sendMessage(m);
+ } else {
+ Log.e(TAG, "Phonebook handle null");
+ if (device != null) {
+ mNativeInterface.atResponseCode(device, HeadsetHalConstants.AT_RESPONSE_ERROR, 0);
}
}
- mPhonebook.setCpbrIndex(-1);
- mPhonebook.setCheckingAccessPermission(false);
- if (atCommandResult >= 0) {
- mNativeInterface.atResponseCode(device, atCommandResult, atCommandErrorCode);
- } else {
- log("handleAccessPermissionResult - RESULT_NONE");
- }
+ log("Exit handleAccessPermissionResult()");
}
private static int getConnectionStateFromAudioState(int audioState) {
diff --git a/src/com/android/bluetooth/hfp/HeadsetSystemInterface.java b/src/com/android/bluetooth/hfp/HeadsetSystemInterface.java
index 81090eb..e4078ac 100644
--- a/src/com/android/bluetooth/hfp/HeadsetSystemInterface.java
+++ b/src/com/android/bluetooth/hfp/HeadsetSystemInterface.java
@@ -238,6 +238,23 @@
}
/**
+ * Check for HD codec for voice call
+ */
+ @VisibleForTesting
+ public boolean isHighDefCallInProgress() {
+ if (mPhoneProxy != null) {
+ try {
+ return mPhoneProxy.isHighDefCallInProgress();
+ } catch (RemoteException e) {
+ Log.e(TAG, Log.getStackTraceString(new Throwable()));
+ }
+ } else {
+ Log.e(TAG, "Handsfree phone proxy null");
+ }
+ return false;
+ }
+
+ /**
* Get the the alphabetic name of current registered operator.
*
* @return null on error, empty string if not available
@@ -329,8 +346,7 @@
@VisibleForTesting
public boolean isInCall() {
return ((mHeadsetPhoneState.getNumActiveCall() > 0) || (mHeadsetPhoneState.getNumHeldCall()
- > 0) || ((mHeadsetPhoneState.getCallState() != HeadsetHalConstants.CALL_STATE_IDLE)
- && (mHeadsetPhoneState.getCallState() != HeadsetHalConstants.CALL_STATE_INCOMING)));
+ > 0) || (mHeadsetPhoneState.getCallState() != HeadsetHalConstants.CALL_STATE_IDLE));
}
/**
diff --git a/src/com/android/bluetooth/hid/HidHostService.java b/src/com/android/bluetooth/hid/HidHostService.java
index c378f8e..bbde619 100644
--- a/src/com/android/bluetooth/hid/HidHostService.java
+++ b/src/com/android/bluetooth/hid/HidHostService.java
@@ -26,7 +26,6 @@
import android.os.Message;
import android.os.UserHandle;
import android.util.Log;
-
import androidx.annotation.VisibleForTesting;
import com.android.bluetooth.BluetoothMetricsProto;
@@ -47,7 +46,7 @@
* @hide
*/
public class HidHostService extends ProfileService {
- private static final boolean DBG = false;
+ private static final boolean DBG = true;
private static final String TAG = "BluetoothHidHostService";
private Map<BluetoothDevice, Integer> mInputDevices;
@@ -181,7 +180,11 @@
if (DBG) {
Log.d(TAG, "Incoming HID connection rejected");
}
- virtualUnPlugNative(Utils.getByteAddress(device));
+ if (disconnectRemote(device)) {
+ disconnectHidNative(Utils.getByteAddress(device));
+ } else {
+ virtualUnPlugNative(Utils.getByteAddress(device));
+ }
} else {
broadcastConnectionState(device, convertHalState(halState));
}
@@ -815,9 +818,10 @@
// Check priority and accept or reject the connection.
int priority = getPriority(device);
int bondState = adapterService.getBondState(device);
- // Allow this connection only if the device is bonded. Any attempt to connect while
- // bonding would potentially lead to an unauthorized connection.
- if (bondState != BluetoothDevice.BOND_BONDED) {
+ // During reconnection bond state may moved to bonding if remote missed key due to collision
+ // Also stack accepts the connection after authentication complete.
+ // Allow the connection in bonding and bonded states
+ if (bondState == BluetoothDevice.BOND_NONE) {
Log.w(TAG, "okToConnect: return false, bondState=" + bondState);
return false;
} else if (priority != BluetoothProfile.PRIORITY_UNDEFINED
@@ -830,6 +834,37 @@
return true;
}
+ /**
+ * Check whether need to disconnect or virtual unplug remote device
+ * The check considers a number of factors during the evaluation.
+ *
+ * @param device the peer device to connect to
+ * @return true if remote device is to be disconnected, otherwise remote
+ * device needs to be virtually unplugged
+ */
+ private boolean disconnectRemote(BluetoothDevice device) {
+ AdapterService adapterService = AdapterService.getAdapterService();
+ // Check if adapter service is null.
+ if (adapterService == null) {
+ Log.w(TAG, "disconnectRemote: adapter service is null");
+ return false;
+ }
+ // Check if this is an incoming connection in Quiet mode.
+ if (adapterService.isQuietModeEnabled() && mTargetDevice == null) {
+ Log.w(TAG, "disconnectRemote: return false as quiet mode enabled");
+ return false;
+ }
+ int priority = getPriority(device);
+ int bondState = adapterService.getBondState(device);
+ // Disconnect remote device if bonded and priroty is OFF
+ if (bondState == BluetoothDevice.BOND_BONDED &&
+ priority == BluetoothProfile.PRIORITY_OFF) {
+ Log.w(TAG, "disconnectRemote: return true");
+ return true;
+ }
+ return false;
+ }
+
private static int convertHalState(int halState) {
switch (halState) {
case CONN_STATE_CONNECTED:
diff --git a/src/com/android/bluetooth/map/BluetoothMapAccountItem.java b/src/com/android/bluetooth/map/BluetoothMapAccountItem.java
index cb9481b..aa5b969 100644
--- a/src/com/android/bluetooth/map/BluetoothMapAccountItem.java
+++ b/src/com/android/bluetooth/map/BluetoothMapAccountItem.java
@@ -40,10 +40,12 @@
public final String mBase_uri_no_account;
private final String mUci;
private final String mUciPrefix;
+ private String mDisplayName;
+ private String mEmailAddress;
public BluetoothMapAccountItem(String id, String name, String packageName, String authority,
Drawable icon, BluetoothMapUtils.TYPE appType, String uci, String uciPrefix) {
- this.mName = name;
+ this.mName = name + " Server " + id;
this.mIcon = icon;
this.mPackageName = packageName;
this.mId = id;
@@ -228,4 +230,23 @@
return mType;
}
+ public void setDisplayName(String name) {
+ mDisplayName = name;
+ if(V) Log.v(TAG, "setDispName: " + mDisplayName );
+ }
+
+ public void setEmailAddress(String emailId) {
+ mEmailAddress = emailId;
+ if(V) Log.v(TAG, "setOrgEmail: " + mEmailAddress );
+ }
+
+ public String getDisplayName() {
+ if(V) Log.v(TAG, "getDispName: " + mDisplayName );
+ return mDisplayName;
+ }
+
+ public String getEmailAddress() {
+ if(V) Log.v(TAG, "getOrgEmail: " + mDisplayName );
+ return mEmailAddress;
+ }
}
diff --git a/src/com/android/bluetooth/map/BluetoothMapAccountLoader.java b/src/com/android/bluetooth/map/BluetoothMapAccountLoader.java
index 3ad600b..1fc4af9 100644
--- a/src/com/android/bluetooth/map/BluetoothMapAccountLoader.java
+++ b/src/com/android/bluetooth/map/BluetoothMapAccountLoader.java
@@ -185,7 +185,7 @@
return children;
} finally {
if (mProviderClient != null) {
- mProviderClient.release();
+ mProviderClient.close();
}
}
diff --git a/src/com/android/bluetooth/map/BluetoothMapAppObserver.java b/src/com/android/bluetooth/map/BluetoothMapAppObserver.java
index b4dfe5a..7ed461e 100644
--- a/src/com/android/bluetooth/map/BluetoothMapAppObserver.java
+++ b/src/com/android/bluetooth/map/BluetoothMapAppObserver.java
@@ -23,10 +23,13 @@
import android.content.pm.ResolveInfo;
import android.database.ContentObserver;
import android.net.Uri;
+import android.os.SystemProperties;
import android.util.Log;
+import com.android.bluetooth.btservice.AdapterService;
+import com.android.bluetooth.btservice.AbstractionLayer;
import com.android.bluetooth.mapapi.BluetoothMapContract;
-
+import com.android.bluetooth.R;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
@@ -59,9 +62,24 @@
public BluetoothMapAppObserver(final Context context, BluetoothMapService mapService) {
mContext = context;
mMapService = mapService;
- mResolver = context.getContentResolver();
- mLoader = new BluetoothMapAccountLoader(mContext);
- mFullList = mLoader.parsePackages(false); /* Get the current list of apps */
+ mResolver = context.getContentResolver();
+ AdapterService adapterService = AdapterService.getAdapterService();
+ boolean isEmailSupported = false;
+
+ if (adapterService != null) {
+ isEmailSupported = adapterService.getProfileInfo(AbstractionLayer.MAP, AbstractionLayer.MAP_EMAIL_SUPPORT);
+ Log.d(TAG, "isEmailSupported: " + isEmailSupported);
+ }
+ if (isEmailSupported) {
+ mLoader = new BluetoothMapAccountEmailLoader(mContext);
+ } else {
+ mLoader = new BluetoothMapAccountLoader(mContext);
+ }
+ mFullList = mLoader.parsePackages(false); /* Get the current list of apps */
+ if (isEmailSupported) {
+ SystemProperties.set("vendor.bluetooth.emailaccountcount",
+ String.valueOf(mLoader.getAccountsEnabledCount()));
+ }
createReceiver();
initObservers();
}
diff --git a/src/com/android/bluetooth/map/BluetoothMapAppParams.java b/src/com/android/bluetooth/map/BluetoothMapAppParams.java
index c1c2846..7c7c05e 100644
--- a/src/com/android/bluetooth/map/BluetoothMapAppParams.java
+++ b/src/com/android/bluetooth/map/BluetoothMapAppParams.java
@@ -63,16 +63,16 @@
private static final int PRESENCE_AVAILABLE = 0x1C;
private static final int PRESENCE_TEXT = 0x1D;
private static final int LAST_ACTIVITY = 0x1E;
- private static final int CHAT_STATE = 0x1F;
- private static final int FILTER_CONVO_ID = 0x20;
- private static final int CONVO_LISTING_SIZE = 0x21;
- private static final int FILTER_PRESENCE = 0x22;
- private static final int FILTER_UID_PRESENT = 0x23;
- private static final int CHAT_STATE_CONVO_ID = 0x24;
- private static final int FOLDER_VER_COUNTER = 0x25;
- private static final int FILTER_MESSAGE_HANDLE = 0x26;
- private static final int NOTIFICATION_FILTER = 0x27;
- private static final int CONVO_PARAMETER_MASK = 0x28;
+ private static final int CHAT_STATE = 0x21; // Unused
+ private static final int FILTER_CONVO_ID = 0x22; // Unused
+ private static final int CONVO_LISTING_SIZE = 0x36; // Unused
+ private static final int FILTER_PRESENCE = 0x37; // Unused
+ private static final int FILTER_UID_PRESENT = 0x38; // Unused
+ private static final int CHAT_STATE_CONVO_ID = 0x39; // Unused
+ private static final int FOLDER_VER_COUNTER = 0x23; // Unused
+ private static final int FILTER_MESSAGE_HANDLE = 0x24; // Unused
+ private static final int NOTIFICATION_FILTER = 0x25;
+ private static final int CONVO_PARAMETER_MASK = 0x26; // Unused
// Length defined for Application Parameters
private static final int MAX_LIST_COUNT_LEN = 0x02; //, 0x0000, 0xFFFF),
@@ -104,8 +104,8 @@
private static final int CONVO_LISTING_SIZE_LEN = 0x02;
private static final int FILTER_PRESENCE_LEN = 0x01;
private static final int FILTER_UID_PRESENT_LEN = 0x01;
- private static final int FOLDER_VER_COUNTER_LEN = 0x10;
- private static final int FILTER_MESSAGE_HANDLE_LEN = 0x10;
+ private static final int FOLDER_VER_COUNTER_LEN = 0x20; // Unused
+ private static final int FILTER_MESSAGE_HANDLE_LEN = 0x08; // Unused
private static final int NOTIFICATION_FILTER_LEN = 0x04;
private static final int CONVO_PARAMETER_MASK_LEN = 0x04;
@@ -1046,7 +1046,7 @@
public void setFilterMsgHandle(String handle) {
try {
mFilterMsgHandle = BluetoothMapUtils.getLongFromString(handle);
- } catch (UnsupportedEncodingException e) {
+ } catch (UnsupportedEncodingException | NumberFormatException e) {
Log.w(TAG, "Error creating long from handle string", e);
}
}
@@ -1100,7 +1100,7 @@
public void setFilterConvoId(String id) {
try {
mFilterConvoId = SignedLongLong.fromString(id);
- } catch (UnsupportedEncodingException e) {
+ } catch (UnsupportedEncodingException | NumberFormatException e) {
Log.w(TAG, "Error creating long from id string", e);
}
}
diff --git a/src/com/android/bluetooth/map/BluetoothMapContent.java b/src/com/android/bluetooth/map/BluetoothMapContent.java
index de1c59d..e98fa40 100644
--- a/src/com/android/bluetooth/map/BluetoothMapContent.java
+++ b/src/com/android/bluetooth/map/BluetoothMapContent.java
@@ -148,10 +148,10 @@
private final BluetoothMapAccountItem mAccount;
/* The MasInstance reference is used to update persistent (over a connection) version counters*/
private final BluetoothMapMasInstance mMasInstance;
- private String mMessageVersion = BluetoothMapUtils.MAP_V10_STR;
+ protected String mMessageVersion = BluetoothMapUtils.MAP_V10_STR;
private int mRemoteFeatureMask = BluetoothMapUtils.MAP_FEATURE_DEFAULT_BITMASK;
- private int mMsgListingVersion = BluetoothMapUtils.MAP_MESSAGE_LISTING_FORMAT_V10;
+ protected int mMsgListingVersion = BluetoothMapUtils.MAP_MESSAGE_LISTING_FORMAT_V10;
static final String[] SMS_PROJECTION = new String[]{
BaseColumns._ID,
@@ -2458,7 +2458,6 @@
setDeliveryStatus(ele, tmpCursor, fi, ap);
setThreadId(ele, tmpCursor, fi, ap);
setThreadName(ele, tmpCursor, fi, ap);
- setFolderType(ele, tmpCursor, fi, ap);
}
}
}
@@ -4324,6 +4323,10 @@
}
}
+ public int getMsgListingVersion() {
+ return mMsgListingVersion;
+ }
+
public int getRemoteFeatureMask() {
return this.mRemoteFeatureMask;
}
diff --git a/src/com/android/bluetooth/map/BluetoothMapContentObserver.java b/src/com/android/bluetooth/map/BluetoothMapContentObserver.java
index c862619..65909b5 100644
--- a/src/com/android/bluetooth/map/BluetoothMapContentObserver.java
+++ b/src/com/android/bluetooth/map/BluetoothMapContentObserver.java
@@ -113,7 +113,7 @@
private static final long EVENT_FILTER_CONVERSATION_CHANGED = 1L << 10;
private static final long EVENT_FILTER_PARTICIPANT_PRESENCE_CHANGED = 1L << 11;
private static final long EVENT_FILTER_PARTICIPANT_CHATSTATE_CHANGED = 1L << 12;
- private static final long EVENT_FILTER_MESSAGE_REMOVED = 1L << 13;
+ private static final long EVENT_FILTER_MESSAGE_REMOVED = 1L << 14;
// TODO: If we are requesting a large message from the network, on a slow connection
// 20 seconds might not be enough... But then again 20 seconds is long for other
@@ -149,7 +149,7 @@
* Actually we only ever use the lower 4 bytes of this variable,
* hence we could manage without the volatile keyword, but as
* we tend to copy ways of doing things, we better do it right:-) */
- private volatile long mEventFilter = 0xFFFFFFFFL;
+ protected volatile long mEventFilter = 0xFFFFFFFFL;
public static final int DELETED_THREAD_ID = -1;
@@ -312,8 +312,7 @@
}
public void setObserverRemoteFeatureMask(int remoteSupportedFeatures) {
- mMapSupportedFeatures =
- remoteSupportedFeatures & BluetoothMapMasInstance.SDP_MAP_MAS_FEATURES;
+ mMapSupportedFeatures = remoteSupportedFeatures;
if ((BluetoothMapUtils.MAP_FEATURE_EXTENDED_EVENT_REPORT_11_BIT & mMapSupportedFeatures)
!= 0) {
mMapEventReportVersion = BluetoothMapUtils.MAP_EVENT_REPORT_V11;
@@ -330,9 +329,9 @@
+ " were set, mMapSupportedFeatures=" + mMapSupportedFeatures);
}
if (D) {
- Log.d(TAG,
- "setObserverRemoteFeatureMask: mMapEventReportVersion=" + mMapEventReportVersion
- + " mMapSupportedFeatures=" + mMapSupportedFeatures);
+ Log.d(TAG, "setObserverRemoteFeatureMask: mMapEventReportVersion="
+ + mMapEventReportVersion + " mMapSupportedFeatures="
+ + Integer.toHexString(mMapSupportedFeatures));
}
}
@@ -588,7 +587,7 @@
}
}
- private class Event {
+ class Event {
public String eventType;
public long handle;
public String folder = null;
@@ -835,6 +834,8 @@
public long folderId = -1; // Email folder ID
public long oldFolderId = -1; // Used for email undelete
public boolean localInitiatedSend = false; // Used for MMS to filter out events
+ boolean localInitiatedReadStatus = false; // Used for SetMsgStatusRead to filter out event
+ boolean localInitiatedShift = false; // Used for SetMsgStatusDelete to filter out events
public boolean transparent = false;
// Used for EMAIL to delete message sent with transparency
public int flagRead = -1; // Message status read/unread
@@ -1054,7 +1055,7 @@
mResolver.unregisterContentObserver(mObserver);
mObserverRegistered = false;
if (mProviderClient != null) {
- mProviderClient.release();
+ mProviderClient.close();
mProviderClient = null;
}
}
@@ -1532,10 +1533,14 @@
c.close();
}
}
-
+ String eventType = EVENT_TYPE_DELETE;
for (Msg msg : getMsgListSms().values()) {
// "old_folder" used only for MessageShift event
- Event evt = new Event(EVENT_TYPE_DELETE, msg.id, getSmsFolderName(msg.type), null,
+ if (mMapEventReportVersion >= BluetoothMapUtils.MAP_EVENT_REPORT_V12) {
+ eventType = EVENT_TYPE_REMOVED;
+ if (V) Log.v(TAG," sent EVENT_TYPE_REMOVED");
+ }
+ Event evt = new Event(eventType, msg.id, getSmsFolderName(msg.type), null,
mSmsType);
sendEvent(evt);
listChanged = true;
diff --git a/src/com/android/bluetooth/map/BluetoothMapFolderElement.java b/src/com/android/bluetooth/map/BluetoothMapFolderElement.java
index 560558e..6867b56 100644
--- a/src/com/android/bluetooth/map/BluetoothMapFolderElement.java
+++ b/src/com/android/bluetooth/map/BluetoothMapFolderElement.java
@@ -40,6 +40,7 @@
private String mName;
private BluetoothMapFolderElement mParent = null;
private long mFolderId = -1;
+ private int mFolderType = -1;
private boolean mHasSmsMmsContent = false;
private boolean mHasImContent = false;
private boolean mHasEmailContent = false;
@@ -128,6 +129,17 @@
return sb.toString();
}
+ public void setFolderType(int folderType) {
+ this.mFolderType = folderType;
+ }
+
+ /**
+ * Return folder typ info
+ * @return a integer for email type.
+ */
+ public int getFolderType() {
+ return mFolderType;
+ }
public BluetoothMapFolderElement getFolderByName(String name) {
BluetoothMapFolderElement folderElement = this.getRoot();
diff --git a/src/com/android/bluetooth/map/BluetoothMapMasInstance.java b/src/com/android/bluetooth/map/BluetoothMapMasInstance.java
index e3df91f..8e0b2d3 100644
--- a/src/com/android/bluetooth/map/BluetoothMapMasInstance.java
+++ b/src/com/android/bluetooth/map/BluetoothMapMasInstance.java
@@ -26,6 +26,7 @@
import com.android.bluetooth.BluetoothObexTransport;
import com.android.bluetooth.IObexConnectionHandler;
import com.android.bluetooth.ObexServerSockets;
+import com.android.bluetooth.Utils;
import com.android.bluetooth.map.BluetoothMapContentObserver.Msg;
import com.android.bluetooth.map.BluetoothMapUtils.TYPE;
import com.android.bluetooth.sdp.SdpManager;
@@ -56,6 +57,10 @@
/* TODO: Should these be adaptive for each MAS? - e.g. read from app? */
static final int SDP_MAP_MAS_FEATURES = 0x0000007F;
+ // Adv map version and supported features
+ private final int SDP_MAP_MAS_FEATURES_ADV = 0x603ff;
+ private final int SDP_MAP_MAS_VERSION_ADV = 0x0103;
+ private int mPeerProfileVersion = -1;
private ServerSession mServerSession = null;
// The handle to the socket registration with SDP
private ObexServerSockets mServerSockets = null;
@@ -80,7 +85,7 @@
private int mMasInstanceId = -1;
private boolean mEnableSmsMms = false;
BluetoothMapContentObserver mObserver;
-
+ private BluetoothMapObexServer mapServer;
private AtomicLong mDbIndetifier = new AtomicLong();
private AtomicLong mFolderVersionCounter = new AtomicLong(0);
private AtomicLong mSmsMmsConvoListVersionCounter = new AtomicLong(0);
@@ -287,9 +292,12 @@
mAcceptNewConnections = true;
} else {
- mServerSockets = ObexServerSockets.create(this);
- mAcceptNewConnections = true;
+ mServerSockets = ObexServerSockets.createWithFixedChannels(this,
+ (SdpManager.MAP_RFCOMM_CHANNEL +
+ SdpManager.NEXT_RFCOMM_CHANNEL * mMasInstanceId),
+ (SdpManager.MAP_L2CAP_PSM + SdpManager.NEXT_L2CAP_CHANNEL * mMasInstanceId));
+ mAcceptNewConnections = true;
if (mServerSockets == null) {
// TODO: Handle - was not handled before
Log.e(mTag, "Failed to start the listeners");
@@ -360,14 +368,29 @@
}
mMnsClient = mnsClient;
- BluetoothMapObexServer mapServer;
- mObserver = new BluetoothMapContentObserver(mContext, mMnsClient, this, mAccount,
- mEnableSmsMms);
- mObserver.init();
- mapServer =
- new BluetoothMapObexServer(mServiceHandler, mContext, mObserver, this, mAccount,
- mEnableSmsMms);
+ if (mAccount != null && mAccount.getType() == TYPE.EMAIL) {
+ Log.d(mTag, "startObexServerSession getType = " + mAccount.getType());
+ mObserver = new BluetoothMapContentObserverEmail(mContext,
+ mMnsClient,
+ this,
+ mAccount,
+ mEnableSmsMms);
+ } else {
+ mObserver = new BluetoothMapContentObserver(mContext,
+ mMnsClient,
+ this,
+ mAccount,
+ mEnableSmsMms);
+ }
+ mObserver.init();
+ mapServer = new BluetoothMapObexServer(mServiceHandler,
+ mContext,
+ mObserver,
+ this,
+ mAccount,
+ mEnableSmsMms);
+ mapServer.setRemoteFeatureMask(mRemoteFeatureMask);
// setup transport
BluetoothObexTransport transport = new BluetoothObexTransport(mConnSocket);
mServerSession = new ServerSession(transport, mapServer, null);
@@ -398,7 +421,7 @@
return (mConnSocket != null);
}
- public void shutdown() {
+ public synchronized void shutdown() {
if (D) {
Log.d(mTag, "MAP Service shutdown");
}
@@ -432,6 +455,7 @@
private synchronized void closeServerSockets(boolean block) {
+ if(V) Log.d(mTag, "closeServerSock");
// exit SocketAcceptThread early
ObexServerSockets sockets = mServerSockets;
if (sockets != null) {
@@ -441,6 +465,7 @@
}
private synchronized void closeConnectionSocket() {
+ if(V) Log.d(mTag, "closeConnectionSock");
if (mConnSocket != null) {
try {
mConnSocket.close();
@@ -452,16 +477,34 @@
}
}
- public void setRemoteFeatureMask(int supportedFeatures) {
- if (V) {
- Log.v(mTag, "setRemoteFeatureMask : Curr: " + mRemoteFeatureMask);
+ public void setRemoteFeatureMask(int supportedFeatures, int remoteProfileVersion,
+ BluetoothDevice rd) {
+ if (D) Log.d(mTag, "setRemoteFeatureMask supportedFeatures "
+ + Integer.toHexString(supportedFeatures) +", remoteProfileVersion: "
+ + Integer.toHexString(remoteProfileVersion));
+ mPeerProfileVersion = remoteProfileVersion;
+ if (Utils.isPtsTestMode()) {
+ mRemoteFeatureMask =
+ SDP_MAP_MAS_FEATURES_ADV;
+ } else if ((remoteProfileVersion > SDP_MAP_MAS_VERSION_ADV)
+ && (!BluetoothMapFixes.isMapAdvDisabled() && BluetoothMapFixes.isRebonded(rd))){
+ mRemoteFeatureMask =
+ supportedFeatures & SDP_MAP_MAS_FEATURES_ADV;
+ } else {
+ mRemoteFeatureMask =
+ supportedFeatures & SDP_MAP_MAS_FEATURES;
}
- mRemoteFeatureMask = supportedFeatures & SDP_MAP_MAS_FEATURES;
+ BluetoothMapUtils.setUtcTimeStamp(mRemoteFeatureMask);
+
+ if (mapServer != null) {
+ mapServer.setRemoteFeatureMask(mRemoteFeatureMask);
+ }
if (mObserver != null) {
mObserver.setObserverRemoteFeatureMask(mRemoteFeatureMask);
- if (V) {
- Log.v(mTag, "setRemoteFeatureMask : set: " + mRemoteFeatureMask);
- }
+ }
+ if (D) {
+ Log.v(mTag, "setRemoteFeatureMask : modified mRemoteFeatureMask: "
+ + Integer.toHexString(mRemoteFeatureMask));
}
}
@@ -469,6 +512,10 @@
return this.mRemoteFeatureMask;
}
+ public int getRemoteProfileVersion() {
+ return mPeerProfileVersion;
+ }
+
@Override
public synchronized boolean onConnect(BluetoothDevice device, BluetoothSocket socket) {
if (!mAcceptNewConnections) {
@@ -477,6 +524,7 @@
/* Signal to the service that we have received an incoming connection.
*/
boolean isValid = mMapService.onConnect(device, BluetoothMapMasInstance.this);
+ if(V) Log.d(mTag, "onConnect");
if (isValid) {
mRemoteDevice = device;
diff --git a/src/com/android/bluetooth/map/BluetoothMapMessageListingElement.java b/src/com/android/bluetooth/map/BluetoothMapMessageListingElement.java
index 17fc549..8e8f216 100644
--- a/src/com/android/bluetooth/map/BluetoothMapMessageListingElement.java
+++ b/src/com/android/bluetooth/map/BluetoothMapMessageListingElement.java
@@ -288,7 +288,8 @@
}
if (mDateTime != 0) {
- xmlMsgElement.attribute(null, "datetime", this.getDateTimeString());
+ xmlMsgElement.attribute(null, "datetime",
+ BluetoothMapUtils.getDateTimeString(this.getDateTime()));
}
if (mSenderName != null) {
xmlMsgElement.attribute(null, "sender_name",
diff --git a/src/com/android/bluetooth/map/BluetoothMapObexServer.java b/src/com/android/bluetooth/map/BluetoothMapObexServer.java
index afd1eb0..406cae5 100644
--- a/src/com/android/bluetooth/map/BluetoothMapObexServer.java
+++ b/src/com/android/bluetooth/map/BluetoothMapObexServer.java
@@ -32,6 +32,7 @@
import com.android.bluetooth.SignedLongLong;
import com.android.bluetooth.map.BluetoothMapUtils.TYPE;
import com.android.bluetooth.mapapi.BluetoothMapContract;
+import com.android.bluetooth.mapapi.BluetoothMapEmailContract;
import java.io.IOException;
import java.io.InputStream;
@@ -156,12 +157,17 @@
}
mProviderClient = acquireUnstableContentProviderOrThrow();
}
+ if (account != null && account.getType() == TYPE.EMAIL) {
+ mOutContent = new BluetoothMapContentEmail(mContext, mAccount, mMasInstance);
+ } else {
+ mOutContent = new BluetoothMapContent(mContext, mAccount, mMasInstance);
+ }
buildFolderStructure(); /* Build the default folder structure, and set
mCurrentFolder to root folder */
mObserver.setFolderStructure(mCurrentFolder.getRoot());
- mOutContent = new BluetoothMapContent(mContext, mAccount, mMasInstance);
+
}
@@ -214,12 +220,12 @@
if (mEnableSmsMms) {
addSmsMmsFolders(tmpFolder);
}
- if (hasEmail) {
- if (D) {
- Log.d(TAG, "buildFolderStructure(): " + mEmailFolderUri.toString());
- }
- addEmailFolders(tmpFolder);
+
+ if (hasEmail && (mOutContent instanceof BluetoothMapContentEmail)) {
+ if (D) Log.d(TAG, "buildFolderStructure(): " + mEmailFolderUri.toString());
+ ((BluetoothMapContentEmail)mOutContent).addEmailFolders(tmpFolder);
}
+
if (hasIM) {
addImFolders(tmpFolder);
}
@@ -319,11 +325,13 @@
}
public void setRemoteFeatureMask(int mRemoteFeatureMask) {
- if (D) {
- Log.d(TAG, "setRemoteFeatureMask() " + Integer.toHexString(mRemoteFeatureMask));
- }
this.mRemoteFeatureMask = mRemoteFeatureMask;
this.mOutContent.setRemoteFeatureMask(mRemoteFeatureMask);
+ if ((mRemoteFeatureMask & BluetoothMapUtils.MAP_FEATURE_MESSAGE_FORMAT_V11_BIT)
+ == BluetoothMapUtils.MAP_FEATURE_MESSAGE_FORMAT_V11_BIT) {
+ mMessageVersion = BluetoothMapUtils.MAP_V11_STR;
+ }
+ if (D) Log.d(TAG," setRemoteFeatureMask mMessageVersion :" + mMessageVersion);
}
@Override
@@ -396,8 +404,8 @@
mMessageVersion = BluetoothMapUtils.MAP_V11_STR;
}
- if (V) {
- Log.v(TAG, "onConnect(): uuid is ok, will send out " + "MSG_SESSION_ESTABLISHED msg.");
+ if (D) {
+ Log.d(TAG, "onConnect(): uuid is ok mMessageVersion :" + mMessageVersion);
}
if (mCallback != null) {
@@ -474,6 +482,11 @@
if (V) {
Log.d(TAG, "TYPE_MESSAGE_UPDATE:");
}
+ if (mAccount!= null && mAccount.getType() == TYPE.EMAIL &&
+ (mOutContent instanceof BluetoothMapContentEmail)) {
+ ((BluetoothMapContentEmail)mOutContent).msgUpdate();
+ return ResponseCodes.OBEX_HTTP_OK;
+ }
return updateInbox();
} else if (type.equals(TYPE_SET_NOTIFICATION_REGISTRATION)) {
if (V) {
@@ -660,7 +673,8 @@
folderName = folderElement.getName();
}
if (!folderName.equalsIgnoreCase(BluetoothMapContract.FOLDER_NAME_OUTBOX) && !folderName
- .equalsIgnoreCase(BluetoothMapContract.FOLDER_NAME_DRAFT)) {
+ .equalsIgnoreCase(BluetoothMapContract.FOLDER_NAME_DRAFT) &&
+ !folderName.equalsIgnoreCase(BluetoothMapEmailContract.FOLDER_NAME_DRAFTS)) {
if (D) {
Log.d(TAG, "pushMessage: Is only allowed to outbox and draft. " + "folderName="
+ folderName);
@@ -783,6 +797,7 @@
long handle;
BluetoothMapUtils.TYPE msgType;
+ if (D) Log.d(TAG, "setMessageStatus():");
if (msgHandle == null) {
return ResponseCodes.OBEX_HTTP_PRECON_FAILED;
@@ -948,10 +963,16 @@
mCurrentFolder = mCurrentFolder.getRoot();
}
} else {
+ if (mAccount!= null && mAccount.getType() == TYPE.EMAIL) {
+ if (folderName.equalsIgnoreCase(BluetoothMapContract.FOLDER_NAME_DRAFT)) {
+ folderName = BluetoothMapEmailContract.FOLDER_NAME_DRAFTS;
+ }
+ }
folder = mCurrentFolder.getSubFolder(folderName);
if (folder != null) {
mCurrentFolder = folder;
} else {
+ Log.w(TAG,"SubFolder Not found! : " + mCurrentFolder.getName());
return ResponseCodes.OBEX_HTTP_BAD_REQUEST;
}
}
@@ -974,7 +995,7 @@
}
if (mProviderClient != null) {
- mProviderClient.release();
+ mProviderClient.close();
mProviderClient = null;
}
@@ -1519,8 +1540,20 @@
if (maxListCount == BluetoothMapAppParams.INVALID_VALUE_PARAMETER) {
maxListCount = 1024;
}
-
- if (maxListCount != 0) {
+ try {
+ if ( (mAccount != null && mAccount.getType() == TYPE.EMAIL) &&
+ (mOutContent instanceof BluetoothMapContentEmail) &&
+ !mCurrentFolder.getName().equals("telecom") &&
+ !mCurrentFolder.getName().equals("root")) {
+ if (D) Log.d(TAG, "RefreshFolderStructure(): " + mCurrentFolder.getName());
+ ((BluetoothMapContentEmail)mOutContent).addEmailFolders(mCurrentFolder);
+ }
+ } catch( RemoteException e1) {
+ Log.v(TAG,"sendFolderList Refresh failed : Go with existing for :"
+ + mCurrentFolder.getName());
+ }
+ if(maxListCount != 0)
+ {
outBytes = mCurrentFolder.encode(listStartOffset, maxListCount);
} else {
// ESR08 specified that this shall only be included for MaxListCount=0
diff --git a/src/com/android/bluetooth/map/BluetoothMapService.java b/src/com/android/bluetooth/map/BluetoothMapService.java
index cc42b60..5c81376 100644
--- a/src/com/android/bluetooth/map/BluetoothMapService.java
+++ b/src/com/android/bluetooth/map/BluetoothMapService.java
@@ -29,6 +29,7 @@
import android.content.Intent;
import android.content.IntentFilter;
import android.content.IntentFilter.MalformedMimeTypeException;
+import android.Manifest;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
@@ -36,6 +37,8 @@
import android.os.ParcelUuid;
import android.os.PowerManager;
import android.os.RemoteException;
+import android.os.SystemProperties;
+import android.provider.Settings;
import android.text.TextUtils;
import android.util.Log;
import android.util.SparseArray;
@@ -56,7 +59,7 @@
public class BluetoothMapService extends ProfileService {
private static final String TAG = "BluetoothMapService";
-
+ private static final String LOG_TAG = "BluetoothMap";
/**
* To enable MAP DEBUG/VERBOSE logging - run below cmd in adb shell, and
* restart com.android.bluetooth process. only enable DEBUG log:
@@ -66,7 +69,7 @@
public static final boolean DEBUG = true; //FIXME set to false;
- public static final boolean VERBOSE = false;
+ public static final boolean VERBOSE = Log.isLoggable(LOG_TAG, Log.VERBOSE);
/**
* Intent indicating timeout for user confirmation, which is sent to
@@ -97,8 +100,8 @@
private static final int USER_TIMEOUT = 2;
private static final int DISCONNECT_MAP = 3;
private static final int SHUTDOWN = 4;
- private static final int UPDATE_MAS_INSTANCES = 5;
-
+ private static final int UPDATE_MAS_INSTANCES = 6;
+ private static final int CREATE_MAS_INSTANCES = 5;
private static final int RELEASE_WAKE_LOCK_DELAY = 10000;
private PowerManager.WakeLock mWakeLock = null;
@@ -123,11 +126,11 @@
// The remote connected device - protect access
private static BluetoothDevice sRemoteDevice = null;
- private ArrayList<BluetoothMapAccountItem> mEnabledAccounts = null;
+ ArrayList<BluetoothMapAccountItem> mEnabledAccounts = null;
private static String sRemoteDeviceName = null;
private int mState;
- private BluetoothMapAppObserver mAppObserver = null;
+ BluetoothMapAppObserver mAppObserver = null;
private AlarmManager mAlarmManager = null;
private boolean mIsWaitingAuthorization = false;
@@ -195,7 +198,7 @@
}
mSessionStatusHandler = null;
- if (VERBOSE) {
+ if (DEBUG) {
Log.v(TAG, "MAP Service closeService out");
}
}
@@ -268,7 +271,7 @@
mSessionStatusHandler.obtainMessage(MSG_RELEASE_WAKE_LOCK),
RELEASE_WAKE_LOCK_DELAY);
- if (VERBOSE) {
+ if (DEBUG) {
Log.v(TAG, "startObexServerSessions() success!");
}
}
@@ -283,7 +286,7 @@
*/
private void stopObexServerSessions(int masId) {
if (DEBUG) {
- Log.d(TAG, "MAP Service STOP ObexServerSessions()");
+ Log.d(TAG, "MAP Service STOP ObexServerSessions() masId: " + masId);
}
boolean lastMasInst = true;
@@ -298,9 +301,13 @@
} // Else just close down it all
// Shutdown the MNS client - this must happen before MAS close
- if (mBluetoothMnsObexClient != null && lastMasInst) {
- mBluetoothMnsObexClient.shutdown();
- mBluetoothMnsObexClient = null;
+ if (mBluetoothMnsObexClient != null ) {
+ if (lastMasInst) {
+ mBluetoothMnsObexClient.shutdown();
+ mBluetoothMnsObexClient = null;
+ } else if(masId != -1 && mMasInstances != null) {
+ BluetoothMapFixes.handleMnsShutdown(mMasInstances,masId);
+ }
}
BluetoothMapMasInstance masInst = mMasInstances.get(masId); // returns null for -1
@@ -333,17 +340,23 @@
}
private final class MapServiceMessageHandler extends Handler {
- private MapServiceMessageHandler(Looper looper) {
+ Context mContxt;
+ private MapServiceMessageHandler(Context contxt, Looper looper) {
super(looper);
+ mContxt = contxt;
}
@Override
public void handleMessage(Message msg) {
- if (VERBOSE) {
+ if (DEBUG) {
Log.v(TAG, "Handler(): got msg=" + msg.what);
}
switch (msg.what) {
+ case CREATE_MAS_INSTANCES:
+ Log.d(TAG, "CREATE_MAS_INSTANCES ");
+ BluetoothMapFixes.createMasInstances(BluetoothMapService.this);
+ break;
case UPDATE_MAS_INSTANCES:
updateMasInstancesHandler();
break;
@@ -600,7 +613,7 @@
HandlerThread thread = new HandlerThread("BluetoothMapHandler");
thread.start();
Looper looper = thread.getLooper();
- mSessionStatusHandler = new MapServiceMessageHandler(looper);
+ mSessionStatusHandler = new MapServiceMessageHandler(this, looper);
IntentFilter filter = new IntentFilter();
filter.addAction(BluetoothDevice.ACTION_CONNECTION_ACCESS_REPLY);
@@ -618,17 +631,26 @@
Log.e(TAG, "Wrong mime type!!!", e);
}
if (!mRegisteredMapReceiver) {
- registerReceiver(mMapReceiver, filter);
- registerReceiver(mMapReceiver, filterMessageSent);
- mRegisteredMapReceiver = true;
+ try {
+ registerReceiver(mMapReceiver, filter);
+ // We need WRITE_SMS permission to handle messages in
+ // actionMessageSentDisconnected()
+ registerReceiver(mMapReceiver, filterMessageSent,
+ Manifest.permission.WRITE_SMS, null);
+ mRegisteredMapReceiver = true;
+ } catch (Exception e) {
+ Log.e(TAG,"Unable to register map receiver",e);
+ }
}
mAdapter = BluetoothAdapter.getDefaultAdapter();
- mAppObserver = new BluetoothMapAppObserver(this, this);
+
+ // Move SDP records creation to Handler Thread instead of main thread.
+ BluetoothMapFixes.sendCreateMasInstances(this, CREATE_MAS_INSTANCES);
mSmsCapable = getResources().getBoolean(com.android.internal.R.bool.config_sms_capable);
-
- mEnabledAccounts = mAppObserver.getEnabledAccountItems();
- createMasInstances(); // Uses mEnabledAccounts
+ if (DEBUG) {
+ Log.d(TAG, "mSmsCapable :" + mSmsCapable);
+ }
sendStartListenerMessage(-1);
setBluetoothMapService(this);
@@ -690,8 +712,9 @@
if (DEBUG) {
Log.d(TAG, "updateMasInstancesHandler() state = " + getState());
}
-
- if (getState() != BluetoothMap.STATE_DISCONNECTED) {
+ if (BluetoothMapFixes.checkMapAppObserver(mAppObserver))
+ return;
+ if (getState() == BluetoothMap.STATE_CONNECTING) {
mAccountChanged = true;
return;
}
@@ -699,6 +722,10 @@
ArrayList<BluetoothMapAccountItem> newAccountList = mAppObserver.getEnabledAccountItems();
ArrayList<BluetoothMapAccountItem> newAccounts = new ArrayList<>();
+ Log.d(TAG, "new Account List size = " + newAccountList.size());
+ SystemProperties.set("vendor.bluetooth.emailaccountcount",
+ String.valueOf(newAccountList.size()));
+
for (BluetoothMapAccountItem account : newAccountList) {
if (!mEnabledAccounts.remove(account)) {
newAccounts.add(account);
@@ -776,7 +803,7 @@
return 0xff; // This will never happen, as we only allow 10 e-mail accounts to be enabled
}
- private void createMasInstances() {
+ void createMasInstances() {
int masId = MAS_ID_SMS_MMS;
if (mSmsCapable) {
@@ -788,13 +815,15 @@
masId++;
}
- // get list of accounts already set to be visible through MAP
- for (BluetoothMapAccountItem account : mEnabledAccounts) {
- BluetoothMapMasInstance newInst =
- new BluetoothMapMasInstance(this, this, account, masId, false);
- mMasInstances.append(masId, newInst);
- mMasInstanceMap.put(account, newInst);
- masId++;
+ if (mEnabledAccounts != null) {
+ // get list of accounts already set to be visible through MAP
+ for (BluetoothMapAccountItem account : mEnabledAccounts) {
+ BluetoothMapMasInstance newInst =
+ new BluetoothMapMasInstance(this, this, account, masId, false);
+ mMasInstances.append(masId, newInst);
+ mMasInstanceMap.put(account, newInst);
+ masId++;
+ }
}
}
@@ -814,8 +843,10 @@
if (mRegisteredMapReceiver) {
mRegisteredMapReceiver = false;
unregisterReceiver(mMapReceiver);
- mAppObserver.shutdown();
+ if (mAppObserver != null)
+ mAppObserver.shutdown();
}
+ setState(BluetoothMap.STATE_DISCONNECTED, BluetoothMap.RESULT_CANCELED);
sendShutdownMessage();
return true;
}
@@ -851,7 +882,7 @@
sRemoteDevice.sdpSearch(BluetoothMnsObexClient.BLUETOOTH_UUID_OBEX_MNS);
mSdpSearchInitiated = true;
}
- } else if (!sRemoteDevice.equals(remoteDevice)) {
+ } else if (!remoteDevice.equals(sRemoteDevice)) {
Log.w(TAG, "Unexpected connection from a second Remote Device received. name: " + (
(remoteDevice == null) ? "unknown" : remoteDevice.getName()));
return false;
@@ -955,6 +986,7 @@
}
private void sendShutdownMessage() {
+ if (VERBOSE) Log.d(TAG, "sendShutdownMessage() In");
// Pending messages are no longer valid. To speed up things, simply delete them.
if (mRemoveTimeoutMsg) {
Intent timeoutIntent = new Intent(USER_CONFIRM_TIMEOUT_ACTION);
@@ -1050,6 +1082,8 @@
Log.d(TAG, "Received ACTION_SDP_RECORD.");
}
ParcelUuid uuid = intent.getParcelableExtra(BluetoothDevice.EXTRA_UUID);
+ BluetoothDevice remoteDevice = intent.getParcelableExtra(
+ BluetoothDevice.EXTRA_DEVICE);
if (VERBOSE) {
Log.v(TAG, "Received UUID: " + uuid.toString());
Log.v(TAG, "expected UUID: "
@@ -1066,9 +1100,11 @@
mBluetoothMnsObexClient.setMnsRecord(mMnsRecord);
}
if (status != -1 && mMnsRecord != null) {
+ BluetoothMapFixes.showNotification(BluetoothMapService.this, remoteDevice);
for (int i = 0, c = mMasInstances.size(); i < c; i++) {
mMasInstances.valueAt(i)
- .setRemoteFeatureMask(mMnsRecord.getSupportedFeatures());
+ .setRemoteFeatureMask(mMnsRecord.getSupportedFeatures(),
+ mMnsRecord.getProfileVersion(), remoteDevice);
}
}
if (mSdpSearchInitiated) {
@@ -1097,23 +1133,27 @@
}
if (!handled) {
// Move the SMS to the correct folder.
- BluetoothMapContentObserver.actionMessageSentDisconnected(context, intent,
- result);
+ try {
+ BluetoothMapContentObserver.actionMessageSentDisconnected(context, intent,
+ result);
+ } catch(IllegalArgumentException e) {
+ return;
+ }
}
- } else if (action.equals(BluetoothDevice.ACTION_ACL_DISCONNECTED)
- && mIsWaitingAuthorization) {
+ } else if (action.equals(BluetoothDevice.ACTION_ACL_DISCONNECTED)) {
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
if (sRemoteDevice == null || device == null) {
- Log.e(TAG, "Unexpected error!");
+ Log.i(TAG, "sRemoteDevice :" + sRemoteDevice + " device:" + device);
return;
}
if (VERBOSE) {
- Log.v(TAG, "ACL disconnected for " + device);
+ Log.v(TAG, "ACL disconnected for " + device
+ + " mIsWaitingAuthorization :" + mIsWaitingAuthorization);
}
- if (sRemoteDevice.equals(device)) {
+ if (mIsWaitingAuthorization && device.equals(sRemoteDevice)) {
// Send any pending timeout now, since ACL got disconnected
mSessionStatusHandler.removeMessages(USER_TIMEOUT);
mSessionStatusHandler.obtainMessage(USER_TIMEOUT).sendToTarget();
@@ -1282,7 +1322,8 @@
println(sb, "mRemoteDevice: " + sRemoteDevice);
println(sb, "sRemoteDeviceName: " + sRemoteDeviceName);
println(sb, "mState: " + mState);
- println(sb, "mAppObserver: " + mAppObserver);
+ if (mAppObserver != null)
+ println(sb, "mAppObserver: " + mAppObserver);
println(sb, "mIsWaitingAuthorization: " + mIsWaitingAuthorization);
println(sb, "mRemoveTimeoutMsg: " + mRemoveTimeoutMsg);
println(sb, "mPermission: " + mPermission);
@@ -1293,8 +1334,10 @@
println(sb, " " + key + " : " + mMasInstanceMap.get(key));
}
println(sb, "mEnabledAccounts:");
- for (BluetoothMapAccountItem account : mEnabledAccounts) {
- println(sb, " " + account);
+ if (mEnabledAccounts != null) {
+ for (BluetoothMapAccountItem account : mEnabledAccounts) {
+ println(sb, " " + account);
+ }
}
}
}
diff --git a/src/com/android/bluetooth/map/BluetoothMapUtils.java b/src/com/android/bluetooth/map/BluetoothMapUtils.java
index e867bd6..d973666 100644
--- a/src/com/android/bluetooth/map/BluetoothMapUtils.java
+++ b/src/com/android/bluetooth/map/BluetoothMapUtils.java
@@ -96,6 +96,8 @@
static final int MAP_MESSAGE_LISTING_FORMAT_V10 = 10; // MAP spec below 1.3
static final int MAP_MESSAGE_LISTING_FORMAT_V11 = 11; // MAP spec 1.3
+ private static boolean mSupportUtcTimeStamp = false;
+
/**
* This enum is used to convert from the bMessage type property to a type safe
* type. Hence do not change the names of the enum values.
@@ -112,13 +114,21 @@
}
}
- public static String getDateTimeString(long timestamp) {
- SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd'T'HHmmss");
- Date date = new Date(timestamp);
- return format.format(date); // Format to YYYYMMDDTHHMMSS local time
+ public static String getDateTimeString( long timestamp) {
+ String time = "";
+ if (mSupportUtcTimeStamp) {
+ SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd'T'HHmmssZ");
+ Date date = new Date(timestamp);
+ time = format.format(date); // Format to YYYYMMDDTHHMMSS±hhmm UTC time ± offset
+ } else {
+ SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd'T'HHmmss");
+ Date date = new Date(timestamp);
+ time = format.format(date); // Format to YYYYMMDDTHHMMSS local time
+ }
+ if (V) Log.v(TAG, "getDateTimeString timestamp :" + timestamp + " time:" + time);
+ return time;
}
-
public static void printCursor(Cursor c) {
if (D) {
StringBuilder sb = new StringBuilder();
@@ -671,5 +681,15 @@
}
}
+ public static void setUtcTimeStamp(int remoteFeatureMask) {
+ if ((remoteFeatureMask & MAP_FEATURE_DEFINED_TIMESTAMP_FORMAT_BIT)
+ == MAP_FEATURE_DEFINED_TIMESTAMP_FORMAT_BIT) {
+ mSupportUtcTimeStamp = true;
+ } else {
+ mSupportUtcTimeStamp = false;
+ }
+ if (V) Log.v(TAG, "setUtcTimeStamp " + mSupportUtcTimeStamp);
+ }
+
}
diff --git a/src/com/android/bluetooth/map/BluetoothMapbMessage.java b/src/com/android/bluetooth/map/BluetoothMapbMessage.java
index e222aa9..55e5933 100644
--- a/src/com/android/bluetooth/map/BluetoothMapbMessage.java
+++ b/src/com/android/bluetooth/map/BluetoothMapbMessage.java
@@ -30,6 +30,7 @@
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
+import com.android.bluetooth.map.BluetoothMapCommonUtils.BMsgReaderExt;
public abstract class BluetoothMapbMessage {
protected static final String TAG = "BluetoothMapbMessage";
@@ -58,7 +59,9 @@
private ArrayList<VCard> mOriginator = null;
private ArrayList<VCard> mRecipient = null;
-
+ private ArrayList<String> mRecipientTo = null;
+ private ArrayList<String> mRecipientCc = null;
+ private ArrayList<String> mRecipientBCc = null;
public static class VCard {
/* VCARD attributes */
@@ -194,6 +197,13 @@
}
}
+ public String[] getEmailAddresses() {
+ if (mEmailAddresses.length > 0) {
+ return mEmailAddresses;
+ } else
+ throw new IllegalArgumentException("No Recipient Email Address");
+ }
+
public String getFirstBtUci() {
if (mBtUcis.length > 0) {
return mBtUcis[0];
@@ -279,6 +289,7 @@
}
// Empty phone number - ignore
} else if (line.startsWith("EMAIL:")) {
+ line = line.replace("<", "<").replace(">", ">");
parts = line.split("[^\\\\]:"); // Split on "un-escaped" :
if (parts.length == 2) {
String[] subParts = parts[1].split("[^\\\\];");
@@ -323,7 +334,7 @@
;
- private static class BMsgReader {
+ protected static class BMsgReader {
InputStream mInStream;
BMsgReader(InputStream is) {
@@ -371,15 +382,14 @@
/**
* Read a line of text from the BMessage.
* @return the next line of text, or null at end of file, or if UTF-8 is not supported.
+ * @hide
*/
public String getLine() {
try {
byte[] line = getLineAsBytes();
- if (line.length == 0) {
+ if (BluetoothMapFixes.isLastLine(line))
return null;
- } else {
- return new String(line, "UTF-8");
- }
+ return new String(line, "UTF-8");
} catch (UnsupportedEncodingException e) {
Log.w(TAG, e);
return null;
@@ -485,7 +495,7 @@
public static BluetoothMapbMessage parse(InputStream bMsgStream, int appParamCharset)
throws IllegalArgumentException {
- BMsgReader reader;
+ BMsgReaderExt reader;
String line = "";
BluetoothMapbMessage newBMsg = null;
boolean status = false;
@@ -561,7 +571,7 @@
Log.i(TAG, "The incoming bMessage have been dumped to " + file.getAbsolutePath());
} /* End of if(V) log-section */
- reader = new BMsgReader(bMsgStream);
+ reader = new BluetoothMapCommonUtils.BMsgReaderExt(bMsgStream);
reader.expect("BEGIN:BMSG");
reader.expect("VERSION");
@@ -610,7 +620,7 @@
newBMsg = new BluetoothMapbMessageMime();
break;
case EMAIL:
- newBMsg = new BluetoothMapbMessageEmail();
+ newBMsg = new BluetoothMapbMessageExtEmail();
break;
case IM:
newBMsg = new BluetoothMapbMessageMime();
@@ -654,6 +664,10 @@
}
if (line.contains("BEGIN:BENV")) {
newBMsg.parseEnvelope(reader, 0);
+ if ( type == TYPE.EMAIL && newBMsg instanceof BluetoothMapbMessageExtEmail) {
+ ((BluetoothMapbMessageExtEmail)newBMsg)
+ .parseBodyEmail(reader.getLastStringTerminator("END:BBODY"));
+ }
} else {
throw new IllegalArgumentException("Bmessage has no BEGIN:BENV - line:" + line);
}
@@ -697,7 +711,7 @@
}
parseEnvelope(reader, ++level); // Nested BENV
}
- if (line.contains("BEGIN:BBODY")) {
+ if (mType != TYPE.EMAIL && line.contains("BEGIN:BBODY")) {
if (D) {
Log.d(TAG, "Decoding bbody");
}
@@ -1064,4 +1078,26 @@
return null;
}
}
+ public ArrayList<String> getmRecipientTo() {
+ return mRecipientTo;
+ }
+
+ public void setmRecipientTo(ArrayList<String> mRecipientTo) {
+ this.mRecipientTo = mRecipientTo;
+ }
+ public ArrayList<String> getmRecipientCc() {
+ return mRecipientCc;
+ }
+
+ public void setmRecipientCc(ArrayList<String> mRecipientCc) {
+ this.mRecipientCc = mRecipientCc;
+ }
+
+ public ArrayList<String> getmRecipientBCc() {
+ return mRecipientBCc;
+ }
+
+ public void setmRecipientBCc(ArrayList<String> mRecipientBCc) {
+ this.mRecipientBCc = mRecipientBCc;
+ }
}
diff --git a/src/com/android/bluetooth/map/BluetoothMapbMessageMime.java b/src/com/android/bluetooth/map/BluetoothMapbMessageMime.java
index a247bff..1101ba0 100644
--- a/src/com/android/bluetooth/map/BluetoothMapbMessageMime.java
+++ b/src/com/android/bluetooth/map/BluetoothMapbMessageMime.java
@@ -153,7 +153,7 @@
private ArrayList<Rfc822Token> mBcc = null; // Can be empty
private ArrayList<Rfc822Token> mReplyTo = null; // Can be empty
private String mMessageId = null;
- private ArrayList<MimePart> mParts = null;
+ ArrayList<MimePart> mParts = null;
private String mContentType = null;
private String mBoundary = null;
private boolean mTextonly = false;
@@ -161,7 +161,7 @@
private boolean mHasHeaders = false;
private String mMyEncoding = null;
- private String getBoundary() {
+ String getBoundary() {
// Include "=_" as these cannot occur in quoted printable text
if (mBoundary == null) {
mBoundary = "--=_" + UUID.randomUUID();
diff --git a/src/com/android/bluetooth/mapclient/MnsService.java b/src/com/android/bluetooth/mapclient/MnsService.java
index b3317df..2344d86 100644
--- a/src/com/android/bluetooth/mapclient/MnsService.java
+++ b/src/com/android/bluetooth/mapclient/MnsService.java
@@ -60,7 +60,8 @@
}
sContext = context;
sAcceptThread = new SocketAcceptor();
- sServerSockets = ObexServerSockets.create(sAcceptThread);
+ sServerSockets = ObexServerSockets.createWithFixedChannels(sAcceptThread,
+ SdpManager.MNS_RFCOMM_CHANNEL, SdpManager.MNS_L2CAP_PSM);
SdpManager sdpManager = SdpManager.getDefaultManager();
if (sdpManager == null) {
Log.e(TAG, "SdpManager is null");
diff --git a/src/com/android/bluetooth/opp/BluetoothOppBatch.java b/src/com/android/bluetooth/opp/BluetoothOppBatch.java
index a66a667..824ded6 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppBatch.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppBatch.java
@@ -150,6 +150,7 @@
BluetoothOppShareInfo info = mShares.get(i);
if (info.mStatus < 200) {
+ BTOppUtils.updateFileNameInDb(mContext, info);
if (info.mDirection == BluetoothShare.DIRECTION_INBOUND && info.mFilename != null) {
new File(info.mFilename).delete();
}
diff --git a/src/com/android/bluetooth/opp/BluetoothOppBtEnableActivity.java b/src/com/android/bluetooth/opp/BluetoothOppBtEnableActivity.java
index 0253e24..42da777 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppBtEnableActivity.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppBtEnableActivity.java
@@ -106,7 +106,9 @@
super.onPause();
if (!mOppManager.mSendingFlag) {
+ BluetoothOppManager.isReadyForFileSharing = false;
mOppManager.cleanUpSendingFileInfo();
+ BluetoothOppManager.isReadyForFileSharing = true;
}
}
}
diff --git a/src/com/android/bluetooth/opp/BluetoothOppHandoverReceiver.java b/src/com/android/bluetooth/opp/BluetoothOppHandoverReceiver.java
index 6e83480..9a81ce8 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppHandoverReceiver.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppHandoverReceiver.java
@@ -32,7 +32,8 @@
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
-
+ if(D) Log.d(TAG, " Action :" + action);
+ if (action == null) return;
if (action.equals(Constants.ACTION_HANDOVER_SEND) || action.equals(
Constants.ACTION_HANDOVER_SEND_MULTIPLE)) {
final BluetoothDevice device =
diff --git a/src/com/android/bluetooth/opp/BluetoothOppIncomingFileConfirmActivity.java b/src/com/android/bluetooth/opp/BluetoothOppIncomingFileConfirmActivity.java
index 1b5ffe1..8eda73c 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppIncomingFileConfirmActivity.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppIncomingFileConfirmActivity.java
@@ -151,7 +151,7 @@
mUpdateValues.put(BluetoothShare.USER_CONFIRMATION,
BluetoothShare.USER_CONFIRMATION_CONFIRMED);
this.getContentResolver().update(mUri, mUpdateValues, null, null);
-
+ if (D) Log.v(TAG, " Confirmed :" + mUri);
Toast.makeText(this, getString(R.string.bt_toast_1), Toast.LENGTH_SHORT).show();
}
break;
@@ -162,6 +162,7 @@
mUpdateValues.put(BluetoothShare.USER_CONFIRMATION,
BluetoothShare.USER_CONFIRMATION_DENIED);
this.getContentResolver().update(mUri, mUpdateValues, null, null);
+ if (D) Log.v(TAG, " Denied :" + mUri);
break;
}
}
@@ -222,7 +223,7 @@
public void handleMessage(Message msg) {
switch (msg.what) {
case DISMISS_TIMEOUT_DIALOG:
- if (V) {
+ if (D) {
Log.v(TAG, "Received DISMISS_TIMEOUT_DIALOG msg.");
}
finish();
diff --git a/src/com/android/bluetooth/opp/BluetoothOppLauncherActivity.java b/src/com/android/bluetooth/opp/BluetoothOppLauncherActivity.java
index 03db259..d602f3b 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppLauncherActivity.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppLauncherActivity.java
@@ -61,7 +61,7 @@
* selection dialog.
*/
public class BluetoothOppLauncherActivity extends Activity {
- private static final String TAG = "BluetoothLauncherActivity";
+ private static final String TAG = "BluetoothOppLauncherActivity";
private static final boolean D = Constants.DEBUG;
private static final boolean V = Constants.VERBOSE;
@@ -99,6 +99,17 @@
return;
}
+ if (!BluetoothOppManager.isReadyForFileSharing) {
+ Log.i(TAG, " File share already in process, retrun with out any action ");
+ finish();
+ return;
+ }
+ /*
+ * SECURITY_EXCEPTION Google Photo grant-uri-permission
+ */
+ BTOppUtils.grantPermissionToUri(getApplicationContext(),
+ intent.getClipData());
+
/*
* Other application is trying to share a file via Bluetooth,
* probably Pictures, videos, or vCards. The Intent should contain
@@ -170,6 +181,7 @@
@Override
public void run() {
try {
+ BluetoothOppManager.isReadyForFileSharing = false;
BluetoothOppManager.getInstance(BluetoothOppLauncherActivity.this)
.saveSendingFileInfo(mimeType, uris, false /* isHandover */,
true /* fromExternal */);
@@ -178,7 +190,8 @@
launchDevicePicker();
finish();
} catch (IllegalArgumentException exception) {
- showToast(exception.getMessage());
+ Log.e(TAG, "SEND_MULTIPLE :" +exception.getMessage());
+ BluetoothOppManager.isReadyForFileSharing = true;
finish();
}
}
@@ -241,6 +254,7 @@
}
startActivity(in1);
}
+ BluetoothOppManager.isReadyForFileSharing = true;
}
/* Returns true if Bluetooth is allowed given current airplane mode settings. */
@@ -259,7 +273,7 @@
Settings.System.getString(resolver, Settings.Global.AIRPLANE_MODE_RADIOS);
final boolean isAirplaneSensitive =
airplaneModeRadios == null || airplaneModeRadios.contains(
- Settings.System.RADIO_BLUETOOTH);
+ Settings.Global.RADIO_BLUETOOTH);
if (!isAirplaneSensitive) {
return true;
}
@@ -414,12 +428,14 @@
boolean fromExternal) {
BluetoothOppManager manager = BluetoothOppManager.getInstance(getApplicationContext());
try {
+ BluetoothOppManager.isReadyForFileSharing = false;
manager.saveSendingFileInfo(mimeType, uriString, isHandover, fromExternal);
launchDevicePicker();
finish();
} catch (IllegalArgumentException exception) {
- showToast(exception.getMessage());
+ Log.e(TAG, "sendFileInfo :" + exception.getMessage());
finish();
+ BluetoothOppManager.isReadyForFileSharing = true;
}
}
diff --git a/src/com/android/bluetooth/opp/BluetoothOppManager.java b/src/com/android/bluetooth/opp/BluetoothOppManager.java
index 129d110..7d2d318 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppManager.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppManager.java
@@ -100,6 +100,8 @@
private static final int ALLOWED_INSERT_SHARE_THREAD_NUMBER = 3;
+ static boolean isReadyForFileSharing = true;
+
// used to judge if need continue sending process after received a
// ENABLED_ACTION
public boolean mSendingFlag;
@@ -194,6 +196,23 @@
return false;
}
+ synchronized void removeWhitelist(String address) {
+ Log.d(TAG, " removeWhitelist :" + address);
+ if (address == null) {
+ return;
+ }
+ // Remove any existing entries
+ for (Iterator<Pair<String, Long>> iter = mWhitelist.iterator(); iter.hasNext(); ) {
+ Pair<String, Long> entry = iter.next();
+ if (entry.first.equals(address)) {
+ iter.remove();
+ Log.i(TAG," removeWhitelist device found removed ");
+ }
+ }
+ Log.d(TAG," removeWhitelist END :");
+ }
+
+
/**
* Restore data from preference
*/
diff --git a/src/com/android/bluetooth/opp/BluetoothOppNotification.java b/src/com/android/bluetooth/opp/BluetoothOppNotification.java
index 41ffec3..ba47aeb 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppNotification.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppNotification.java
@@ -40,6 +40,7 @@
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
+import android.graphics.drawable.Icon;
import android.net.Uri;
import android.os.Handler;
import android.os.Message;
@@ -165,7 +166,7 @@
public void updateNotification() {
synchronized (BluetoothOppNotification.this) {
mPendingUpdate++;
- if (mPendingUpdate > 1) {
+ if ((mPendingUpdate > 1) && (mUpdateNotificationThread != null)) {
if (V) {
Log.v(TAG, "update too frequent, put in queue");
}
@@ -557,12 +558,14 @@
.setClassName(Constants.THIS_PACKAGE_NAME,
BluetoothOppReceiver.class.getName());
Notification.Action actionDecline =
- new Notification.Action.Builder(R.drawable.ic_decline,
+ new Notification.Action.Builder(Icon.createWithResource(mContext,
+ R.drawable.ic_decline),
mContext.getText(R.string.incoming_file_confirm_cancel),
PendingIntent.getBroadcast(mContext, 0,
new Intent(baseIntent).setAction(Constants.ACTION_DECLINE),
0)).build();
- Notification.Action actionAccept = new Notification.Action.Builder(R.drawable.ic_accept,
+ Notification.Action actionAccept = new Notification.Action.Builder(
+ Icon.createWithResource(mContext, R.drawable.ic_accept),
mContext.getText(R.string.incoming_file_confirm_ok),
PendingIntent.getBroadcast(mContext, 0,
new Intent(baseIntent).setAction(Constants.ACTION_ACCEPT), 0)).build();
@@ -589,11 +592,12 @@
.setStyle(new Notification.BigTextStyle().bigText(mContext.getString(
R.string.incoming_file_confirm_Notification_content,
info.mDeviceName, info.mFileName)))
- .setContentInfo(Formatter.formatFileSize(mContext, info.mTotalBytes))
+ .setSubText(Formatter.formatFileSize(mContext, info.mTotalBytes))
.setSmallIcon(R.drawable.bt_incomming_file_notification)
.setLocalOnly(true)
.build();
mNotificationMgr.notify(NOTIFICATION_ID_PROGRESS, n);
+ Log.i(TAG, " Incoming Notification ");
}
cursor.close();
}
diff --git a/src/com/android/bluetooth/opp/BluetoothOppObexClientSession.java b/src/com/android/bluetooth/opp/BluetoothOppObexClientSession.java
index 1d01646..ada8ab4 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppObexClientSession.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppObexClientSession.java
@@ -32,6 +32,7 @@
package com.android.bluetooth.opp;
+import android.bluetooth.BluetoothAdapter;
import android.content.ContentValues;
import android.content.Context;
import android.net.Uri;
@@ -80,12 +81,15 @@
private int mNumFilesAttemptedToSend;
+ private BluetoothAdapter mAdapter;
+
public BluetoothOppObexClientSession(Context context, ObexTransport transport) {
if (transport == null) {
throw new NullPointerException("transport is null");
}
mContext = context;
mTransport = transport;
+ mAdapter = BluetoothAdapter.getDefaultAdapter();
}
@Override
@@ -99,7 +103,7 @@
}
@Override
- public void stop() {
+ public synchronized void stop() {
if (D) {
Log.d(TAG, "Stop!");
}
@@ -110,7 +114,23 @@
if (V) {
Log.v(TAG, "waiting for thread to terminate");
}
- mThread.join();
+ if (mAdapter.getState() == BluetoothAdapter.STATE_TURNING_OFF) {
+ Log.d(TAG, "stop, bt is turning off");
+ mThread.join(1500);
+ if (mThread.isAlive()) {
+ Log.d(TAG, "stop, close the transport");
+ mThread.interrupt();
+ try {
+ mTransport.close();
+ } catch (IOException e) {
+ Log.e(TAG, "mTransport.close error");
+ }
+ Log.d(TAG, "stop, close the transport, done");
+ mThread.join();
+ }
+ } else {
+ mThread.join();
+ }
mThread = null;
} catch (InterruptedException e) {
if (V) {
@@ -490,7 +510,7 @@
if (responseCode == ResponseCodes.OBEX_HTTP_CONTINUE
|| responseCode == ResponseCodes.OBEX_HTTP_OK) {
- if (V) {
+ if (D) {
Log.v(TAG, "Remote accept");
}
okToProceed = true;
@@ -503,7 +523,7 @@
Log.i(TAG, "Remote reject, Response code is " + responseCode);
}
}
-
+ long beginTime = System.currentTimeMillis();
while (!mInterrupted && okToProceed && (position < fileInfo.mLength)) {
if (V) {
timestamp = SystemClock.elapsedRealtime();
@@ -556,6 +576,7 @@
Log.i(TAG,
"SendFile finished send out file " + fileInfo.mFileName + " length "
+ fileInfo.mLength);
+ BTOppUtils.throughputInKbps(fileInfo.mLength, beginTime);
} else {
error = true;
status = BluetoothShare.STATUS_CANCELED;
@@ -586,7 +607,7 @@
if (!error) {
responseCode = putOperation.getResponseCode();
if (responseCode != -1) {
- if (V) {
+ if (D) {
Log.v(TAG, "Get response code " + responseCode);
}
if (responseCode != ResponseCodes.OBEX_HTTP_OK) {
@@ -643,7 +664,7 @@
super.interrupt();
synchronized (this) {
if (mWaitingForRemote) {
- if (V) {
+ if (D) {
Log.v(TAG, "Interrupted when waitingForRemote");
}
try {
diff --git a/src/com/android/bluetooth/opp/BluetoothOppObexServerSession.java b/src/com/android/bluetooth/opp/BluetoothOppObexServerSession.java
index 47e80c8..91b62fd 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppObexServerSession.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppObexServerSession.java
@@ -104,6 +104,10 @@
private int mNumFilesAttemptedToReceive;
+ private boolean isHandover = false;
+
+ private String destination;
+
public BluetoothOppObexServerSession(Context context, ObexTransport transport,
BluetoothOppService service) {
mContext = context;
@@ -129,6 +133,9 @@
Log.d(TAG, "Create ServerSession with transport " + mTransport.toString());
}
mSession = new ServerSession(mTransport, this, null);
+ if(BTOppUtils.isA2DPPlaying) {
+ mSession.reduceMTU(true);
+ }
} catch (IOException e) {
Log.e(TAG, "Create server session error" + e);
}
@@ -198,15 +205,13 @@
} else {
destination = "FF:FF:FF:00:00:00";
}
- boolean isWhitelisted =
- BluetoothOppManager.getInstance(mContext).isWhitelisted(destination);
HeaderSet request;
String name, mimeType;
Long length;
try {
request = op.getReceivedHeader();
- if (V) {
+ if (D) {
Constants.logHeader(request);
}
name = (String) request.getHeader(HeaderSet.NAME);
@@ -260,7 +265,7 @@
}
// Reject anything outside the "whitelist" plus unspecified MIME Types.
- if (mimeType == null || (!isWhitelisted && !Constants.mimeTypeMatches(mimeType,
+ if (mimeType == null || (!isHandover && !Constants.mimeTypeMatches(mimeType,
Constants.ACCEPTABLE_SHARE_INBOUND_TYPES))) {
if (D) {
Log.w(TAG, "mimeType is null or in unacceptable list, reject the transfer");
@@ -275,29 +280,31 @@
values.put(BluetoothShare.DESTINATION, destination);
values.put(BluetoothShare.DIRECTION, BluetoothShare.DIRECTION_INBOUND);
values.put(BluetoothShare.TIMESTAMP, mTimestamp);
-
+ boolean needConfirm = true;
// It's not first put if !serverBlocking, so we auto accept it
if (!mServerBlocking && (mAccepted == BluetoothShare.USER_CONFIRMATION_CONFIRMED
|| mAccepted == BluetoothShare.USER_CONFIRMATION_AUTO_CONFIRMED)) {
values.put(BluetoothShare.USER_CONFIRMATION,
BluetoothShare.USER_CONFIRMATION_AUTO_CONFIRMED);
+ needConfirm = false;
}
- if (isWhitelisted) {
+ if (isHandover) {
values.put(BluetoothShare.USER_CONFIRMATION,
BluetoothShare.USER_CONFIRMATION_HANDOVER_CONFIRMED);
+ needConfirm = false;
}
Uri contentUri = mContext.getContentResolver().insert(BluetoothShare.CONTENT_URI, values);
mLocalShareInfoId = Integer.parseInt(contentUri.getPathSegments().get(1));
-
- if (V) {
+ BTOppUtils.isTurnOnScreen(mContext ,needConfirm);
+ if (D) {
Log.v(TAG, "insert contentUri: " + contentUri);
Log.v(TAG, "mLocalShareInfoId = " + mLocalShareInfoId);
}
synchronized (this) {
- mPartialWakeLock.acquire();
+ BTOppUtils.acquirePartialWakeLock(mPartialWakeLock);
mServerBlocking = true;
try {
@@ -339,7 +346,7 @@
}
mAccepted = mInfo.mConfirm;
- if (V) {
+ if (D) {
Log.v(TAG, "after confirm: userAccepted=" + mAccepted);
}
int status = BluetoothShare.STATUS_SUCCESS;
@@ -390,6 +397,8 @@
mInfo.mStatus = status;
msg.obj = mInfo;
msg.sendToTarget();
+ } else {
+ Log.w(TAG," Not sent MSG_SESSION_ERROR ");
}
}
} else if (mAccepted == BluetoothShare.USER_CONFIRMATION_DENIED
@@ -429,6 +438,7 @@
/*
* implement receive file
*/
+ long beginTime = 0;
int status = -1;
BufferedOutputStream bos = null;
@@ -466,6 +476,7 @@
long currentTime;
long prevTimestamp = SystemClock.elapsedRealtime();
try {
+ beginTime = System.currentTimeMillis();
while ((!mInterrupted) && (position != fileInfo.mLength)) {
if (V) {
@@ -508,9 +519,15 @@
/* OBEX Abort packet received from remote device */
if ("Abort Received".equals(e1.getMessage())) {
status = BluetoothShare.STATUS_CANCELED;
+ Message msg = Message.obtain(mCallback,
+ BluetoothOppObexSession.MSG_SESSION_ERROR);
+ msg.obj = mInfo;
+ msg.sendToTarget();
+ mCallback = null;
} else {
status = BluetoothShare.STATUS_OBEX_DATA_ERROR;
}
+ BTOppUtils.cleanFile(mFileInfo.mFileName);
error = true;
}
}
@@ -525,6 +542,7 @@
if (D) {
Log.d(TAG, "Receiving file completed for " + fileInfo.mFileName);
}
+ BTOppUtils.throughputInKbps(fileInfo.mLength, beginTime);
status = BluetoothShare.STATUS_SUCCESS;
} else {
if (D) {
@@ -568,7 +586,7 @@
if (D) {
Log.d(TAG, "onConnect");
}
- if (V) {
+ if (D) {
Constants.logHeader(request);
}
Long objectCount = null;
@@ -586,13 +604,13 @@
Log.e(TAG, e.toString());
return ResponseCodes.OBEX_HTTP_INTERNAL_ERROR;
}
- String destination;
if (mTransport instanceof BluetoothObexTransport) {
destination = ((BluetoothObexTransport) mTransport).getRemoteAddress();
} else {
destination = "FF:FF:FF:00:00:00";
}
- boolean isHandover = BluetoothOppManager.getInstance(mContext).isWhitelisted(destination);
+ isHandover = BluetoothOppManager.getInstance(mContext).isWhitelisted(destination);
+ if (D) Log.d(TAG, "isHandover :" + isHandover);
if (isHandover) {
// Notify the handover requester file transfer has started
Intent intent = new Intent(Constants.ACTION_HANDOVER_STARTED);
@@ -624,6 +642,7 @@
private synchronized void releaseWakeLocks() {
if (mPartialWakeLock.isHeld()) {
+ if (D) Log.d(TAG, "releasing partial wakelock");
mPartialWakeLock.release();
}
}
@@ -631,7 +650,10 @@
@Override
public void onClose() {
if (D) {
- Log.d(TAG, "onClose");
+ Log.d(TAG, "onClose isHandover :" + isHandover);
+ }
+ if (isHandover) {
+ BluetoothOppManager.getInstance(mContext).removeWhitelist(destination);
}
releaseWakeLocks();
mBluetoothOppService.acceptNewConnections();
diff --git a/src/com/android/bluetooth/opp/BluetoothOppReceiver.java b/src/com/android/bluetooth/opp/BluetoothOppReceiver.java
index 73d0194..edcbedf 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppReceiver.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppReceiver.java
@@ -58,10 +58,11 @@
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
-
+ if(D) Log.d(TAG, "Action :" + action);
+ if (action == null) return;
if (action.equals(BluetoothDevicePicker.ACTION_DEVICE_SELECTED)) {
BluetoothOppManager mOppManager = BluetoothOppManager.getInstance(context);
-
+ BluetoothOppManager.isReadyForFileSharing = false;
BluetoothDevice remoteDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
if (D) {
@@ -70,6 +71,7 @@
if (remoteDevice == null) {
mOppManager.cleanUpSendingFileInfo();
+ BluetoothOppManager.isReadyForFileSharing = true;
return;
}
// Insert transfer session record to database
@@ -85,6 +87,7 @@
} else {
toastMsg = context.getString(R.string.bt_toast_4, deviceName);
}
+ BluetoothOppManager.isReadyForFileSharing = true;
Toast.makeText(context, toastMsg, Toast.LENGTH_SHORT).show();
} else if (action.equals(Constants.ACTION_INCOMING_FILE_CONFIRM)) {
if (V) {
diff --git a/src/com/android/bluetooth/opp/BluetoothOppSendFileInfo.java b/src/com/android/bluetooth/opp/BluetoothOppSendFileInfo.java
index 6d7fe95..7130418 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppSendFileInfo.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppSendFileInfo.java
@@ -36,6 +36,7 @@
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.database.Cursor;
+import android.database.CursorWindowAllocationException;
import android.database.sqlite.SQLiteException;
import android.net.Uri;
import android.provider.OpenableColumns;
@@ -119,9 +120,12 @@
} catch (SQLiteException e) {
// some content providers don't support the DISPLAY_NAME or SIZE columns
metadataCursor = null;
- } catch (SecurityException e) {
+ } catch (SecurityException | NullPointerException e) {
Log.e(TAG, "generateFileInfo: Permission error, could not access URI: " + uri);
return SEND_FILE_INFO_ERROR;
+ } catch (CursorWindowAllocationException e) {
+ Log.e(TAG, " generateFileInfo :" + e);
+ throw new IllegalArgumentException(e.toString());
}
if (metadataCursor != null) {
@@ -175,6 +179,10 @@
// As a second source of getting the correct file length,
// get a file descriptor and get the stat length
AssetFileDescriptor fd = contentResolver.openAssetFileDescriptor(uri, "r");
+ if (fd == null) {
+ Log.e(TAG, "fd is NULL");
+ throw new IllegalArgumentException("Memory related error");
+ }
long statLength = fd.getLength();
if (length != statLength && statLength > 0) {
Log.e(TAG, "Content provider length is wrong (" + Long.toString(length)
@@ -206,6 +214,9 @@
}
} catch (FileNotFoundException e) {
// Ignore
+ } catch (SecurityException | IllegalStateException e) {
+ Log.e(TAG, "Error generateFileInfo ", e);
+ return SEND_FILE_INFO_ERROR;
}
}
@@ -224,6 +235,9 @@
return SEND_FILE_INFO_ERROR;
} catch (IOException e) {
return SEND_FILE_INFO_ERROR;
+ } catch (IllegalStateException e) {
+ Log.e(TAG, "Error generateFileInfo ", e);
+ return SEND_FILE_INFO_ERROR;
}
}
diff --git a/src/com/android/bluetooth/opp/BluetoothOppService.java b/src/com/android/bluetooth/opp/BluetoothOppService.java
index 914b9b6..ad23c5f 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppService.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppService.java
@@ -193,7 +193,7 @@
@Override
protected void create() {
- if (V) {
+ if (D) {
Log.v(TAG, "onCreate");
}
mShares = Lists.newArrayList();
@@ -204,16 +204,18 @@
@Override
public void run() {
trimDatabase(contentResolver);
+ mHandler.sendMessage(mHandler.obtainMessage(MSG_START_UPDATE_THREAD));
}
}.start();
IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
+ BTOppUtils.addA2dpFilter(filter);
registerReceiver(mBluetoothReceiver, filter);
mAdapter = BluetoothAdapter.getDefaultAdapter();
synchronized (BluetoothOppService.this) {
if (mAdapter == null) {
- Log.w(TAG, "Local BT device is not enabled");
+ Log.w(TAG, "Local BT is not enabled");
}
}
if (V) {
@@ -228,21 +230,16 @@
@Override
public boolean start() {
- if (V) {
+ if (D) {
Log.v(TAG, "start()");
}
- mObserver = new BluetoothShareContentObserver();
- getContentResolver().registerContentObserver(BluetoothShare.CONTENT_URI, true, mObserver);
- mNotifier = new BluetoothOppNotification(this);
- mNotifier.mNotificationMgr.cancelAll();
- mNotifier.updateNotification();
- updateFromProvider();
setBluetoothOppService(this);
return true;
}
@Override
public boolean stop() {
+ if (D) Log.d(TAG," stop");
if (sBluetoothOppService == null) {
Log.w(TAG, "stop() called before start()");
return true;
@@ -258,8 +255,8 @@
if (V) {
Log.v(TAG, "Starting RfcommListener");
}
- mHandler.sendMessage(mHandler.obtainMessage(START_LISTENER));
mListenStarted = true;
+ mHandler.sendMessage(mHandler.obtainMessage(START_LISTENER));
}
}
}
@@ -316,13 +313,20 @@
private static final int STOP_LISTENER = 200;
+ private static final int MSG_START_UPDATE_THREAD = 300;
+
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
+ Log.i(TAG, " handleMessage :" + msg.what);
switch (msg.what) {
case STOP_LISTENER:
- stopListeners();
+ if (!mListenStarted) { // Extra check to avoid redundant call
+ if (V) Log.v(TAG," stop_listener already called");
+ return;
+ }
mListenStarted = false;
+ stopListeners();
//Stop Active INBOUND Transfer
if (mServerTransfer != null) {
mServerTransfer.onBatchCanceled();
@@ -333,7 +337,7 @@
mTransfer.onBatchCanceled();
mTransfer = null;
}
- unregisterReceivers();
+ unregisterObserver();
synchronized (BluetoothOppService.this) {
if (mUpdateThread != null) {
mUpdateThread.interrupt();
@@ -356,8 +360,18 @@
mUpdateThread = null;
}
}
+ if (D) Log.d(TAG," clear batches");
+ if (mBatches != null) {
+ mBatches.clear();
+ }
+ if (mShares != null) {
+ mShares.clear();
+ }
- mNotifier.cancelNotifications();
+ if (mNotifier != null) {
+ mNotifier.cancelNotifications();
+ }
+ updatePendingNfcState();
break;
case START_LISTENER:
if (mAdapter.isEnabled()) {
@@ -452,6 +466,17 @@
}
}
break;
+ case MSG_START_UPDATE_THREAD:
+ mObserver = new BluetoothShareContentObserver();
+ getContentResolver().registerContentObserver(BluetoothShare.CONTENT_URI,
+ true, mObserver);
+
+ mNotifier = new BluetoothOppNotification(BluetoothOppService.this);
+ mNotifier.mNotificationMgr.cancelAll();
+ mNotifier.updateNotification();
+
+ updateFromProvider();
+ break;
}
}
};
@@ -463,7 +488,8 @@
Log.d(TAG, "start Socket Listeners");
}
stopListeners();
- mServerSocket = ObexServerSockets.createInsecure(this);
+ mServerSocket = ObexServerSockets.createInsecureWithFixedChannels(this,
+ SdpManager.OPP_RFCOMM_CHANNEL, SdpManager.OPP_L2CAP_PSM);
acceptNewConnections();
SdpManager sdpManager = SdpManager.getDefaultManager();
if (sdpManager == null || mServerSocket == null) {
@@ -481,30 +507,30 @@
@Override
protected void cleanup() {
- if (V) {
+ if (D) {
Log.v(TAG, "onDestroy");
}
stopListeners();
- if (mBatches != null) {
- mBatches.clear();
+
+ try {
+ unregisterReceiver(mBluetoothReceiver);
+ } catch (IllegalArgumentException e) {
+ Log.w(TAG, "unregisterReceiver " + e.toString());
}
- if (mShares != null) {
- mShares.clear();
- }
+
if (mHandler != null) {
mHandler.removeCallbacksAndMessages(null);
}
}
- private void unregisterReceivers() {
+ private void unregisterObserver() {
try {
if (mObserver != null) {
getContentResolver().unregisterContentObserver(mObserver);
mObserver = null;
}
- unregisterReceiver(mBluetoothReceiver);
} catch (IllegalArgumentException e) {
- Log.w(TAG, "unregisterReceivers " + e.toString());
+ Log.w(TAG, "unregisterContentObserver " + e.toString());
}
}
@@ -522,7 +548,8 @@
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
-
+ if (D) Log.d(TAG, "action : " + action);
+ if (action == null) return;
if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
switch (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)) {
case BluetoothAdapter.STATE_ON:
@@ -559,6 +586,8 @@
mHandler.sendMessage(mHandler.obtainMessage(STOP_LISTENER));
break;
}
+ } else {
+ BTOppUtils.checkAction(intent);
}
}
};
@@ -665,6 +694,7 @@
if (V) {
Log.v(TAG, "Array update: inserting " + id + " @ " + arrayPos);
}
+ scanFileIfNeeded(arrayPos);
++arrayPos;
cursor.moveToNext();
isAfterLast = cursor.isAfterLast();
@@ -694,7 +724,7 @@
Log.v(TAG, "Array update: appending " + id + " @ " + arrayPos);
}
insertShare(cursor, arrayPos);
-
+ scanFileIfNeeded(arrayPos);
++arrayPos;
cursor.moveToNext();
isAfterLast = cursor.isAfterLast();
@@ -1076,7 +1106,7 @@
if (V) {
Log.v(TAG, "Deleted shares, number = " + delNum);
}
-
+ BTOppUtils.cleanOnPowerOff(contentResolver);
// Keep the latest inbound and successful shares.
Cursor cursor =
contentResolver.query(BluetoothShare.CONTENT_URI, new String[]{BluetoothShare._ID},
@@ -1211,4 +1241,25 @@
void acceptNewConnections() {
mAcceptNewConnections = true;
}
+
+ private void updatePendingNfcState() {
+ new Thread("updateState") {
+ @Override
+ public void run() {
+ String where_nfc_pending = BluetoothShare.STATUS
+ + "=" + BluetoothShare.STATUS_PENDING + " AND "
+ + BluetoothShare.USER_CONFIRMATION + "="
+ + BluetoothShare.USER_CONFIRMATION_HANDOVER_CONFIRMED
+ +" AND ( " + BluetoothShare.DIRECTION
+ + "=" + BluetoothShare.DIRECTION_OUTBOUND + " OR "
+ + BluetoothShare.DIRECTION + "="
+ + BluetoothShare.DIRECTION_INBOUND + ")";
+ ContentValues cv = new ContentValues();
+ cv.put(BluetoothShare.STATUS, BluetoothShare.STATUS_CONNECTION_ERROR);
+ int updatedCount = getContentResolver().update(BluetoothShare.CONTENT_URI,
+ cv, where_nfc_pending, null);
+ if (V) Log.v(TAG, "updatePendingNfcState " + updatedCount);
+ }
+ }.start();
+ }
}
diff --git a/src/com/android/bluetooth/opp/BluetoothOppTransfer.java b/src/com/android/bluetooth/opp/BluetoothOppTransfer.java
index 91af9ca..7bfc1ca 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppTransfer.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppTransfer.java
@@ -123,7 +123,7 @@
}
if ((device.equals(mBatch.mDestination)) && (mCurrentShare.mConfirm
== BluetoothShare.USER_CONFIRMATION_PENDING)) {
- if (V) {
+ if (D) {
Log.v(TAG, "ACTION_ACL_DISCONNECTED to be processed for batch: "
+ mBatch.mId);
}
@@ -203,6 +203,7 @@
@Override
public void handleMessage(Message msg) {
+ Log.i(TAG, " handleMessage :" + msg.what);
switch (msg.what) {
case SOCKET_ERROR_RETRY:
mConnectThread = new SocketConnectThread((BluetoothDevice) msg.obj, true);
@@ -217,7 +218,7 @@
if (V) {
Log.v(TAG, "receive TRANSPORT_ERROR msg");
}
- mConnectThread = null;
+
markBatchFailed(BluetoothShare.STATUS_CONNECTION_ERROR);
mBatch.mStatus = Constants.BATCH_STATUS_FAILED;
@@ -230,7 +231,7 @@
if (V) {
Log.v(TAG, "Transfer receive TRANSPORT_CONNECTED msg");
}
- mConnectThread = null;
+
mTransport = (ObexTransport) msg.obj;
startObexSession();
@@ -502,7 +503,7 @@
* Stop the transfer
*/
public void stop() {
- if (V) {
+ if (D) {
Log.v(TAG, "stop");
}
if (mSession != null) {
@@ -513,19 +514,22 @@
}
cleanUp();
- if (mConnectThread != null) {
- try {
- mConnectThread.interrupt();
- if (V) {
- Log.v(TAG, "waiting for connect thread to terminate");
+ synchronized (this) {
+ if (mConnectThread != null) {
+ try {
+ mConnectThread.interrupt();
+ if (D) {
+ Log.v(TAG, "waiting for connect thread to terminate");
+ }
+ mConnectThread.join();
+ } catch (InterruptedException e) {
+ if (V) {
+ Log.v(TAG, "Interrupted waiting for connect thread to join");
+ }
}
- mConnectThread.join();
- } catch (InterruptedException e) {
- if (V) {
- Log.v(TAG, "Interrupted waiting for connect thread to join");
- }
+ mConnectThread = null;
+ if (D) Log.d(TAG, "mConnectThread terminated");
}
- mConnectThread = null;
}
// Prevent concurrent access
synchronized (this) {
@@ -731,7 +735,7 @@
try {
mBtSocket.connect();
- if (V) {
+ if (D) {
Log.v(TAG,
"Rfcomm socket connection attempt took " + (System.currentTimeMillis()
- mTimestamp) + " ms");
@@ -799,7 +803,7 @@
}
try {
mBtSocket.connect();
- if (V) {
+ if (D) {
Log.v(TAG, "L2cap socket connection attempt took " + (System.currentTimeMillis()
- mTimestamp) + " ms");
}
diff --git a/src/com/android/bluetooth/opp/BluetoothOppTransferActivity.java b/src/com/android/bluetooth/opp/BluetoothOppTransferActivity.java
index fc45d3f..e4d98e8 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppTransferActivity.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppTransferActivity.java
@@ -375,24 +375,13 @@
mTransInfo.mID);
} else if (mWhichDialog == DIALOG_SEND_COMPLETE_FAIL) {
// "try again"
-
// make current transfer "hidden"
BluetoothOppUtility.updateVisibilityToHidden(this, mUri);
// clear correspondent notification item
((NotificationManager) getSystemService(NOTIFICATION_SERVICE)).cancel(
mTransInfo.mID);
-
- // retry the failed transfer
- Uri uri = BluetoothOppUtility.originalUri(Uri.parse(mTransInfo.mFileUri));
- BluetoothOppSendFileInfo sendFileInfo =
- BluetoothOppSendFileInfo.generateFileInfo(BluetoothOppTransferActivity
- .this, uri, mTransInfo.mFileType, false);
- uri = BluetoothOppUtility.generateUri(uri, sendFileInfo);
- BluetoothOppUtility.putSendFileInfo(uri, sendFileInfo);
- mTransInfo.mFileUri = uri.toString();
- BluetoothOppUtility.retryTransfer(this, mTransInfo);
-
+ retryFailedTrasfer();
BluetoothDevice remoteDevice = mAdapter.getRemoteDevice(mTransInfo.mDestAddr);
// Display toast message
@@ -502,4 +491,22 @@
.setText(getString(R.string.upload_fail_cancel));
}
}
+
+ // Retry the failed transfer in background thread
+ private void retryFailedTrasfer() {
+ new Thread() {
+ @Override
+ public void run() {
+ super.run();
+ Uri uri = BluetoothOppUtility.originalUri(Uri.parse(mTransInfo.mFileUri));
+ BluetoothOppSendFileInfo sendFileInfo =
+ BluetoothOppSendFileInfo.generateFileInfo(BluetoothOppTransferActivity
+ .this, uri, mTransInfo.mFileType, false);
+ uri = BluetoothOppUtility.generateUri(uri, sendFileInfo);
+ BluetoothOppUtility.putSendFileInfo(uri, sendFileInfo);
+ mTransInfo.mFileUri = uri.toString();
+ BluetoothOppUtility.retryTransfer(BluetoothOppTransferActivity.this, mTransInfo);
+ }
+ }.start();
+ }
}
diff --git a/src/com/android/bluetooth/opp/BluetoothOppTransferAdapter.java b/src/com/android/bluetooth/opp/BluetoothOppTransferAdapter.java
index 7221c53..04c9dff 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppTransferAdapter.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppTransferAdapter.java
@@ -58,7 +58,7 @@
private Context mContext;
public BluetoothOppTransferAdapter(Context context, int layout, Cursor c) {
- super(context, layout, c);
+ super(context, layout, c, true);
mContext = context;
}
diff --git a/src/com/android/bluetooth/opp/BluetoothOppUtility.java b/src/com/android/bluetooth/opp/BluetoothOppUtility.java
index 7533d0d..7cb6f80 100644
--- a/src/com/android/bluetooth/opp/BluetoothOppUtility.java
+++ b/src/com/android/bluetooth/opp/BluetoothOppUtility.java
@@ -43,6 +43,7 @@
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.database.Cursor;
+import android.database.SQLException;
import android.net.Uri;
import android.os.Environment;
import android.os.SystemProperties;
@@ -80,17 +81,22 @@
public static BluetoothOppTransferInfo queryRecord(Context context, Uri uri) {
BluetoothOppTransferInfo info = new BluetoothOppTransferInfo();
- Cursor cursor = context.getContentResolver().query(uri, null, null, null, null);
- if (cursor != null) {
- if (cursor.moveToFirst()) {
- fillRecord(context, cursor, info);
+ try {
+ Cursor cursor = context.getContentResolver().query(uri, null, null, null, null);
+ if (cursor != null) {
+ if (cursor.moveToFirst()) {
+ fillRecord(context, cursor, info);
+ }
+ cursor.close();
+ } else {
+ info = null;
+ if (V) {
+ Log.v(TAG, "BluetoothOppManager Error: not got data from db for uri:" + uri);
+ }
}
- cursor.close();
- } else {
+ } catch (SQLException | NullPointerException e) {
info = null;
- if (V) {
- Log.v(TAG, "BluetoothOppManager Error: not got data from db for uri:" + uri);
- }
+ Log.e(TAG, "queryRecord Error: ", e);
}
return info;
}
@@ -208,8 +214,14 @@
return;
}
- Uri path = BluetoothOppFileProvider.getUriForFile(context,
- "com.android.bluetooth.opp.fileprovider", f);
+ Uri path = null;
+ try {
+ path = BluetoothOppFileProvider.getUriForFile(context,
+ "com.android.bluetooth.opp.fileprovider", f);
+ } catch (IllegalArgumentException e) {
+ Log.e(TAG, "Not able to find root path:" + f.getAbsolutePath());
+ }
+
if (path == null) {
Log.w(TAG, "Cannot get content URI for the shared file");
return;
diff --git a/src/com/android/bluetooth/opp/Constants.java b/src/com/android/bluetooth/opp/Constants.java
index 3bf6cde..0dd612c 100644
--- a/src/com/android/bluetooth/opp/Constants.java
+++ b/src/com/android/bluetooth/opp/Constants.java
@@ -194,6 +194,9 @@
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"application/vnd.openxmlformats-officedocument.presentationml.presentation",
"application/x-hwp",
+ "application/ogg",
+ "application/vnd.android.package-archive",
+ "text/comma-separated-values",
};
/** Where we store received files */
@@ -204,7 +207,7 @@
static final boolean DEBUG = true;
- static final boolean VERBOSE = false;
+ static final boolean VERBOSE = Log.isLoggable(TAG, Log.VERBOSE);;
static final int MAX_RECORDS_IN_DATABASE = 50;
diff --git a/src/com/android/bluetooth/pan/PanService.java b/src/com/android/bluetooth/pan/PanService.java
index 92eab77..6e2d2cd 100644
--- a/src/com/android/bluetooth/pan/PanService.java
+++ b/src/com/android/bluetooth/pan/PanService.java
@@ -54,7 +54,8 @@
*/
public class PanService extends ProfileService {
private static final String TAG = "PanService";
- private static final boolean DBG = false;
+ private static final String LOG_TAG = "BluetoothPan";
+ private static final boolean DBG = Log.isLoggable(LOG_TAG, Log.DEBUG);
private static PanService sPanService;
private static final String BLUETOOTH_IFACE_ADDR_START = "192.168.44.1";
@@ -74,6 +75,7 @@
private static final int MESSAGE_CONNECT = 1;
private static final int MESSAGE_DISCONNECT = 2;
private static final int MESSAGE_CONNECT_STATE_CHANGED = 11;
+ private static final int STOP_LISTENER = 200;
private boolean mTetherOn = false;
private BluetoothTetheringNetworkFactory mNetworkFactory;
@@ -131,37 +133,18 @@
@Override
protected boolean stop() {
- mHandler.removeCallbacksAndMessages(null);
+ Log.i(TAG, " stop");
+ mHandler.sendMessage(mHandler.obtainMessage(STOP_LISTENER));
return true;
}
@Override
protected void cleanup() {
- // TODO(b/72948646): this should be moved to stop()
- setPanService(null);
- if (mNativeAvailable) {
- cleanupNative();
- mNativeAvailable = false;
- }
+ Log.i(TAG, " cleanup");
+ mHandler.removeCallbacksAndMessages(null);
mUserManager = null;
- if (mPanDevices != null) {
- int[] desiredStates = {BluetoothProfile.STATE_CONNECTING, BluetoothProfile.STATE_CONNECTED,
- BluetoothProfile.STATE_DISCONNECTING};
- List<BluetoothDevice> devList =
- getDevicesMatchingConnectionStates(desiredStates);
- for (BluetoothDevice device : devList) {
- BluetoothPanDevice panDevice = mPanDevices.get(device);
- Log.d(TAG, "panDevice: " + panDevice + " device address: " + device);
- if (panDevice != null) {
- handlePanDeviceStateChange(device, mPanIfName,
- BluetoothProfile.STATE_DISCONNECTED,
- panDevice.mLocalRole, panDevice.mRemoteRole);
- }
- }
- mPanDevices.clear();
- }
}
private final Handler mHandler = new Handler() {
@@ -206,6 +189,30 @@
convertHalState(cs.state), cs.local_role, cs.remote_role);
}
break;
+ case STOP_LISTENER :
+ setPanService(null);
+ if (mNativeAvailable) {
+ cleanupNative();
+ mNativeAvailable = false;
+ }
+ if (mPanDevices != null) {
+ int[] desiredStates = {BluetoothProfile.STATE_CONNECTING,
+ BluetoothProfile.STATE_CONNECTED,
+ BluetoothProfile.STATE_DISCONNECTING};
+ List<BluetoothDevice> devList =
+ getDevicesMatchingConnectionStates(desiredStates);
+ for (BluetoothDevice device : devList) {
+ BluetoothPanDevice panDevice = mPanDevices.get(device);
+ Log.d(TAG, "panDevice: " + panDevice + " device address: " + device);
+ if (panDevice != null) {
+ handlePanDeviceStateChange(device, mPanIfName,
+ BluetoothProfile.STATE_DISCONNECTED,
+ panDevice.mLocalRole, panDevice.mRemoteRole);
+ }
+ }
+ mPanDevices.clear();
+ }
+ break;
}
}
};
@@ -336,6 +343,11 @@
Log.e(TAG, "Pan Device not disconnected: " + device);
return false;
}
+ /* Cancel discovery while initiating PANU connection, if It's in progress */
+ if (mAdapter != null && mAdapter.isDiscovering()) {
+ Log.d(TAG,"Inquiry is going on, Cancelling inquiry while initiating PANU connection");
+ mAdapter.cancelDiscovery();
+ }
Message msg = mHandler.obtainMessage(MESSAGE_CONNECT, device);
mHandler.sendMessage(msg);
return true;
@@ -505,6 +517,10 @@
+ ", state: " + state + ", localRole:" + localRole + ", remoteRole:"
+ remoteRole);
}
+ if (device == null) {
+ Log.d(TAG, "BluetoothDevice is null, Ignoring state change ");
+ return;
+ }
int prevState;
BluetoothPanDevice panDevice = mPanDevices.get(device);
@@ -526,8 +542,9 @@
// connect call will put us in STATE_DISCONNECTED. Then, the disconnect completes and
// changes the state to STATE_DISCONNECTING. All future calls to BluetoothPan#connect
// will fail until the caller explicitly calls BluetoothPan#disconnect.
- if (prevState == BluetoothProfile.STATE_DISCONNECTED
- && state == BluetoothProfile.STATE_DISCONNECTING) {
+ if (prevState == BluetoothProfile.STATE_DISCONNECTED &&
+ (state == BluetoothProfile.STATE_DISCONNECTING ||
+ state == BluetoothProfile.STATE_DISCONNECTED)) {
Log.d(TAG, "Ignoring state change from " + prevState + " to " + state);
mPanDevices.remove(device);
return;
diff --git a/src/com/android/bluetooth/pbap/BluetoothPbapCallLogComposer.java b/src/com/android/bluetooth/pbap/BluetoothPbapCallLogComposer.java
index 805f3ea..6185557 100644
--- a/src/com/android/bluetooth/pbap/BluetoothPbapCallLogComposer.java
+++ b/src/com/android/bluetooth/pbap/BluetoothPbapCallLogComposer.java
@@ -23,7 +23,6 @@
import android.provider.CallLog;
import android.provider.CallLog.Calls;
import android.text.TextUtils;
-import android.text.format.Time;
import android.util.Log;
import com.android.bluetooth.R;
@@ -32,13 +31,15 @@
import com.android.vcard.VCardConstants;
import com.android.vcard.VCardUtils;
+import java.text.SimpleDateFormat;
import java.util.Arrays;
+import java.util.Calendar;
/**
* VCard composer especially for Call Log used in Bluetooth.
*/
public class BluetoothPbapCallLogComposer {
- private static final String TAG = "CallLogComposer";
+ private static final String TAG = "PbapCallLogComposer";
private static final String FAILURE_REASON_FAILED_TO_GET_DATABASE_INFO =
"Failed to get database information";
@@ -198,9 +199,11 @@
* The format is: ("%Y%m%dT%H%M%S").
*/
private String toRfc2455Format(final long millSecs) {
- Time startDate = new Time();
- startDate.set(millSecs);
- return startDate.format2445();
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(millSecs);
+ String rfc2455Format = "yyyyMMdd'T'HHmmss";
+ SimpleDateFormat df = new SimpleDateFormat(rfc2455Format);
+ return df.format(cal.getTime());
}
/**
diff --git a/src/com/android/bluetooth/pbap/BluetoothPbapObexServer.java b/src/com/android/bluetooth/pbap/BluetoothPbapObexServer.java
index 979becd..b40721d 100755
--- a/src/com/android/bluetooth/pbap/BluetoothPbapObexServer.java
+++ b/src/com/android/bluetooth/pbap/BluetoothPbapObexServer.java
@@ -58,7 +58,9 @@
import javax.obex.ResponseCodes;
import javax.obex.ServerRequestHandler;
-public class BluetoothPbapObexServer extends ServerRequestHandler {
+import com.android.bluetooth.pbap.BluetoothPbapSimVcardManager.SimPaths;
+
+public class BluetoothPbapObexServer extends ServerRequestHandler implements SimPaths{
private static final String TAG = "BluetoothPbapObexServer";
@@ -93,22 +95,12 @@
0x66
};
- // Currently not support SIM card
private static final String[] LEGAL_PATH = {
"/telecom",
"/telecom/pb",
"/telecom/ich",
"/telecom/och",
"/telecom/mch",
- "/telecom/cch"
- };
-
- @SuppressWarnings("unused") private static final String[] LEGAL_PATH_WITH_SIM = {
- "/telecom",
- "/telecom/pb",
- "/telecom/ich",
- "/telecom/och",
- "/telecom/mch",
"/telecom/cch",
"/SIM1",
"/SIM1/telecom",
@@ -202,6 +194,8 @@
private PbapStateMachine mStateMachine;
+ protected static BluetoothPbapSimVcardManager mVcardSimManager;
+
public static class ContentType {
public static final int PHONEBOOK = 1;
@@ -212,6 +206,8 @@
public static final int MISSED_CALL_HISTORY = 4;
public static final int COMBINED_CALL_HISTORY = 5;
+
+ public static final int SIM_PHONEBOOK = 6;
}
public BluetoothPbapObexServer(Handler callback, Context context,
@@ -221,6 +217,8 @@
mContext = context;
mVcardManager = new BluetoothPbapVcardManager(mContext);
mStateMachine = stateMachine;
+ mVcardSimManager = new BluetoothPbapSimVcardManager(mContext);
+ BluetoothPbapFixes.getFeatureSupport(mContext);
}
@Override
@@ -433,6 +431,12 @@
validName = false;
}
+ if (!BluetoothPbapFixes.isSimSupported && ((mCurrentPath.contains("SIM") ||
+ (validName && name.contains("SIM"))))) {
+ if (D) Log.d(TAG, "SIM support disabled ");
+ return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE;
+ }
+
if (!validName || (validName && type.equals(TYPE_VCARD))) {
if (D) {
Log.d(TAG,
@@ -441,21 +445,23 @@
if (mCurrentPath.equals(PB_PATH)) {
appParamValue.needTag = ContentType.PHONEBOOK;
- } else if (mCurrentPath.equals(ICH_PATH)) {
+ } else if (mCurrentPath.equals(ICH_PATH)|| mCurrentPath.equals(SIM_ICH_PATH)) {
appParamValue.needTag = ContentType.INCOMING_CALL_HISTORY;
- } else if (mCurrentPath.equals(OCH_PATH)) {
+ } else if (mCurrentPath.equals(OCH_PATH)|| mCurrentPath.equals(SIM_OCH_PATH)) {
appParamValue.needTag = ContentType.OUTGOING_CALL_HISTORY;
- } else if (mCurrentPath.equals(MCH_PATH)) {
+ } else if (mCurrentPath.equals(MCH_PATH)|| mCurrentPath.equals(SIM_MCH_PATH)) {
appParamValue.needTag = ContentType.MISSED_CALL_HISTORY;
mNeedNewMissedCallsNum = true;
- } else if (mCurrentPath.equals(CCH_PATH)) {
+ } else if (mCurrentPath.equals(CCH_PATH)|| mCurrentPath.equals(SIM_CCH_PATH)) {
appParamValue.needTag = ContentType.COMBINED_CALL_HISTORY;
- } else if (mCurrentPath.equals(TELECOM_PATH)) {
+ } else if (mCurrentPath.equals(TELECOM_PATH)|| mCurrentPath.equals(SIM_PATH)) {
/* PBAP 1.1.1 change */
if (!validName && type.equals(TYPE_LISTING)) {
Log.e(TAG, "invalid vcard listing request in default folder");
return ResponseCodes.OBEX_HTTP_NOT_FOUND;
}
+ } else if (mCurrentPath.equals(SIM_PB_PATH)) {
+ appParamValue.needTag = ContentType.SIM_PHONEBOOK;
} else {
Log.w(TAG, "mCurrentpath is not valid path!!!");
return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE;
@@ -464,16 +470,14 @@
Log.v(TAG, "onGet(): appParamValue.needTag=" + appParamValue.needTag);
}
} else {
- // Not support SIM card currently
- if (name.contains(SIM1.subSequence(0, SIM1.length()))) {
- Log.w(TAG, "Not support access SIM card info!");
- return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE;
- }
-
// we have weak name checking here to provide better
// compatibility with other devices,although unique name such as
// "pb.vcf" is required by SIG spec.
- if (isNameMatchTarget(name, PB)) {
+ if (mVcardSimManager.isSimPhoneBook(name, type, PB, SIM1,
+ TYPE_PB, TYPE_LISTING, mCurrentPath)) {
+ appParamValue.needTag = ContentType.SIM_PHONEBOOK;
+ if (D) Log.d(TAG, "download SIM phonebook request");
+ } else if (isNameMatchTarget(name, PB)) {
appParamValue.needTag = ContentType.PHONEBOOK;
if (D) {
Log.v(TAG, "download phonebook request");
@@ -570,7 +574,7 @@
return false;
}
- private class AppParamValue {
+ class AppParamValue {
public int maxListCount;
public int listStartOffset;
@@ -746,25 +750,36 @@
int size) {
StringBuilder result = new StringBuilder();
int itemsFound = 0;
+ String type = "";
result.append("<?xml version=\"1.0\"?>");
result.append("<!DOCTYPE vcard-listing SYSTEM \"vcard-listing.dtd\">");
result.append("<vCard-listing version=\"1.0\">");
// Phonebook listing request
if (appParamValue.needTag == ContentType.PHONEBOOK) {
- String type = "";
if (appParamValue.searchAttr.equals("0")) {
type = "name";
} else if (appParamValue.searchAttr.equals("1")) {
type = "number";
}
if (type.length() > 0) {
- itemsFound = createList(appParamValue, needSendBody, size, result, type);
+ itemsFound = BluetoothPbapFixes.createList(mVcardSimManager, mVcardManager,
+ this, mVcardSelector, mOrderBy, appParamValue, needSendBody, size, result,
+ type);
} else {
return ResponseCodes.OBEX_HTTP_PRECON_FAILED;
}
+ // SIM Phonebook listing Request
+ } else if (appParamValue.needTag == ContentType.SIM_PHONEBOOK) {
+ type = mVcardSimManager.getType(appParamValue.searchAttr);
+ if (type.length() > 0) {
+ itemsFound = BluetoothPbapFixes.createList(mVcardSimManager, mVcardManager,
+ this,mVcardSelector,mOrderBy,appParamValue, needSendBody, size, result, type);
+ } else {
+ return ResponseCodes.OBEX_HTTP_PRECON_FAILED;
+ }
+ // Call history listing request
} else {
- // Call history listing request
ArrayList<String> nameList = mVcardManager.loadCallHistoryList(appParamValue.needTag);
int requestSize =
nameList.size() >= appParamValue.maxListCount ? appParamValue.maxListCount
@@ -911,7 +926,7 @@
}
/** Function to send vcard data to client */
- private int pushBytes(Operation op, final String vcardString) {
+ protected int pushBytes(Operation op, final String vcardString) {
if (vcardString == null) {
Log.w(TAG, "vcardString is null!");
return ResponseCodes.OBEX_HTTP_OK;
@@ -986,6 +1001,8 @@
nmnum = nmnum > 0 ? nmnum : 0;
misnum[0] = (byte) nmnum;
+ ap.addAPPHeader(ApplicationParameter.TRIPLET_TAGID.NEWMISSEDCALLS_TAGID,
+ ApplicationParameter.TRIPLET_LENGTH.NEWMISSEDCALLS_LENGTH, misnum);
if (D) {
Log.d(TAG, "handleAppParaForResponse(): mNeedNewMissedCallsNum=true, num= "
+ nmnum);
@@ -995,7 +1012,7 @@
if (checkPbapFeatureSupport(mDatabaseIdentifierBitMask)) {
setDbCounters(ap);
}
- if (needSendPhonebookVersionCounters) {
+ if (BluetoothPbapFixes.isSupportedPbap12 && needSendPhonebookVersionCounters) {
setFolderVersionCounters(ap);
}
if (needSendCallHistoryVersionCounters) {
@@ -1057,7 +1074,8 @@
}
}
- if (checkPbapFeatureSupport(mDatabaseIdentifierBitMask)) {
+ if (BluetoothPbapFixes.isSupportedPbap12
+ && checkPbapFeatureSupport(mDatabaseIdentifierBitMask)) {
setDbCounters(ap);
reply.setHeader(HeaderSet.APPLICATION_PARAMETER, ap.getAPPparam());
try {
@@ -1068,7 +1086,7 @@
}
}
- if (needSendPhonebookVersionCounters) {
+ if (BluetoothPbapFixes.isSupportedPbap12 && needSendPhonebookVersionCounters) {
setFolderVersionCounters(ap);
reply.setHeader(HeaderSet.APPLICATION_PARAMETER, ap.getAPPparam());
try {
@@ -1173,6 +1191,7 @@
if (strIndex.trim().length() != 0) {
try {
intIndex = Integer.parseInt(strIndex);
+ if (D) Log.d(TAG, "Index: " + intIndex + "orderby: " + mOrderBy);
} catch (NumberFormatException e) {
Log.e(TAG, "catch number format exception " + e.toString());
return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE;
@@ -1193,7 +1212,7 @@
Log.w(TAG, "wrong path!");
return ResponseCodes.OBEX_HTTP_NOT_ACCEPTABLE;
} else if (appParamValue.needTag == ContentType.PHONEBOOK) {
- if (intIndex < 0 || intIndex >= size) {
+ if (intIndex < 0 || !BluetoothPbapFixes.checkContactsVcardId(intIndex, mContext)) {
Log.w(TAG, "The requested vcard is not acceptable! name= " + name);
return ResponseCodes.OBEX_HTTP_NOT_FOUND;
} else if (intIndex == 0) {
@@ -1205,6 +1224,10 @@
return mVcardManager.composeAndSendPhonebookOneVcard(op, intIndex, vcard21, null,
mOrderBy, appParamValue.ignorefilter, appParamValue.propertySelector);
}
+ } else if (appParamValue.needTag == ContentType.SIM_PHONEBOOK) {
+ return mVcardSimManager.initiatePullSimVcardEntry(intIndex, size,
+ vcard21, mOrderBy, name, op, mVcardManager, appParamValue.ignorefilter,
+ appParamValue.propertySelector, this);
} else {
if (intIndex <= 0 || intIndex > size) {
Log.w(TAG, "The requested vcard is not acceptable! name= " + name);
@@ -1259,7 +1282,8 @@
}
// Limit the number of call log to CALLLOG_NUM_LIMIT
- if (appParamValue.needTag != BluetoothPbapObexServer.ContentType.PHONEBOOK) {
+ if (appParamValue.needTag != BluetoothPbapObexServer.ContentType.PHONEBOOK
+ && (appParamValue.needTag != BluetoothPbapObexServer.ContentType.SIM_PHONEBOOK)) {
if (requestSize > CALLLOG_NUM_LIMIT) {
requestSize = CALLLOG_NUM_LIMIT;
}
@@ -1293,6 +1317,10 @@
appParamValue.propertySelector, appParamValue.vCardSelector,
appParamValue.vCardSelectorOperator, mVcardSelector);
}
+ } else if (appParamValue.needTag == BluetoothPbapObexServer.ContentType.SIM_PHONEBOOK) {
+ return mVcardSimManager.initiatePullSimPhonebook(startPoint,
+ endPoint, vcard21, op, mVcardManager, appParamValue.ignorefilter,
+ appParamValue.propertySelector, this);
} else {
return mVcardManager.composeAndSendSelectedCallLogVcards(appParamValue.needTag, op,
startPoint + 1, endPoint + 1, vcard21, needSendBody, pbSize,
@@ -1381,7 +1409,7 @@
}
}
- private void writeVCardEntry(int vcfIndex, String name, StringBuilder result) {
+ protected void writeVCardEntry(int vcfIndex, String name, StringBuilder result) {
result.append("<card handle=\"");
result.append(vcfIndex);
result.append(".vcf\" name=\"");
diff --git a/src/com/android/bluetooth/pbap/BluetoothPbapService.java b/src/com/android/bluetooth/pbap/BluetoothPbapService.java
index e7dba2a..dc8e054 100644
--- a/src/com/android/bluetooth/pbap/BluetoothPbapService.java
+++ b/src/com/android/bluetooth/pbap/BluetoothPbapService.java
@@ -36,6 +36,7 @@
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothSocket;
+import android.bluetooth.BluetoothUuid;
import android.bluetooth.IBluetoothPbap;
import android.content.BroadcastReceiver;
import android.content.Context;
@@ -47,6 +48,7 @@
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
+import android.os.ParcelUuid;
import android.os.PowerManager;
import android.os.UserManager;
import android.telephony.TelephonyManager;
@@ -68,17 +70,18 @@
public class BluetoothPbapService extends ProfileService implements IObexConnectionHandler {
private static final String TAG = "BluetoothPbapService";
+ private static final String LOG_TAG = "BluetoothPbap";
/**
* To enable PBAP DEBUG/VERBOSE logging - run below cmd in adb shell, and
* restart com.android.bluetooth process. only enable DEBUG log:
* "setprop log.tag.BluetoothPbapService DEBUG"; enable both VERBOSE and
- * DEBUG log: "setprop log.tag.BluetoothPbapService VERBOSE"
+ * DEBUG log: "setprop log.tag.BluetoothPbap VERBOSE"
*/
public static final boolean DEBUG = true;
- public static final boolean VERBOSE = false;
+ public static final boolean VERBOSE = Log.isLoggable(LOG_TAG, Log.VERBOSE);
/**
* Intent indicating incoming obex authentication request which is from
@@ -128,9 +131,13 @@
static final int CHECK_SECONDARY_VERSION_COUNTER = 6;
static final int ROLLOVER_COUNTERS = 7;
static final int GET_LOCAL_TELEPHONY_DETAILS = 8;
+ static final int CLEANUP_HANDLER_TASKS = 9;
+ static final int HANDLE_VERSION_UPDATE_NOTIFICATION = 10;
static final int USER_CONFIRM_TIMEOUT_VALUE = 30000;
static final int RELEASE_WAKE_LOCK_DELAY = 10000;
+ static final int CLEANUP_HANDLER_DELAY = 50;
+ static final int VERSION_UPDATE_NOTIFICATION_DELAY = 500;
private PowerManager.WakeLock mWakeLock;
@@ -148,7 +155,7 @@
private static final int PBAP_NOTIFICATION_ID_START = 1000000;
private static final int PBAP_NOTIFICATION_ID_END = 2000000;
- private int mSdpHandle = -1;
+ protected int mSdpHandle = -1;
protected Context mContext;
@@ -220,7 +227,7 @@
if (access == BluetoothDevice.CONNECTION_ACCESS_YES) {
if (savePreference) {
device.setPhonebookAccessPermission(BluetoothDevice.ACCESS_ALLOWED);
- if (VERBOSE) {
+ if (DEBUG) {
Log.v(TAG, "setPhonebookAccessPermission(ACCESS_ALLOWED)");
}
}
@@ -228,7 +235,7 @@
} else {
if (savePreference) {
device.setPhonebookAccessPermission(BluetoothDevice.ACCESS_REJECTED);
- if (VERBOSE) {
+ if (DEBUG) {
Log.v(TAG, "setPhonebookAccessPermission(ACCESS_REJECTED)");
}
}
@@ -255,6 +262,17 @@
}
sm.sendMessage(PbapStateMachine.AUTH_CANCELLED);
}
+ } else if (BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)) {
+ int bondState = intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,
+ BluetoothDevice.ERROR);
+ if (bondState == BluetoothDevice.BOND_BONDED && BluetoothPbapFixes.isSupportedPbap12) {
+ BluetoothDevice remoteDevice = intent.getParcelableExtra(
+ BluetoothDevice.EXTRA_DEVICE);
+ mSessionStatusHandler.sendMessageDelayed(
+ mSessionStatusHandler.obtainMessage(
+ HANDLE_VERSION_UPDATE_NOTIFICATION, remoteDevice),
+ VERSION_UPDATE_NOTIFICATION_DELAY);
+ }
} else {
Log.w(TAG, "Unhandled intent action: " + action);
}
@@ -284,6 +302,16 @@
if (mSessionStatusHandler != null) {
mSessionStatusHandler.removeCallbacksAndMessages(null);
}
+
+ mSessionStatusHandler.sendMessageDelayed(
+ mSessionStatusHandler.obtainMessage(CLEANUP_HANDLER_TASKS), CLEANUP_HANDLER_DELAY);
+ }
+
+ private void cleanUpHandlerTasks() {
+ Log.d(TAG, "quitHandlerThread");
+ if (mHandlerThread != null) {
+ mHandlerThread.quitSafely();
+ }
}
private void cleanUpServerSocket() {
@@ -306,11 +334,9 @@
if (mSdpHandle > -1) {
Log.w(TAG, "createSdpRecord, SDP record already created");
}
- mSdpHandle = SdpManager.getDefaultManager()
- .createPbapPseRecord("OBEX Phonebook Access Server",
- mServerSockets.getRfcommChannel(), mServerSockets.getL2capPsm(),
- SDP_PBAP_SERVER_VERSION, SDP_PBAP_SUPPORTED_REPOSITORIES,
- SDP_PBAP_SUPPORTED_FEATURES);
+ BluetoothPbapFixes.getFeatureSupport(mContext);
+ BluetoothPbapFixes.createSdpRecord(mServerSockets, this);
+
if (DEBUG) {
Log.d(TAG, "created Sdp record, mSdpHandle=" + mSdpHandle);
}
@@ -347,7 +373,9 @@
switch (msg.what) {
case START_LISTENER:
- mServerSockets = ObexServerSockets.create(BluetoothPbapService.this);
+ mServerSockets = ObexServerSockets.createWithFixedChannels
+ (sBluetoothPbapService, SdpManager.PBAP_RFCOMM_CHANNEL,
+ SdpManager.PBAP_L2CAP_PSM);
if (mServerSockets == null) {
Log.w(TAG, "ObexServerSockets.create() returned null");
break;
@@ -411,6 +439,15 @@
break;
case GET_LOCAL_TELEPHONY_DETAILS:
getLocalTelephonyDetails();
+ break;
+ case CLEANUP_HANDLER_TASKS:
+ cleanUpHandlerTasks();
+ break;
+ case HANDLE_VERSION_UPDATE_NOTIFICATION:
+ BluetoothDevice remoteDev = (BluetoothDevice) msg.obj;
+ BluetoothPbapFixes.handleNotificationTask(
+ sBluetoothPbapService, remoteDev);
+ break;
default:
break;
}
@@ -497,6 +534,7 @@
filter.addAction(BluetoothDevice.ACTION_CONNECTION_ACCESS_REPLY);
filter.addAction(AUTH_RESPONSE_ACTION);
filter.addAction(AUTH_CANCELLED_ACTION);
+ filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
BluetoothPbapConfig.init(this);
registerReceiver(mPbapReceiver, filter);
try {
@@ -508,6 +546,8 @@
Log.e(TAG, "SQLite exception: " + e);
} catch (IllegalStateException e) {
Log.e(TAG, "Illegal state exception, content observer is already registered");
+ } catch (SecurityException e) {
+ Log.e(TAG, "Error while rigistering ContactChangeObserver " + e);
}
setBluetoothPbapService(this);
@@ -528,9 +568,6 @@
if (mSessionStatusHandler != null) {
mSessionStatusHandler.obtainMessage(SHUTDOWN).sendToTarget();
}
- if (mHandlerThread != null) {
- mHandlerThread.quitSafely();
- }
mContactsLoaded = false;
if (mContactChangeObserver == null) {
Log.i(TAG, "Avoid unregister when receiver it is not registered");
@@ -664,7 +701,10 @@
+ " socket=" + socket);
return false;
}
-
+ if (getConnectedDevices().size() >= BluetoothPbapFixes.MAX_CONNECTED_DEVICES) {
+ Log.i(TAG, "Cannot connect to " + remoteDevice + " multiple devices connected already");
+ return false;
+ }
PbapStateMachine sm = PbapStateMachine.make(this, mHandlerThread.getLooper(), remoteDevice,
socket, this, mSessionStatusHandler, mNextNotificationId);
mNextNotificationId++;
@@ -748,9 +788,14 @@
Runnable r = new Runnable() {
@Override
public void run() {
- BluetoothPbapUtils.loadAllContacts(mContext,
- mSessionStatusHandler);
- mThreadLoadContacts = null;
+ try {
+ BluetoothPbapUtils.loadAllContacts(mContext,
+ mSessionStatusHandler);
+ } catch (Exception e) {
+ Log.e(TAG, "loadAllContacts failed: " + e);
+ } finally {
+ mThreadLoadContacts = null;
+ }
}
};
mThreadLoadContacts = new Thread(r);
@@ -763,9 +808,14 @@
Runnable r = new Runnable() {
@Override
public void run() {
- BluetoothPbapUtils.updateSecondaryVersionCounter(mContext,
- mSessionStatusHandler);
- mThreadUpdateSecVersionCounter = null;
+ try {
+ BluetoothPbapUtils.updateSecondaryVersionCounter(mContext,
+ mSessionStatusHandler);
+ } catch (Exception e) {
+ Log.e(TAG, "updateSecondaryVersion counter failed: " + e);
+ } finally {
+ mThreadUpdateSecVersionCounter = null;
+ }
}
};
mThreadUpdateSecVersionCounter = new Thread(r);
diff --git a/src/com/android/bluetooth/pbap/BluetoothPbapUtils.java b/src/com/android/bluetooth/pbap/BluetoothPbapUtils.java
index f8b8e5f..a5c3ec3 100644
--- a/src/com/android/bluetooth/pbap/BluetoothPbapUtils.java
+++ b/src/com/android/bluetooth/pbap/BluetoothPbapUtils.java
@@ -21,6 +21,7 @@
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.database.Cursor;
+import android.database.sqlite.SQLiteException;
import android.net.Uri;
import android.os.Handler;
import android.preference.PreferenceManager;
@@ -199,7 +200,8 @@
}
}
- static void loadAllContacts(Context context, Handler handler) {
+ static void loadAllContacts(Context context, Handler handler)
+ throws IllegalStateException, SQLiteException {
if (V) {
Log.v(TAG, "Loading Contacts ...");
}
@@ -213,7 +215,8 @@
handler.sendMessage(handler.obtainMessage(BluetoothPbapService.CONTACTS_LOADED));
}
- static void updateSecondaryVersionCounter(Context context, Handler handler) {
+ static void updateSecondaryVersionCounter(Context context, Handler handler)
+ throws IllegalStateException, SQLiteException {
/* updatedList stores list of contacts which are added/updated after
* the time when contacts were last updated. (contactsLastUpdated
* indicates the time when contact/contacts were last updated and
@@ -229,9 +232,15 @@
Log.d(TAG, "Failed to fetch data from contact database");
return;
}
+ int indexCid = c.getColumnIndex(Contacts._ID);
+ int indexTimestamp = c.getColumnIndex(Contacts.CONTACT_LAST_UPDATED_TIMESTAMP);
while (c.moveToNext()) {
- String contactId = c.getString(0);
- long lastUpdatedTime = c.getLong(1);
+ if (c.isNull(indexCid)) {
+ Log.d(TAG, "Skipping unavailable contact from cursor.");
+ continue;
+ }
+ String contactId = c.getString(indexCid);
+ long lastUpdatedTime = c.getLong(indexTimestamp);
if (lastUpdatedTime > sContactsLastUpdated) {
updatedList.add(contactId);
}
@@ -430,6 +439,10 @@
int indexMimeType = c.getColumnIndex(Data.MIMETYPE);
String contactId, data, mimeType;
while (c.moveToNext()) {
+ if (c.isNull(indexCId) || c.isNull(indexMimeType)) {
+ Log.e(TAG, "Contact data in cursor is not found. Skipping.");
+ continue;
+ }
contactId = c.getString(indexCId);
data = c.getString(indexData);
mimeType = c.getString(indexMimeType);
diff --git a/src/com/android/bluetooth/pbap/BluetoothPbapVcardManager.java b/src/com/android/bluetooth/pbap/BluetoothPbapVcardManager.java
index 5ba2b4b..6e431a1 100755
--- a/src/com/android/bluetooth/pbap/BluetoothPbapVcardManager.java
+++ b/src/com/android/bluetooth/pbap/BluetoothPbapVcardManager.java
@@ -83,6 +83,7 @@
static final String[] PHONES_CONTACTS_PROJECTION = new String[]{
Phone.CONTACT_ID, // 0
Phone.DISPLAY_NAME, // 1
+ Phone.ACCOUNT_TYPE_AND_DATA_SET, //2
};
static final String[] PHONE_LOOKUP_PROJECTION = new String[]{
@@ -102,6 +103,7 @@
static final String CALLLOG_SORT_ORDER = Calls._ID + " DESC";
private static final int NEED_SEND_BODY = -1;
+ protected static boolean isPullVcardEntry = false;
public BluetoothPbapVcardManager(final Context context) {
mContext = context;
@@ -155,6 +157,9 @@
case BluetoothPbapObexServer.ContentType.PHONEBOOK:
size = getContactsSize();
break;
+ case BluetoothPbapObexServer.ContentType.SIM_PHONEBOOK:
+ size = BluetoothPbapObexServer.mVcardSimManager.getSIMContactsSize();
+ break;
default:
size = getCallHistorySize(type);
break;
@@ -168,19 +173,27 @@
public final int getContactsSize() {
final Uri myUri = DevicePolicyUtils.getEnterprisePhoneUri(mContext);
Cursor contactCursor = null;
+ MatrixCursor mCursor = null;
try {
- contactCursor = mResolver.query(myUri, new String[]{Phone.CONTACT_ID}, null, null,
- Phone.CONTACT_ID);
+ contactCursor = mResolver.query(
+ myUri,
+ new String[] {Phone.CONTACT_ID, Phone.ACCOUNT_TYPE_AND_DATA_SET},
+ null, null, Phone.CONTACT_ID);
if (contactCursor == null) {
return 0;
}
- return getDistinctContactIdSize(contactCursor) + 1; // always has the 0.vcf
+ mCursor = BluetoothPbapFixes.filterOutSimContacts(contactCursor);
+ return mCursor.getCount() + 1; // always has the 0.vcf
} catch (CursorWindowAllocationException e) {
Log.e(TAG, "CursorWindowAllocationException while getting Contacts size");
} finally {
if (contactCursor != null) {
contactCursor.close();
}
+ if (mCursor != null) {
+ mCursor.close();
+ mCursor = null;
+ }
}
return 0;
}
@@ -260,7 +273,7 @@
if (ownerName == null || ownerName.length() == 0) {
ownerName = BluetoothPbapService.getLocalPhoneName();
}
- nameList.add(ownerName);
+ nameList.add(ownerName + "," + "0");
//End enhancement
final Uri myUri = DevicePolicyUtils.getEnterprisePhoneUri(mContext);
@@ -323,7 +336,7 @@
if (ownerName == null || ownerName.length() == 0) {
ownerName = BluetoothPbapService.getLocalPhoneName();
}
- nameList.add(ownerName);
+ nameList.add(ownerName + "," + "0");
// End enhancement
final Uri myUri = DevicePolicyUtils.getEnterprisePhoneUri(mContext);
@@ -333,6 +346,8 @@
Phone.CONTACT_ID);
ArrayList<String> contactNameIdList = new ArrayList<String>();
+ contactCursor = getContactNameIdList(contactCursor,
+ contactNameIdList, mContext.getString(android.R.string.unknownName));
appendDistinctNameIdList(contactNameIdList,
mContext.getString(android.R.string.unknownName), contactCursor);
@@ -565,6 +580,7 @@
try {
contactCursor = mResolver.query(myUri, PHONES_CONTACTS_PROJECTION, null, null,
Phone.CONTACT_ID);
+ contactCursor = BluetoothPbapFixes.filterOutSimContacts(contactCursor);
if (contactCursor != null) {
contactIdCursor =
ContactCursorFilter.filterByRange(contactCursor, startPoint, endPoint);
@@ -577,7 +593,7 @@
}
}
- if (vcardselect) {
+ if (BluetoothPbapFixes.isSupportedPbap12 && vcardselect) {
return composeContactsAndSendSelectedVCards(op, contactIdCursor, vcardType21,
ownerVCard, needSendBody, pbSize, ignorefilter, filter, vcardselector,
vcardselectorop);
@@ -610,6 +626,7 @@
} catch (CursorWindowAllocationException e) {
Log.e(TAG, "CursorWindowAllocationException while composing phonebook one vcard");
} finally {
+ contactCursor = BluetoothPbapFixes.filterOutSimContacts(contactCursor);
if (contactCursor != null) {
contactIdCursor = ContactCursorFilter.filterByOffset(contactCursor, offset);
contactCursor.close();
@@ -631,6 +648,7 @@
* @return a cursor containing contact id of {@code offset} contact.
*/
public static Cursor filterByOffset(Cursor contactCursor, int offset) {
+ isPullVcardEntry = true;
return filterByRange(contactCursor, offset, offset);
}
@@ -651,6 +669,10 @@
final MatrixCursor contactIdsCursor = new MatrixCursor(new String[]{
Phone.CONTACT_ID
});
+ if (startPoint == endPoint && isPullVcardEntry) {
+ return BluetoothPbapFixes.getVcardEntry(contactCursor,
+ contactIdsCursor, contactIdColumn, startPoint);
+ }
while (contactCursor.moveToNext() && currentOffset <= endPoint) {
long currentContactId = contactCursor.getLong(contactIdColumn);
if (previousContactId != currentContactId) {
@@ -1322,17 +1344,21 @@
final int contactIdColumn = cursor.getColumnIndex(Data.CONTACT_ID);
final int idColumn = cursor.getColumnIndex(Data._ID);
final int nameColumn = cursor.getColumnIndex(Data.DISPLAY_NAME);
+ final int accountIndex = cursor.getColumnIndex(Phone.ACCOUNT_TYPE_AND_DATA_SET);
cursor.moveToPosition(-1);
while (cursor.moveToNext()) {
final long contactId =
cursor.getLong(contactIdColumn != -1 ? contactIdColumn : idColumn);
String displayName = nameColumn != -1 ? cursor.getString(nameColumn) : defaultName;
+ String accountType = accountIndex != -1 ? cursor.getString(accountIndex) :
+ BluetoothPbapFixes.getAccount(contactId);
if (TextUtils.isEmpty(displayName)) {
displayName = defaultName;
}
String newString = displayName + "," + contactId;
- if (!resultList.contains(newString)) {
+ if (!resultList.contains(newString) &&
+ !(accountType != null && accountType.startsWith("com.android.sim"))) {
resultList.add(newString);
}
}
@@ -1342,4 +1368,36 @@
}
}
}
+
+ /* creates name and id list of Non-sim contacts as display_name + "," + contact_id */
+ protected static Cursor getContactNameIdList(Cursor cursor,
+ ArrayList<String> contactIdList, String unknownName) {
+ if (cursor == null)
+ return null;
+ MatrixCursor mCursor = new MatrixCursor(new String[]{
+ Phone.CONTACT_ID
+ });
+
+ long previousContactId = -1;
+ final int contactIdColumn = cursor.getColumnIndex(Data.CONTACT_ID);
+ final int idColumn = cursor.getColumnIndex(Data._ID);
+ final int nameColumn = cursor.getColumnIndex(Data.DISPLAY_NAME);
+ final int account_col_id = cursor.getColumnIndex(Phone.ACCOUNT_TYPE_AND_DATA_SET);
+ cursor.moveToPosition(-1);
+ while (cursor.moveToNext()) {
+ long currentContactId = contactIdColumn != -1 ? cursor.getLong(contactIdColumn)
+ : cursor.getLong(idColumn);
+ String displayName = nameColumn != -1 ? cursor.getString(nameColumn)
+ : unknownName;
+ String accType = cursor.getString(account_col_id);
+ if (previousContactId != currentContactId &&
+ !(accType != null && accType.startsWith("com.android.sim"))) {
+ if (V) Log.v(TAG, displayName + "," + currentContactId);
+ previousContactId = currentContactId;
+ mCursor.addRow(new Long[]{currentContactId});
+ contactIdList.add(displayName + "," + Long.toString(currentContactId));
+ }
+ }
+ return mCursor;
+ }
}
diff --git a/src/com/android/bluetooth/pbap/PbapStateMachine.java b/src/com/android/bluetooth/pbap/PbapStateMachine.java
index 0f53be5..52d2a46 100644
--- a/src/com/android/bluetooth/pbap/PbapStateMachine.java
+++ b/src/com/android/bluetooth/pbap/PbapStateMachine.java
@@ -342,8 +342,6 @@
}
BluetoothObexTransport transport = new BluetoothObexTransport(mConnSocket);
mServerSession = new ServerSession(transport, mPbapServer, mObexAuth);
- // It's ok to just use one wake lock
- // Message MSG_ACQUIRE_WAKE_LOCK is always surrounded by RELEASE. safe.
}
private void stopObexServerSession() {
@@ -392,9 +390,11 @@
.setFlag(Notification.FLAG_AUTO_CANCEL, true)
.setFlag(Notification.FLAG_ONLY_ALERT_ONCE, true)
.setContentIntent(
- PendingIntent.getActivity(mService, 0, clickIntent, 0))
+ PendingIntent.getActivity(mService, 0, clickIntent,
+ PendingIntent.FLAG_UPDATE_CURRENT))
.setDeleteIntent(
- PendingIntent.getBroadcast(mService, 0, deleteIntent, 0))
+ PendingIntent.getBroadcast(mService, 0, deleteIntent,
+ PendingIntent.FLAG_UPDATE_CURRENT))
.setLocalOnly(true)
.build();
nm.notify(mNotificationId, notification);
diff --git a/src/com/android/bluetooth/sap/SapServer.java b/src/com/android/bluetooth/sap/SapServer.java
index d8281fe..63e1d08 100644
--- a/src/com/android/bluetooth/sap/SapServer.java
+++ b/src/com/android/bluetooth/sap/SapServer.java
@@ -11,6 +11,7 @@
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
+import android.graphics.drawable.Icon;
import android.hardware.radio.V1_0.ISap;
import android.os.Handler;
import android.os.Handler.Callback;
@@ -252,16 +253,17 @@
sapDisconnectIntent.putExtra(SapServer.SAP_DISCONNECT_TYPE_EXTRA, type);
PendingIntent pIntentDisconnect =
PendingIntent.getBroadcast(mContext, type, sapDisconnectIntent, flags);
+ Notification.Action actionDisconnect =
+ new Notification.Action.Builder(Icon.createWithResource(mContext,
+ android.R.drawable.stat_sys_data_bluetooth), button,pIntentDisconnect).build();
notification =
new Notification.Builder(mContext, SAP_NOTIFICATION_CHANNEL).setOngoing(true)
- .addAction(android.R.drawable.stat_sys_data_bluetooth, button,
- pIntentDisconnect)
+ .addAction(actionDisconnect)
.setContentTitle(title)
.setTicker(ticker)
.setContentText(text)
.setSmallIcon(android.R.drawable.stat_sys_data_bluetooth)
.setAutoCancel(false)
- .setPriority(Notification.PRIORITY_MAX)
.setOnlyAlertOnce(true)
.setLocalOnly(true)
.build();
@@ -277,22 +279,24 @@
PendingIntent pIntentForceDisconnect =
PendingIntent.getBroadcast(mContext, SapMessage.DISC_IMMEDIATE,
sapForceDisconnectIntent, flags);
+ Notification.Action actionDisconnect = new Notification.Action.Builder(
+ Icon.createWithResource(mContext, android.R.drawable.stat_sys_data_bluetooth),
+ mContext.getString(R.string.bluetooth_sap_notif_disconnect_button),
+ pIntentDisconnect).build();
+ Notification.Action actionForceDisconnect =
+ new Notification.Action.Builder(Icon.createWithResource(mContext,
+ android.R.drawable.stat_sys_data_bluetooth),
+ mContext.getString(R.string.bluetooth_sap_notif_force_disconnect_button),
+ pIntentForceDisconnect).build();
notification =
new Notification.Builder(mContext, SAP_NOTIFICATION_CHANNEL).setOngoing(true)
- .addAction(android.R.drawable.stat_sys_data_bluetooth,
- mContext.getString(
- R.string.bluetooth_sap_notif_disconnect_button),
- pIntentDisconnect)
- .addAction(android.R.drawable.stat_sys_data_bluetooth,
- mContext.getString(
- R.string.bluetooth_sap_notif_force_disconnect_button),
- pIntentForceDisconnect)
+ .addAction(actionDisconnect)
+ .addAction(actionForceDisconnect)
.setContentTitle(title)
.setTicker(ticker)
.setContentText(text)
.setSmallIcon(android.R.drawable.stat_sys_data_bluetooth)
.setAutoCancel(false)
- .setPriority(Notification.PRIORITY_MAX)
.setOnlyAlertOnce(true)
.setLocalOnly(true)
.build();
diff --git a/src/com/android/bluetooth/sap/SapService.java b/src/com/android/bluetooth/sap/SapService.java
index a9b1994..9a9c0f8 100644
--- a/src/com/android/bluetooth/sap/SapService.java
+++ b/src/com/android/bluetooth/sap/SapService.java
@@ -42,9 +42,10 @@
private static final String SDP_SAP_SERVICE_NAME = "SIM Access";
private static final int SDP_SAP_VERSION = 0x0102;
+ private static final String LOG_TAG = "BluetoothSap";
private static final String TAG = "SapService";
- public static final boolean DEBUG = false;
- public static final boolean VERBOSE = false;
+ public static final boolean DEBUG = true;
+ public static final boolean VERBOSE = Log.isLoggable(LOG_TAG, Log.VERBOSE);
/* Message ID's */
private static final int START_LISTENER = 1;
@@ -155,15 +156,19 @@
// It is mandatory for MSE to support initiation of bonding and encryption.
// TODO: Consider reusing the mServerSocket - it is indented to be reused
// for multiple connections.
- mServerSocket = mAdapter.listenUsingRfcommOn(
- BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP, true, true);
removeSdpRecord();
+ mServerSocket = mAdapter.listenUsingRfcommOn(
+ SdpManager.SAP_RFCOMM_CHANNEL, true, true);
mSdpHandle = SdpManager.getDefaultManager()
.createSapsRecord(SDP_SAP_SERVICE_NAME, mServerSocket.getChannel(),
SDP_SAP_VERSION);
} catch (IOException e) {
Log.e(TAG, "Error create RfcommServerSocket ", e);
initSocketOK = false;
+ } catch (SecurityException e) {
+ Log.e(TAG, "Error create RfcommServerSocket ", e);
+ initSocketOK = false;
+ break;
}
if (!initSocketOK) {
@@ -367,7 +372,7 @@
}
int permission = mRemoteDevice.getSimAccessPermission();
- if (VERBOSE) {
+ if (DEBUG) {
Log.v(TAG, "getSimAccessPermission() = " + permission);
}
@@ -394,7 +399,7 @@
setUserTimeoutAlarm();
sendBroadcast(intent, BLUETOOTH_ADMIN_PERM);
- if (VERBOSE) {
+ if (DEBUG) {
Log.v(TAG, "waiting for authorization for connection from: "
+ sRemoteDeviceName);
}
@@ -433,9 +438,7 @@
switch (msg.what) {
case START_LISTENER:
- if (mAdapter.isEnabled()) {
- startRfcommSocketListener();
- }
+ startRfcommSocketListener();
break;
case USER_TIMEOUT:
if (mIsWaitingAuthorization) {
@@ -619,7 +622,6 @@
Log.v(TAG, "start()");
IntentFilter filter = new IntentFilter();
filter.addAction(BluetoothDevice.ACTION_CONNECTION_ACCESS_REPLY);
- filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);
filter.addAction(USER_CONFIRM_TIMEOUT_ACTION);
@@ -761,25 +763,6 @@
Log.v(TAG, "onReceive");
}
String action = intent.getAction();
- if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {
- int state =
- intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR);
- if (state == BluetoothAdapter.STATE_TURNING_OFF) {
- if (DEBUG) {
- Log.d(TAG, "STATE_TURNING_OFF");
- }
- sendShutdownMessage();
- } else if (state == BluetoothAdapter.STATE_ON) {
- if (DEBUG) {
- Log.d(TAG, "STATE_ON");
- }
- // start RFCOMM listener
- mSessionStatusHandler.sendMessage(
- mSessionStatusHandler.obtainMessage(START_LISTENER));
- }
- return;
- }
-
if (action.equals(BluetoothDevice.ACTION_CONNECTION_ACCESS_REPLY)) {
Log.v(TAG, " - Received BluetoothDevice.ACTION_CONNECTION_ACCESS_REPLY");
if (!mIsWaitingAuthorization) {
diff --git a/src/com/android/bluetooth/sdp/SdpManager.java b/src/com/android/bluetooth/sdp/SdpManager.java
index d5e3770..15a9cc1 100644
--- a/src/com/android/bluetooth/sdp/SdpManager.java
+++ b/src/com/android/bluetooth/sdp/SdpManager.java
@@ -49,6 +49,21 @@
public static final byte PBAP_REPO_SPEED_DAIL = 0x01 << 2;
public static final byte PBAP_REPO_FAVORITES = 0x01 << 3;
+ public static final int OPP_L2CAP_PSM = 0x1023;
+ public static final int PBAP_L2CAP_PSM = 0x1025;
+ public static final int MNS_L2CAP_PSM = 0x1027;
+ public static final int MAP_L2CAP_PSM = 0x1029;
+
+ public static final int OPP_RFCOMM_CHANNEL = 12;
+ public static final int SAP_RFCOMM_CHANNEL = 16;
+ public static final int PBAP_RFCOMM_CHANNEL = 19;
+ public static final int MNS_RFCOMM_CHANNEL = 22;
+ /* SMS/MMS will use channel 26 & Email channels are set from 27 to 30*/
+ public static final int MAP_RFCOMM_CHANNEL = 26;
+
+ public static final int NEXT_RFCOMM_CHANNEL = 1;
+ public static final int NEXT_L2CAP_CHANNEL = 2;
+
/* Variables to keep track of ongoing and queued search requests.
* mTrackerLock must be held, when using/changing sSdpSearchTracker
* and mSearchInProgress. */
diff --git a/tests/unit/src/com/android/bluetooth/TestUtils.java b/tests/unit/src/com/android/bluetooth/TestUtils.java
index 4e6b7ba..fef4d0e 100644
--- a/tests/unit/src/com/android/bluetooth/TestUtils.java
+++ b/tests/unit/src/com/android/bluetooth/TestUtils.java
@@ -301,8 +301,7 @@
adapterConfig.put(section, new HashMap<>());
} else {
String[] keyValue = line.split("=");
- adapterConfig.get(section).put(keyValue[0].trim(),
- keyValue.length == 1 ? "" : keyValue[1].trim());
+ adapterConfig.get(section).put(keyValue[0].trim(), keyValue[1].trim());
}
}
} catch (IOException e) {
diff --git a/tests/unit/src/com/android/bluetooth/avrcp/AvrcpTest.java b/tests/unit/src/com/android/bluetooth/avrcp/AvrcpTest.java
new file mode 100644
index 0000000..871dde0
--- /dev/null
+++ b/tests/unit/src/com/android/bluetooth/avrcp/AvrcpTest.java
@@ -0,0 +1,84 @@
+package com.android.bluetooth.avrcp;
+
+import static org.mockito.Mockito.*;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
+import android.media.AudioManager;
+import android.os.Looper;
+
+import androidx.test.InstrumentationRegistry;
+import androidx.test.filters.MediumTest;
+import androidx.test.runner.AndroidJUnit4;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * Unit tests for {@link Avrcp}
+ */
+@MediumTest
+@RunWith(AndroidJUnit4.class)
+public class AvrcpTest {
+ @Test
+ public void testCanStart() {
+ if (Looper.myLooper() == null) {
+ Looper.prepare();
+ }
+
+ Avrcp a = Avrcp.make(InstrumentationRegistry.getTargetContext());
+ }
+
+ @Test
+ public void testFailedBrowseStart() {
+ if (Looper.myLooper() == null) {
+ Looper.prepare();
+ }
+
+ Context mockContext = mock(Context.class);
+ AudioManager mockAudioManager = mock(AudioManager.class);
+ PackageManager mockPackageManager = mock(PackageManager.class);
+
+ when(mockAudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC)).thenReturn(100);
+
+ when(mockContext.getSystemService(Context.AUDIO_SERVICE)).thenReturn(mockAudioManager);
+
+ when(mockContext.getApplicationContext()).thenReturn(mockContext);
+ when(mockContext.getPackageManager()).thenReturn(mockPackageManager);
+
+
+ // Call to get the BrowsableMediaPlayers
+ // We must return at least one to try to startService
+ List<ResolveInfo> resInfos = new ArrayList<ResolveInfo>();
+
+ ServiceInfo fakeService = new ServiceInfo();
+ fakeService.name = ".browse.MediaBrowserService";
+ fakeService.packageName = "com.test.android.fake";
+
+ ResolveInfo fakePackage = new ResolveInfo();
+ fakePackage.serviceInfo = fakeService;
+ fakePackage.nonLocalizedLabel = "Fake Package";
+ resInfos.add(fakePackage);
+ when(mockPackageManager.queryIntentServices(isA(Intent.class), anyInt())).thenReturn(
+ resInfos);
+
+ when(mockContext.startService(isA(Intent.class))).thenThrow(new SecurityException("test"));
+
+ // Make calls start() which calls buildMediaPlayersList() which should
+ // try to start the service?
+ try {
+ Avrcp a = Avrcp.make(mockContext);
+ } catch (SecurityException e) {
+ Assert.fail(
+ "Threw SecurityException instead of protecting against it: " + e.toString());
+ }
+ }
+}
diff --git a/tests/unit/src/com/android/bluetooth/avrcp/EvictingQueueTest.java b/tests/unit/src/com/android/bluetooth/avrcp/EvictingQueueTest.java
new file mode 100644
index 0000000..e60ea0f
--- /dev/null
+++ b/tests/unit/src/com/android/bluetooth/avrcp/EvictingQueueTest.java
@@ -0,0 +1,58 @@
+package com.android.bluetooth.avrcp;
+
+import androidx.test.filters.MediumTest;
+import androidx.test.runner.AndroidJUnit4;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * Unit tests for {@link EvictingQueue}.
+ */
+@MediumTest
+@RunWith(AndroidJUnit4.class)
+public class EvictingQueueTest {
+ @Test
+ public void testEvictingQueue_canAddItems() {
+ EvictingQueue<Integer> e = new EvictingQueue<Integer>(10);
+
+ e.add(1);
+
+ Assert.assertEquals((long) e.size(), (long) 1);
+ }
+
+ @Test
+ public void testEvictingQueue_maxItems() {
+ EvictingQueue<Integer> e = new EvictingQueue<Integer>(5);
+
+ e.add(1);
+ e.add(2);
+ e.add(3);
+ e.add(4);
+ e.add(5);
+ e.add(6);
+
+ Assert.assertEquals((long) e.size(), (long) 5);
+ // Items drop off the front
+ Assert.assertEquals((long) e.peek(), (long) 2);
+ }
+
+ @Test
+ public void testEvictingQueue_frontDrop() {
+ EvictingQueue<Integer> e = new EvictingQueue<Integer>(5);
+
+ e.add(1);
+ e.add(2);
+ e.add(3);
+ e.add(4);
+ e.add(5);
+
+ Assert.assertEquals((long) e.size(), (long) 5);
+
+ e.addFirst(6);
+
+ Assert.assertEquals((long) e.size(), (long) 5);
+ Assert.assertEquals((long) e.peek(), (long) 1);
+ }
+}
diff --git a/tests/unit/src/com/android/bluetooth/btservice/BondStateMachineTest.java b/tests/unit/src/com/android/bluetooth/btservice/BondStateMachineTest.java
index b9c8953..7666f3a 100644
--- a/tests/unit/src/com/android/bluetooth/btservice/BondStateMachineTest.java
+++ b/tests/unit/src/com/android/bluetooth/btservice/BondStateMachineTest.java
@@ -22,8 +22,8 @@
import android.content.Intent;
import android.os.HandlerThread;
import android.os.ParcelUuid;
+import android.os.PowerManager;
import android.os.UserHandle;
-
import androidx.test.InstrumentationRegistry;
import androidx.test.filters.MediumTest;
import androidx.test.runner.AndroidJUnit4;
@@ -76,7 +76,8 @@
mTargetContext.getResources());
mAdapterProperties = new AdapterProperties(mAdapterService);
mAdapterProperties.init(mRemoteDevices);
- mBondStateMachine = BondStateMachine.make(mAdapterService, mAdapterProperties,
+ PowerManager powerManager = (PowerManager) mTargetContext.getSystemService(Context.POWER_SERVICE);
+ mBondStateMachine = BondStateMachine.make(powerManager, mAdapterService, mAdapterProperties,
mRemoteDevices);
}
diff --git a/tests/unit/src/com/android/bluetooth/hid/HidHostServiceTest.java b/tests/unit/src/com/android/bluetooth/hid/HidHostServiceTest.java
index ede535d..4e0ec59 100644
--- a/tests/unit/src/com/android/bluetooth/hid/HidHostServiceTest.java
+++ b/tests/unit/src/com/android/bluetooth/hid/HidHostServiceTest.java
@@ -53,7 +53,6 @@
@Rule public final ServiceTestRule mServiceRule = new ServiceTestRule();
@Mock private AdapterService mAdapterService;
- @Mock private DatabaseManager mDatabaseManager;
@Before
public void setUp() throws Exception {
@@ -146,15 +145,13 @@
*
* @param device test device
* @param bondState bond state value, could be invalid
- * @param priority value, could be invalid, could be invalid
+ * @param priority value, could be invalid
* @param expected expected result from okToConnect()
*/
private void testOkToConnectCase(BluetoothDevice device, int bondState, int priority,
boolean expected) {
doReturn(bondState).when(mAdapterService).getBondState(device);
- when(mAdapterService.getDatabase()).thenReturn(mDatabaseManager);
- when(mDatabaseManager.getProfilePriority(device, BluetoothProfile.HID_HOST))
- .thenReturn(priority);
+ Assert.assertTrue(mService.setPriority(device, priority));
// Test when the AdapterService is in non-quiet mode.
doReturn(false).when(mAdapterService).isQuietModeEnabled();