| /* |
| * 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 "BluetoothAvrcpControllerJni" |
| |
| #define LOG_NDEBUG 0 |
| |
| #include "android_runtime/AndroidRuntime.h" |
| #include "com_android_bluetooth.h" |
| #include "hardware/bt_rc.h" |
| #include "utils/Log.h" |
| |
| #include <string.h> |
| #include <shared_mutex> |
| |
| namespace android { |
| static jmethodID method_handlePassthroughRsp; |
| static jmethodID method_onConnectionStateChanged; |
| static jmethodID method_getRcFeatures; |
| static jmethodID method_setplayerappsettingrsp; |
| static jmethodID method_handleplayerappsetting; |
| static jmethodID method_handleplayerappsettingchanged; |
| static jmethodID method_handleSetAbsVolume; |
| static jmethodID method_handleRegisterNotificationAbsVol; |
| static jmethodID method_handletrackchanged; |
| static jmethodID method_handleplaypositionchanged; |
| static jmethodID method_handleplaystatuschanged; |
| static jmethodID method_handleGetFolderItemsRsp; |
| static jmethodID method_handleGetPlayerItemsRsp; |
| static jmethodID method_handleGroupNavigationRsp; |
| static jmethodID method_createFromNativeMediaItem; |
| static jmethodID method_createFromNativeFolderItem; |
| static jmethodID method_createFromNativePlayerItem; |
| static jmethodID method_handleChangeFolderRsp; |
| static jmethodID method_handleSetBrowsedPlayerRsp; |
| static jmethodID method_handleSetAddressedPlayerRsp; |
| static jmethodID method_handleAddressedPlayerChanged; |
| static jmethodID method_handleNowPlayingContentChanged; |
| |
| static jclass class_MediaBrowser_MediaItem; |
| static jclass class_AvrcpPlayer; |
| |
| static const btrc_ctrl_interface_t* sBluetoothAvrcpInterface = NULL; |
| static jobject sCallbacksObj = NULL; |
| static std::shared_timed_mutex sCallbacks_mutex; |
| |
| static void btavrcp_passthrough_response_callback(const RawAddress& bd_addr, |
| int id, int pressed) { |
| ALOGI("%s: id: %d, pressed: %d", __func__, id, pressed); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handlePassthroughRsp, |
| (jint)id, (jint)pressed, addr.get()); |
| } |
| |
| static void btavrcp_groupnavigation_response_callback(int id, int pressed) { |
| ALOGV("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleGroupNavigationRsp, |
| (jint)id, (jint)pressed); |
| } |
| |
| static void btavrcp_connection_state_callback(bool rc_connect, bool br_connect, |
| const RawAddress& bd_addr) { |
| ALOGI("%s: conn state: rc: %d br: %d", __func__, rc_connect, br_connect); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)bd_addr.address); |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_onConnectionStateChanged, |
| (jboolean)rc_connect, (jboolean)br_connect, |
| addr.get()); |
| } |
| |
| static void btavrcp_get_rcfeatures_callback(const RawAddress& bd_addr, |
| int features) { |
| ALOGV("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_getRcFeatures, addr.get(), |
| (jint)features); |
| } |
| |
| static void btavrcp_setplayerapplicationsetting_rsp_callback( |
| const RawAddress& bd_addr, uint8_t accepted) { |
| ALOGV("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_setplayerappsettingrsp, |
| addr.get(), (jint)accepted); |
| } |
| |
| 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, |
| btrc_player_app_ext_attr_t* ext_attrs) { |
| ALOGI("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| /* TODO ext attrs |
| * Flattening defined attributes: <id,num_values,values[]> |
| */ |
| jint arraylen = 0; |
| for (int i = 0; i < num_attr; i++) { |
| /*2 bytes for id and num */ |
| arraylen += 2 + app_attrs[i].num_val; |
| } |
| ALOGV(" arraylen %d", arraylen); |
| |
| ScopedLocalRef<jbyteArray> playerattribs( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(arraylen)); |
| if (!playerattribs.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| for (int i = 0, k = 0; (i < num_attr) && (k < arraylen); i++) { |
| sCallbackEnv->SetByteArrayRegion(playerattribs.get(), k, 1, |
| (jbyte*)&(app_attrs[i].attr_id)); |
| k++; |
| sCallbackEnv->SetByteArrayRegion(playerattribs.get(), k, 1, |
| (jbyte*)&(app_attrs[i].num_val)); |
| k++; |
| sCallbackEnv->SetByteArrayRegion(playerattribs.get(), k, |
| app_attrs[i].num_val, |
| (jbyte*)(app_attrs[i].attr_val)); |
| k = k + app_attrs[i].num_val; |
| } |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleplayerappsetting, |
| addr.get(), playerattribs.get(), (jint)arraylen); |
| } |
| |
| static void btavrcp_playerapplicationsetting_changed_callback( |
| const RawAddress& bd_addr, const btrc_player_settings_t& vals) { |
| ALOGI("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| |
| int arraylen = vals.num_attr * 2; |
| ScopedLocalRef<jbyteArray> playerattribs( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(arraylen)); |
| if (!playerattribs.get()) { |
| ALOGE("Fail to new jbyteArray playerattribs "); |
| return; |
| } |
| /* |
| * Flatening format: <id,val> |
| */ |
| for (int i = 0, k = 0; (i < vals.num_attr) && (k < arraylen); i++) { |
| sCallbackEnv->SetByteArrayRegion(playerattribs.get(), k, 1, |
| (jbyte*)&(vals.attr_ids[i])); |
| k++; |
| sCallbackEnv->SetByteArrayRegion(playerattribs.get(), k, 1, |
| (jbyte*)&(vals.attr_values[i])); |
| k++; |
| } |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, |
| method_handleplayerappsettingchanged, addr.get(), |
| playerattribs.get(), (jint)arraylen); |
| } |
| |
| static void btavrcp_set_abs_vol_cmd_callback(const RawAddress& bd_addr, |
| uint8_t abs_vol, uint8_t label) { |
| ALOGI("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleSetAbsVolume, |
| addr.get(), (jbyte)abs_vol, (jbyte)label); |
| } |
| |
| static void btavrcp_register_notification_absvol_callback( |
| const RawAddress& bd_addr, uint8_t label) { |
| ALOGI("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, |
| method_handleRegisterNotificationAbsVol, |
| addr.get(), (jbyte)label); |
| } |
| |
| static void btavrcp_track_changed_callback(const 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. |
| */ |
| ALOGI("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jintArray> attribIds(sCallbackEnv.get(), |
| sCallbackEnv->NewIntArray(num_attr)); |
| if (!attribIds.get()) { |
| ALOGE(" failed to set new array for attribIds"); |
| return; |
| } |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| |
| jclass strclazz = sCallbackEnv->FindClass("java/lang/String"); |
| ScopedLocalRef<jobjectArray> stringArray( |
| sCallbackEnv.get(), |
| sCallbackEnv->NewObjectArray((jint)num_attr, strclazz, 0)); |
| if (!stringArray.get()) { |
| ALOGE(" failed to get String array"); |
| return; |
| } |
| |
| for (jint i = 0; i < num_attr; i++) { |
| ScopedLocalRef<jstring> str( |
| sCallbackEnv.get(), |
| sCallbackEnv->NewStringUTF((char*)(p_attrs[i].text))); |
| if (!str.get()) { |
| ALOGE("Unable to get str"); |
| return; |
| } |
| sCallbackEnv->SetIntArrayRegion(attribIds.get(), i, 1, |
| (jint*)&(p_attrs[i].attr_id)); |
| sCallbackEnv->SetObjectArrayElement(stringArray.get(), i, str.get()); |
| } |
| |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handletrackchanged, |
| addr.get(), (jbyte)(num_attr), attribIds.get(), |
| stringArray.get()); |
| } |
| |
| static void btavrcp_play_position_changed_callback(const RawAddress& bd_addr, |
| uint32_t song_len, |
| uint32_t song_pos) { |
| ALOGI("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleplaypositionchanged, |
| addr.get(), (jint)(song_len), (jint)song_pos); |
| } |
| |
| static void btavrcp_play_status_changed_callback( |
| const RawAddress& bd_addr, btrc_play_status_t play_status) { |
| ALOGI("%s", __func__); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleplaystatuschanged, |
| addr.get(), (jbyte)play_status); |
| } |
| |
| static void btavrcp_get_folder_items_callback( |
| const RawAddress& bd_addr, btrc_status_t status, |
| const btrc_folder_items_t* folder_items, uint8_t count) { |
| /* Folder items are list of items that can be either BTRC_ITEM_PLAYER |
| * BTRC_ITEM_MEDIA, BTRC_ITEM_FOLDER. Here we translate them to their java |
| * counterparts by calling the java constructor for each of the items. |
| */ |
| ALOGV("%s count %d", __func__, count); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| |
| // Inspect if the first element is a folder/item or player listing. They are |
| // always exclusive. |
| bool isPlayerListing = |
| count > 0 && (folder_items[0].item_type == BTRC_ITEM_PLAYER); |
| |
| // Initialize arrays for Folder OR Player listing. |
| ScopedLocalRef<jobjectArray> itemArray(sCallbackEnv.get(), NULL); |
| if (isPlayerListing) { |
| itemArray.reset( |
| sCallbackEnv->NewObjectArray((jint)count, class_AvrcpPlayer, 0)); |
| } else { |
| itemArray.reset(sCallbackEnv->NewObjectArray( |
| (jint)count, class_MediaBrowser_MediaItem, 0)); |
| } |
| if (!itemArray.get()) { |
| ALOGE("%s itemArray allocation failed.", __func__); |
| return; |
| } |
| for (int i = 0; i < count; i++) { |
| const btrc_folder_items_t* item = &(folder_items[i]); |
| ALOGV("%s item type %d", __func__, item->item_type); |
| switch (item->item_type) { |
| case BTRC_ITEM_MEDIA: { |
| // Parse name |
| ScopedLocalRef<jstring> mediaName( |
| sCallbackEnv.get(), |
| sCallbackEnv->NewStringUTF((const char*)item->media.name)); |
| if (!mediaName.get()) { |
| ALOGE("%s can't allocate media name string!", __func__); |
| return; |
| } |
| // Parse UID |
| long long uid = *(long long*)item->media.uid; |
| // Parse Attrs |
| ScopedLocalRef<jintArray> attrIdArray( |
| sCallbackEnv.get(), |
| sCallbackEnv->NewIntArray(item->media.num_attrs)); |
| if (!attrIdArray.get()) { |
| ALOGE("%s can't allocate attr id array!", __func__); |
| return; |
| } |
| ScopedLocalRef<jobjectArray> attrValArray( |
| sCallbackEnv.get(), |
| sCallbackEnv->NewObjectArray( |
| item->media.num_attrs, |
| sCallbackEnv->FindClass("java/lang/String"), 0)); |
| if (!attrValArray.get()) { |
| ALOGE("%s can't allocate attr val array!", __func__); |
| return; |
| } |
| |
| for (int j = 0; j < item->media.num_attrs; j++) { |
| sCallbackEnv->SetIntArrayRegion( |
| attrIdArray.get(), j, 1, |
| (jint*)&(item->media.p_attrs[j].attr_id)); |
| ScopedLocalRef<jstring> attrValStr( |
| sCallbackEnv.get(), |
| sCallbackEnv->NewStringUTF((char*)(item->media.p_attrs[j].text))); |
| sCallbackEnv->SetObjectArrayElement(attrValArray.get(), j, |
| attrValStr.get()); |
| } |
| |
| ScopedLocalRef<jobject> mediaObj( |
| sCallbackEnv.get(), |
| (jobject)sCallbackEnv->CallObjectMethod( |
| sCallbacksObj, method_createFromNativeMediaItem, uid, |
| (jint)item->media.type, mediaName.get(), attrIdArray.get(), |
| attrValArray.get())); |
| if (!mediaObj.get()) { |
| ALOGE("%s failed to creae MediaItem for type ITEM_MEDIA", __func__); |
| return; |
| } |
| sCallbackEnv->SetObjectArrayElement(itemArray.get(), i, mediaObj.get()); |
| break; |
| } |
| |
| case BTRC_ITEM_FOLDER: { |
| // Parse name |
| ScopedLocalRef<jstring> folderName( |
| sCallbackEnv.get(), |
| sCallbackEnv->NewStringUTF((const char*)item->folder.name)); |
| if (!folderName.get()) { |
| ALOGE("%s can't allocate folder name string!", __func__); |
| return; |
| } |
| // Parse UID |
| long long uid = *(long long*)item->folder.uid; |
| ScopedLocalRef<jobject> folderObj( |
| sCallbackEnv.get(), |
| (jobject)sCallbackEnv->CallObjectMethod( |
| sCallbacksObj, method_createFromNativeFolderItem, uid, |
| (jint)item->folder.type, folderName.get(), |
| (jint)item->folder.playable)); |
| if (!folderObj.get()) { |
| ALOGE("%s failed to create MediaItem for type ITEM_FOLDER", __func__); |
| return; |
| } |
| sCallbackEnv->SetObjectArrayElement(itemArray.get(), i, |
| folderObj.get()); |
| break; |
| } |
| |
| case BTRC_ITEM_PLAYER: { |
| // Parse name |
| isPlayerListing = true; |
| jint id = (jint)item->player.player_id; |
| jint playerType = (jint)item->player.major_type; |
| jint playStatus = (jint)item->player.play_status; |
| ScopedLocalRef<jbyteArray> featureBitArray( |
| sCallbackEnv.get(), |
| sCallbackEnv->NewByteArray(BTRC_FEATURE_BIT_MASK_SIZE * |
| sizeof(uint8_t))); |
| if (!featureBitArray.get()) { |
| ALOGE("%s failed to allocate featureBitArray", __func__); |
| return; |
| } |
| sCallbackEnv->SetByteArrayRegion( |
| featureBitArray.get(), 0, |
| sizeof(uint8_t) * BTRC_FEATURE_BIT_MASK_SIZE, |
| (jbyte*)item->player.features); |
| ScopedLocalRef<jstring> playerName( |
| sCallbackEnv.get(), |
| sCallbackEnv->NewStringUTF((const char*)item->player.name)); |
| if (!playerName.get()) { |
| ALOGE("%s can't allocate player name string!", __func__); |
| return; |
| } |
| ScopedLocalRef<jobject> playerObj( |
| sCallbackEnv.get(), |
| (jobject)sCallbackEnv->CallObjectMethod( |
| sCallbacksObj, method_createFromNativePlayerItem, id, |
| playerName.get(), featureBitArray.get(), playStatus, |
| playerType)); |
| if (!playerObj.get()) { |
| ALOGE("%s failed to create AvrcpPlayer from ITEM_PLAYER", __func__); |
| return; |
| } |
| sCallbackEnv->SetObjectArrayElement(itemArray.get(), i, |
| playerObj.get()); |
| break; |
| } |
| |
| default: |
| ALOGE("%s cannot understand type %d", __func__, item->item_type); |
| } |
| } |
| |
| if (isPlayerListing) { |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleGetPlayerItemsRsp, |
| addr.get(), itemArray.get()); |
| } else { |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleGetFolderItemsRsp, |
| addr.get(), status, itemArray.get()); |
| } |
| } |
| |
| static void btavrcp_change_path_callback(const RawAddress& bd_addr, |
| uint32_t count) { |
| ALOGI("%s count %d", __func__, count); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleChangeFolderRsp, |
| addr.get(), (jint)count); |
| } |
| |
| static void btavrcp_set_browsed_player_callback(const RawAddress& bd_addr, |
| uint8_t num_items, |
| uint8_t depth) { |
| ALOGI("%s items %d depth %d", __func__, num_items, depth); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, method_handleSetBrowsedPlayerRsp, |
| addr.get(), (jint)num_items, (jint)depth); |
| } |
| |
| static void btavrcp_set_addressed_player_callback(const RawAddress& bd_addr, |
| uint8_t status) { |
| ALOGI("%s status %d", __func__, status); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| |
| sCallbackEnv->CallVoidMethod(sCallbacksObj, |
| method_handleSetAddressedPlayerRsp, addr.get(), |
| (jint)status); |
| } |
| |
| static void btavrcp_addressed_player_changed_callback(const RawAddress& bd_addr, |
| uint16_t id) { |
| ALOGI("%s status %d", __func__, id); |
| std::shared_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| if (!sCallbacksObj) { |
| ALOGE("%s: sCallbacksObj is null", __func__); |
| return; |
| } |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| |
| sCallbackEnv->CallVoidMethod( |
| sCallbacksObj, method_handleAddressedPlayerChanged, addr.get(), (jint)id); |
| } |
| |
| static void btavrcp_now_playing_content_changed_callback( |
| const RawAddress& bd_addr) { |
| ALOGI("%s", __func__); |
| |
| CallbackEnv sCallbackEnv(__func__); |
| if (!sCallbackEnv.valid()) return; |
| ScopedLocalRef<jbyteArray> addr( |
| sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress))); |
| if (!addr.get()) { |
| ALOGE("%s: Failed to allocate a new byte array", __func__); |
| return; |
| } |
| |
| sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress), |
| (jbyte*)&bd_addr.address); |
| |
| sCallbackEnv->CallVoidMethod( |
| sCallbacksObj, method_handleNowPlayingContentChanged, addr.get()); |
| } |
| |
| static btrc_ctrl_callbacks_t sBluetoothAvrcpCallbacks = { |
| sizeof(sBluetoothAvrcpCallbacks), |
| btavrcp_passthrough_response_callback, |
| btavrcp_groupnavigation_response_callback, |
| btavrcp_connection_state_callback, |
| btavrcp_get_rcfeatures_callback, |
| btavrcp_setplayerapplicationsetting_rsp_callback, |
| btavrcp_playerapplicationsetting_callback, |
| btavrcp_playerapplicationsetting_changed_callback, |
| btavrcp_set_abs_vol_cmd_callback, |
| btavrcp_register_notification_absvol_callback, |
| btavrcp_track_changed_callback, |
| btavrcp_play_position_changed_callback, |
| btavrcp_play_status_changed_callback, |
| btavrcp_get_folder_items_callback, |
| btavrcp_change_path_callback, |
| btavrcp_set_browsed_player_callback, |
| btavrcp_set_addressed_player_callback, |
| btavrcp_addressed_player_changed_callback, |
| btavrcp_now_playing_content_changed_callback}; |
| |
| static void classInitNative(JNIEnv* env, jclass clazz) { |
| method_handlePassthroughRsp = |
| env->GetMethodID(clazz, "handlePassthroughRsp", "(II[B)V"); |
| |
| method_handleGroupNavigationRsp = |
| env->GetMethodID(clazz, "handleGroupNavigationRsp", "(II)V"); |
| |
| method_onConnectionStateChanged = |
| env->GetMethodID(clazz, "onConnectionStateChanged", "(ZZ[B)V"); |
| |
| method_getRcFeatures = env->GetMethodID(clazz, "getRcFeatures", "([BI)V"); |
| |
| method_setplayerappsettingrsp = |
| env->GetMethodID(clazz, "setPlayerAppSettingRsp", "([BB)V"); |
| |
| method_handleplayerappsetting = |
| env->GetMethodID(clazz, "handlePlayerAppSetting", "([B[BI)V"); |
| |
| method_handleplayerappsettingchanged = |
| env->GetMethodID(clazz, "onPlayerAppSettingChanged", "([B[BI)V"); |
| |
| method_handleSetAbsVolume = |
| env->GetMethodID(clazz, "handleSetAbsVolume", "([BBB)V"); |
| |
| method_handleRegisterNotificationAbsVol = |
| env->GetMethodID(clazz, "handleRegisterNotificationAbsVol", "([BB)V"); |
| |
| method_handletrackchanged = |
| env->GetMethodID(clazz, "onTrackChanged", "([BB[I[Ljava/lang/String;)V"); |
| |
| method_handleplaypositionchanged = |
| env->GetMethodID(clazz, "onPlayPositionChanged", "([BII)V"); |
| |
| method_handleplaystatuschanged = |
| env->GetMethodID(clazz, "onPlayStatusChanged", "([BB)V"); |
| |
| method_handleGetFolderItemsRsp = |
| env->GetMethodID(clazz, "handleGetFolderItemsRsp", |
| "([BI[Landroid/media/browse/MediaBrowser$MediaItem;)V"); |
| method_handleGetPlayerItemsRsp = env->GetMethodID( |
| clazz, "handleGetPlayerItemsRsp", |
| "([B[Lcom/android/bluetooth/avrcpcontroller/AvrcpPlayer;)V"); |
| |
| method_createFromNativeMediaItem = |
| env->GetMethodID(clazz, "createFromNativeMediaItem", |
| "(JILjava/lang/String;[I[Ljava/lang/String;)Landroid/" |
| "media/browse/MediaBrowser$MediaItem;"); |
| method_createFromNativeFolderItem = env->GetMethodID( |
| clazz, "createFromNativeFolderItem", |
| "(JILjava/lang/String;I)Landroid/media/browse/MediaBrowser$MediaItem;"); |
| method_createFromNativePlayerItem = |
| env->GetMethodID(clazz, "createFromNativePlayerItem", |
| "(ILjava/lang/String;[BII)Lcom/android/bluetooth/" |
| "avrcpcontroller/AvrcpPlayer;"); |
| method_handleChangeFolderRsp = |
| env->GetMethodID(clazz, "handleChangeFolderRsp", "([BI)V"); |
| method_handleSetBrowsedPlayerRsp = |
| env->GetMethodID(clazz, "handleSetBrowsedPlayerRsp", "([BII)V"); |
| method_handleSetAddressedPlayerRsp = |
| env->GetMethodID(clazz, "handleSetAddressedPlayerRsp", "([BI)V"); |
| method_handleAddressedPlayerChanged = |
| env->GetMethodID(clazz, "handleAddressedPlayerChanged", "([BI)V"); |
| method_handleNowPlayingContentChanged = |
| env->GetMethodID(clazz, "handleNowPlayingContentChanged", "([B)V"); |
| |
| ALOGI("%s: succeeds", __func__); |
| } |
| |
| static void initNative(JNIEnv* env, jobject object) { |
| std::unique_lock<std::shared_timed_mutex> lock(sCallbacks_mutex); |
| |
| jclass tmpMediaItem = |
| env->FindClass("android/media/browse/MediaBrowser$MediaItem"); |
| class_MediaBrowser_MediaItem = (jclass)env->NewGlobalRef(tmpMediaItem); |
| |
| jclass tmpBtPlayer = |
| env->FindClass("com/android/bluetooth/avrcpcontroller/AvrcpPlayer"); |
| class_AvrcpPlayer = (jclass)env->NewGlobalRef(tmpBtPlayer); |
| |
| 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 (sCallbacksObj != NULL) { |
| ALOGW("Cleaning up Avrcp callback object"); |
| env->DeleteGlobalRef(sCallbacksObj); |
| sCallbacksObj = NULL; |
| } |
| |
| sBluetoothAvrcpInterface = |
| (btrc_ctrl_interface_t*)btInf->get_profile_interface( |
| BT_PROFILE_AV_RC_CTRL_ID); |
| if (sBluetoothAvrcpInterface == NULL) { |
| ALOGE("Failed to get Bluetooth Avrcp Controller Interface"); |
| return; |
| } |
| |
| bt_status_t status = |
| sBluetoothAvrcpInterface->init(&sBluetoothAvrcpCallbacks); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed to initialize Bluetooth Avrcp Controller, status: %d", |
| status); |
| sBluetoothAvrcpInterface = NULL; |
| return; |
| } |
| |
| sCallbacksObj = env->NewGlobalRef(object); |
| } |
| |
| static void cleanupNative(JNIEnv* env, jobject object) { |
| std::unique_lock<std::shared_timed_mutex> lock(sCallbacks_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 (sCallbacksObj != NULL) { |
| env->DeleteGlobalRef(sCallbacksObj); |
| sCallbacksObj = NULL; |
| } |
| } |
| |
| static jboolean sendPassThroughCommandNative(JNIEnv* env, jobject object, |
| jbyteArray address, jint key_code, |
| jint key_state) { |
| if (!sBluetoothAvrcpInterface) return JNI_FALSE; |
| |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| |
| ALOGI("key_code: %d, key_state: %d", key_code, key_state); |
| |
| 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->send_pass_through_cmd( |
| rawAddress, (uint8_t)key_code, (uint8_t)key_state); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending passthru command, status: %d", status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| |
| return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE; |
| } |
| |
| static jboolean sendGroupNavigationCommandNative(JNIEnv* env, jobject object, |
| jbyteArray address, |
| jint key_code, |
| jint key_state) { |
| if (!sBluetoothAvrcpInterface) return JNI_FALSE; |
| |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| |
| ALOGI("key_code: %d, key_state: %d", key_code, key_state); |
| |
| 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->send_group_navigation_cmd( |
| rawAddress, (uint8_t)key_code, (uint8_t)key_state); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending Grp Navigation command, status: %d", status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| |
| return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE; |
| } |
| |
| static void setPlayerApplicationSettingValuesNative(JNIEnv* env, jobject object, |
| jbyteArray address, |
| jbyte num_attrib, |
| jbyteArray attrib_ids, |
| jbyteArray attrib_val) { |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| if (!sBluetoothAvrcpInterface) return; |
| |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| |
| uint8_t* pAttrs = new uint8_t[num_attrib]; |
| uint8_t* pAttrsVal = new uint8_t[num_attrib]; |
| if ((!pAttrs) || (!pAttrsVal)) { |
| delete[] pAttrs; |
| ALOGE("setPlayerApplicationSettingValuesNative: not have enough memeory"); |
| return; |
| } |
| |
| jbyte* attr = env->GetByteArrayElements(attrib_ids, NULL); |
| jbyte* attr_val = env->GetByteArrayElements(attrib_val, NULL); |
| if ((!attr) || (!attr_val)) { |
| delete[] pAttrs; |
| delete[] pAttrsVal; |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| |
| int i; |
| for (i = 0; i < num_attrib; ++i) { |
| pAttrs[i] = (uint8_t)attr[i]; |
| pAttrsVal[i] = (uint8_t)attr_val[i]; |
| } |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| bt_status_t status = sBluetoothAvrcpInterface->set_player_app_setting_cmd( |
| rawAddress, (uint8_t)num_attrib, pAttrs, pAttrsVal); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending setPlAppSettValNative command, status: %d", status); |
| } |
| delete[] pAttrs; |
| delete[] pAttrsVal; |
| env->ReleaseByteArrayElements(attrib_ids, attr, 0); |
| env->ReleaseByteArrayElements(attrib_val, attr_val, 0); |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void sendAbsVolRspNative(JNIEnv* env, jobject object, jbyteArray address, |
| jint abs_vol, jint label) { |
| if (!sBluetoothAvrcpInterface) return; |
| |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| bt_status_t status = sBluetoothAvrcpInterface->set_volume_rsp( |
| rawAddress, (uint8_t)abs_vol, (uint8_t)label); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending sendAbsVolRspNative command, status: %d", status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void sendRegisterAbsVolRspNative(JNIEnv* env, jobject object, |
| jbyteArray address, jbyte rsp_type, |
| jint abs_vol, jint label) { |
| if (!sBluetoothAvrcpInterface) return; |
| |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| bt_status_t status = sBluetoothAvrcpInterface->register_abs_vol_rsp( |
| rawAddress, (btrc_notification_type_t)rsp_type, (uint8_t)abs_vol, |
| (uint8_t)label); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending sendRegisterAbsVolRspNative command, status: %d", |
| status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void getPlaybackStateNative(JNIEnv* env, jobject object, |
| jbyteArray address) { |
| if (!sBluetoothAvrcpInterface) return; |
| |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| ALOGV("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| bt_status_t status = |
| sBluetoothAvrcpInterface->get_playback_state_cmd(rawAddress); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending getPlaybackStateNative command, status: %d", status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void getNowPlayingListNative(JNIEnv* env, jobject object, |
| jbyteArray address, jint start, jint end) { |
| if (!sBluetoothAvrcpInterface) return; |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| ALOGV("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| bt_status_t status = sBluetoothAvrcpInterface->get_now_playing_list_cmd( |
| rawAddress, start, end); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending getNowPlayingListNative command, status: %d", status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void getFolderListNative(JNIEnv* env, jobject object, jbyteArray address, |
| jint start, jint end) { |
| if (!sBluetoothAvrcpInterface) return; |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| ALOGV("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| bt_status_t status = |
| sBluetoothAvrcpInterface->get_folder_list_cmd(rawAddress, start, end); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending getFolderListNative command, status: %d", status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void getPlayerListNative(JNIEnv* env, jobject object, jbyteArray address, |
| jint start, jint end) { |
| if (!sBluetoothAvrcpInterface) return; |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| bt_status_t status = |
| sBluetoothAvrcpInterface->get_player_list_cmd(rawAddress, start, end); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending getPlayerListNative command, status: %d", status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void changeFolderPathNative(JNIEnv* env, jobject object, |
| jbyteArray address, jbyte direction, |
| jlong uid) { |
| if (!sBluetoothAvrcpInterface) return; |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| |
| // jbyte* uid = env->GetByteArrayElements(uidarr, NULL); |
| // if (!uid) { |
| // jniThrowIOException(env, EINVAL); |
| // return; |
| //} |
| |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| bt_status_t status = sBluetoothAvrcpInterface->change_folder_path_cmd( |
| rawAddress, (uint8_t)direction, (uint8_t*)&uid); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending changeFolderPathNative command, status: %d", status); |
| } |
| // env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void setBrowsedPlayerNative(JNIEnv* env, jobject object, |
| jbyteArray address, jint id) { |
| if (!sBluetoothAvrcpInterface) return; |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| bt_status_t status = sBluetoothAvrcpInterface->set_browsed_player_cmd( |
| rawAddress, (uint16_t)id); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending setBrowsedPlayerNative command, status: %d", status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void setAddressedPlayerNative(JNIEnv* env, jobject object, |
| jbyteArray address, jint id) { |
| if (!sBluetoothAvrcpInterface) return; |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| bt_status_t status = sBluetoothAvrcpInterface->set_addressed_player_cmd( |
| rawAddress, (uint16_t)id); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending setAddressedPlayerNative command, status: %d", |
| status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static void playItemNative(JNIEnv* env, jobject object, jbyteArray address, |
| jbyte scope, jlong uid, jint uidCounter) { |
| if (!sBluetoothAvrcpInterface) return; |
| jbyte* addr = env->GetByteArrayElements(address, NULL); |
| if (!addr) { |
| jniThrowIOException(env, EINVAL); |
| return; |
| } |
| |
| // jbyte* uid = env->GetByteArrayElements(uidArr, NULL); |
| // if (!uid) { |
| // jniThrowIOException(env, EINVAL); |
| // return; |
| // } |
| RawAddress rawAddress; |
| rawAddress.FromOctets((uint8_t*)addr); |
| |
| ALOGI("%s: sBluetoothAvrcpInterface: %p", __func__, sBluetoothAvrcpInterface); |
| bt_status_t status = sBluetoothAvrcpInterface->play_item_cmd( |
| rawAddress, (uint8_t)scope, (uint8_t*)&uid, (uint16_t)uidCounter); |
| if (status != BT_STATUS_SUCCESS) { |
| ALOGE("Failed sending playItemNative command, status: %d", status); |
| } |
| env->ReleaseByteArrayElements(address, addr, 0); |
| } |
| |
| static JNINativeMethod sMethods[] = { |
| {"classInitNative", "()V", (void*)classInitNative}, |
| {"initNative", "()V", (void*)initNative}, |
| {"cleanupNative", "()V", (void*)cleanupNative}, |
| {"sendPassThroughCommandNative", "([BII)Z", |
| (void*)sendPassThroughCommandNative}, |
| {"sendGroupNavigationCommandNative", "([BII)Z", |
| (void*)sendGroupNavigationCommandNative}, |
| {"setPlayerApplicationSettingValuesNative", "([BB[B[B)V", |
| (void*)setPlayerApplicationSettingValuesNative}, |
| {"sendAbsVolRspNative", "([BII)V", (void*)sendAbsVolRspNative}, |
| {"sendRegisterAbsVolRspNative", "([BBII)V", |
| (void*)sendRegisterAbsVolRspNative}, |
| {"getPlaybackStateNative", "([B)V", (void*)getPlaybackStateNative}, |
| {"getNowPlayingListNative", "([BII)V", (void*)getNowPlayingListNative}, |
| {"getFolderListNative", "([BII)V", (void*)getFolderListNative}, |
| {"getPlayerListNative", "([BII)V", (void*)getPlayerListNative}, |
| {"changeFolderPathNative", "([BBJ)V", (void*)changeFolderPathNative}, |
| {"playItemNative", "([BBJI)V", (void*)playItemNative}, |
| {"setBrowsedPlayerNative", "([BI)V", (void*)setBrowsedPlayerNative}, |
| {"setAddressedPlayerNative", "([BI)V", (void*)setAddressedPlayerNative}, |
| }; |
| |
| int register_com_android_bluetooth_avrcp_controller(JNIEnv* env) { |
| return jniRegisterNativeMethods( |
| env, "com/android/bluetooth/avrcpcontroller/AvrcpControllerService", |
| sMethods, NELEM(sMethods)); |
| } |
| } |
