You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
996 lines
38 KiB
996 lines
38 KiB
/*
|
|
* Copyright (C) 2012 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 "BluetoothHeadsetServiceJni"
|
|
|
|
#define LOG_NDEBUG 0
|
|
|
|
#include "com_android_bluetooth.h"
|
|
#include "hardware/bluetooth_headset_callbacks.h"
|
|
#include "hardware/bluetooth_headset_interface.h"
|
|
#include "hardware/bt_hf.h"
|
|
#include "utils/Log.h"
|
|
|
|
#include <mutex>
|
|
#include <shared_mutex>
|
|
|
|
namespace android {
|
|
|
|
static jmethodID method_onConnectionStateChanged;
|
|
static jmethodID method_onAudioStateChanged;
|
|
static jmethodID method_onVrStateChanged;
|
|
static jmethodID method_onAnswerCall;
|
|
static jmethodID method_onHangupCall;
|
|
static jmethodID method_onVolumeChanged;
|
|
static jmethodID method_onDialCall;
|
|
static jmethodID method_onSendDtmf;
|
|
static jmethodID method_onNoiseReductionEnable;
|
|
static jmethodID method_onWBS;
|
|
static jmethodID method_onAtChld;
|
|
static jmethodID method_onAtCnum;
|
|
static jmethodID method_onAtCind;
|
|
static jmethodID method_onAtCops;
|
|
static jmethodID method_onAtClcc;
|
|
static jmethodID method_onUnknownAt;
|
|
static jmethodID method_onKeyPressed;
|
|
static jmethodID method_onAtBind;
|
|
static jmethodID method_onAtBiev;
|
|
static jmethodID method_onAtBia;
|
|
|
|
static bluetooth::headset::Interface* sBluetoothHfpInterface = nullptr;
|
|
static std::shared_timed_mutex interface_mutex;
|
|
|
|
static jobject mCallbacksObj = nullptr;
|
|
static std::shared_timed_mutex callbacks_mutex;
|
|
|
|
static jbyteArray marshall_bda(RawAddress* bd_addr) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return nullptr;
|
|
|
|
jbyteArray addr = sCallbackEnv->NewByteArray(sizeof(RawAddress));
|
|
if (!addr) {
|
|
ALOGE("Fail to new jbyteArray bd addr");
|
|
return nullptr;
|
|
}
|
|
sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(RawAddress),
|
|
(jbyte*)bd_addr);
|
|
return addr;
|
|
}
|
|
|
|
class JniHeadsetCallbacks : bluetooth::headset::Callbacks {
|
|
public:
|
|
static bluetooth::headset::Callbacks* GetInstance() {
|
|
static bluetooth::headset::Callbacks* instance = new JniHeadsetCallbacks();
|
|
return instance;
|
|
}
|
|
|
|
void ConnectionStateCallback(
|
|
bluetooth::headset::bthf_connection_state_t state,
|
|
RawAddress* bd_addr) override {
|
|
ALOGI("%s %d for %s", __func__, state, bd_addr->ToString().c_str());
|
|
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectionStateChanged,
|
|
(jint)state, addr.get());
|
|
}
|
|
|
|
void AudioStateCallback(bluetooth::headset::bthf_audio_state_t state,
|
|
RawAddress* bd_addr) override {
|
|
ALOGI("%s, %d for %s", __func__, state, bd_addr->ToString().c_str());
|
|
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAudioStateChanged,
|
|
(jint)state, addr.get());
|
|
}
|
|
|
|
void VoiceRecognitionCallback(bluetooth::headset::bthf_vr_state_t state,
|
|
RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onVrStateChanged,
|
|
(jint)state, addr.get());
|
|
}
|
|
|
|
void AnswerCallCallback(RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAnswerCall,
|
|
addr.get());
|
|
}
|
|
|
|
void HangupCallCallback(RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onHangupCall,
|
|
addr.get());
|
|
}
|
|
|
|
void VolumeControlCallback(bluetooth::headset::bthf_volume_type_t type,
|
|
int volume, RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onVolumeChanged,
|
|
(jint)type, (jint)volume, addr.get());
|
|
}
|
|
|
|
void DialCallCallback(char* number, RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
char null_str[] = "";
|
|
if (!sCallbackEnv.isValidUtf(number)) {
|
|
android_errorWriteLog(0x534e4554, "109838537");
|
|
ALOGE("%s: number is not a valid UTF string.", __func__);
|
|
number = null_str;
|
|
}
|
|
|
|
ScopedLocalRef<jstring> js_number(sCallbackEnv.get(),
|
|
sCallbackEnv->NewStringUTF(number));
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onDialCall,
|
|
js_number.get(), addr.get());
|
|
}
|
|
|
|
void DtmfCmdCallback(char dtmf, RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
// TBD dtmf has changed from int to char
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onSendDtmf, dtmf,
|
|
addr.get());
|
|
}
|
|
|
|
void NoiseReductionCallback(bluetooth::headset::bthf_nrec_t nrec,
|
|
RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNoiseReductionEnable,
|
|
nrec == bluetooth::headset::BTHF_NREC_START,
|
|
addr.get());
|
|
}
|
|
|
|
void WbsCallback(bluetooth::headset::bthf_wbs_config_t wbs_config,
|
|
RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (addr.get() == nullptr) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onWBS, wbs_config,
|
|
addr.get());
|
|
}
|
|
|
|
void AtChldCallback(bluetooth::headset::bthf_chld_type_t chld,
|
|
RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(
|
|
sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),
|
|
(jbyte*)bd_addr);
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtChld, chld,
|
|
addr.get());
|
|
}
|
|
|
|
void AtCnumCallback(RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtCnum, addr.get());
|
|
}
|
|
|
|
void AtCindCallback(RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtCind, addr.get());
|
|
}
|
|
|
|
void AtCopsCallback(RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtCops, addr.get());
|
|
}
|
|
|
|
void AtClccCallback(RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtClcc, addr.get());
|
|
}
|
|
|
|
void UnknownAtCallback(char* at_string, RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
char null_str[] = "";
|
|
if (!sCallbackEnv.isValidUtf(at_string)) {
|
|
android_errorWriteLog(0x534e4554, "109838537");
|
|
ALOGE("%s: at_string is not a valid UTF string.", __func__);
|
|
at_string = null_str;
|
|
}
|
|
|
|
ScopedLocalRef<jstring> js_at_string(sCallbackEnv.get(),
|
|
sCallbackEnv->NewStringUTF(at_string));
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onUnknownAt,
|
|
js_at_string.get(), addr.get());
|
|
}
|
|
|
|
void KeyPressedCallback(RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) {
|
|
ALOGE("Fail to new jbyteArray bd addr for audio state");
|
|
return;
|
|
}
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onKeyPressed,
|
|
addr.get());
|
|
}
|
|
|
|
void AtBindCallback(char* at_string, RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (addr.get() == nullptr) return;
|
|
|
|
char null_str[] = "";
|
|
if (!sCallbackEnv.isValidUtf(at_string)) {
|
|
android_errorWriteLog(0x534e4554, "109838537");
|
|
ALOGE("%s: at_string is not a valid UTF string.", __func__);
|
|
at_string = null_str;
|
|
}
|
|
|
|
ScopedLocalRef<jstring> js_at_string(sCallbackEnv.get(),
|
|
sCallbackEnv->NewStringUTF(at_string));
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtBind,
|
|
js_at_string.get(), addr.get());
|
|
}
|
|
|
|
void AtBievCallback(bluetooth::headset::bthf_hf_ind_type_t ind_id,
|
|
int ind_value, RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (addr.get() == nullptr) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtBiev, ind_id,
|
|
(jint)ind_value, addr.get());
|
|
}
|
|
|
|
void AtBiaCallback(bool service, bool roam, bool signal, bool battery,
|
|
RawAddress* bd_addr) override {
|
|
std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid() || !mCallbacksObj) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (addr.get() == nullptr) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtBia, service, roam,
|
|
signal, battery, addr.get());
|
|
}
|
|
};
|
|
|
|
static void classInitNative(JNIEnv* env, jclass clazz) {
|
|
method_onConnectionStateChanged =
|
|
env->GetMethodID(clazz, "onConnectionStateChanged", "(I[B)V");
|
|
method_onAudioStateChanged =
|
|
env->GetMethodID(clazz, "onAudioStateChanged", "(I[B)V");
|
|
method_onVrStateChanged =
|
|
env->GetMethodID(clazz, "onVrStateChanged", "(I[B)V");
|
|
method_onAnswerCall = env->GetMethodID(clazz, "onAnswerCall", "([B)V");
|
|
method_onHangupCall = env->GetMethodID(clazz, "onHangupCall", "([B)V");
|
|
method_onVolumeChanged =
|
|
env->GetMethodID(clazz, "onVolumeChanged", "(II[B)V");
|
|
method_onDialCall =
|
|
env->GetMethodID(clazz, "onDialCall", "(Ljava/lang/String;[B)V");
|
|
method_onSendDtmf = env->GetMethodID(clazz, "onSendDtmf", "(I[B)V");
|
|
method_onNoiseReductionEnable =
|
|
env->GetMethodID(clazz, "onNoiseReductionEnable", "(Z[B)V");
|
|
method_onWBS = env->GetMethodID(clazz, "onWBS", "(I[B)V");
|
|
method_onAtChld = env->GetMethodID(clazz, "onAtChld", "(I[B)V");
|
|
method_onAtCnum = env->GetMethodID(clazz, "onAtCnum", "([B)V");
|
|
method_onAtCind = env->GetMethodID(clazz, "onAtCind", "([B)V");
|
|
method_onAtCops = env->GetMethodID(clazz, "onAtCops", "([B)V");
|
|
method_onAtClcc = env->GetMethodID(clazz, "onAtClcc", "([B)V");
|
|
method_onUnknownAt =
|
|
env->GetMethodID(clazz, "onUnknownAt", "(Ljava/lang/String;[B)V");
|
|
method_onKeyPressed = env->GetMethodID(clazz, "onKeyPressed", "([B)V");
|
|
method_onAtBind =
|
|
env->GetMethodID(clazz, "onATBind", "(Ljava/lang/String;[B)V");
|
|
method_onAtBiev = env->GetMethodID(clazz, "onATBiev", "(II[B)V");
|
|
method_onAtBia = env->GetMethodID(clazz, "onAtBia", "(ZZZZ[B)V");
|
|
|
|
ALOGI("%s: succeeds", __func__);
|
|
}
|
|
|
|
static void initializeNative(JNIEnv* env, jobject object, jint max_hf_clients,
|
|
jboolean inband_ringing_enabled) {
|
|
std::unique_lock<std::shared_timed_mutex> interface_lock(interface_mutex);
|
|
std::unique_lock<std::shared_timed_mutex> callbacks_lock(callbacks_mutex);
|
|
|
|
const bt_interface_t* btInf = getBluetoothInterface();
|
|
if (!btInf) {
|
|
ALOGE("%s: Bluetooth module is not loaded", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return;
|
|
}
|
|
|
|
if (sBluetoothHfpInterface) {
|
|
ALOGI("%s: Cleaning up Bluetooth Handsfree Interface before initializing",
|
|
__func__);
|
|
sBluetoothHfpInterface->Cleanup();
|
|
sBluetoothHfpInterface = nullptr;
|
|
}
|
|
|
|
if (mCallbacksObj) {
|
|
ALOGI("%s: Cleaning up Bluetooth Handsfree callback object", __func__);
|
|
env->DeleteGlobalRef(mCallbacksObj);
|
|
mCallbacksObj = nullptr;
|
|
}
|
|
|
|
sBluetoothHfpInterface =
|
|
(bluetooth::headset::Interface*)btInf->get_profile_interface(
|
|
BT_PROFILE_HANDSFREE_ID);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: Failed to get Bluetooth Handsfree Interface", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return;
|
|
}
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->Init(JniHeadsetCallbacks::GetInstance(),
|
|
max_hf_clients, inband_ringing_enabled);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("%s: Failed to initialize Bluetooth Handsfree Interface, status: %d",
|
|
__func__, status);
|
|
sBluetoothHfpInterface = nullptr;
|
|
return;
|
|
}
|
|
|
|
mCallbacksObj = env->NewGlobalRef(object);
|
|
}
|
|
|
|
static void cleanupNative(JNIEnv* env, jobject object) {
|
|
std::unique_lock<std::shared_timed_mutex> interface_lock(interface_mutex);
|
|
std::unique_lock<std::shared_timed_mutex> callbacks_lock(callbacks_mutex);
|
|
|
|
const bt_interface_t* btInf = getBluetoothInterface();
|
|
if (!btInf) {
|
|
ALOGW("%s: Bluetooth module is not loaded", __func__);
|
|
return;
|
|
}
|
|
|
|
if (sBluetoothHfpInterface) {
|
|
ALOGI("%s: Cleaning up Bluetooth Handsfree Interface", __func__);
|
|
sBluetoothHfpInterface->Cleanup();
|
|
sBluetoothHfpInterface = nullptr;
|
|
}
|
|
|
|
if (mCallbacksObj) {
|
|
ALOGI("%s: Cleaning up Bluetooth Handsfree callback object", __func__);
|
|
env->DeleteGlobalRef(mCallbacksObj);
|
|
mCallbacksObj = nullptr;
|
|
}
|
|
}
|
|
|
|
static jboolean connectHfpNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
ALOGI("%s: device %s", __func__, ((RawAddress*)addr)->ToString().c_str());
|
|
bt_status_t status = sBluetoothHfpInterface->Connect((RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed HF connection, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean disconnectHfpNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
ALOGI("%s: device %s", __func__, ((RawAddress*)addr)->ToString().c_str());
|
|
bt_status_t status = sBluetoothHfpInterface->Disconnect((RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed HF disconnection, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean connectAudioNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
ALOGI("%s: device %s", __func__, ((RawAddress*)addr)->ToString().c_str());
|
|
bt_status_t status = sBluetoothHfpInterface->ConnectAudio((RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed HF audio connection, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean disconnectAudioNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
ALOGI("%s: device %s", __func__, ((RawAddress*)addr)->ToString().c_str());
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->DisconnectAudio((RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed HF audio disconnection, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean isNoiseReductionSupportedNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->isNoiseReductionSupported((RawAddress*)addr);
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean isVoiceRecognitionSupportedNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->isVoiceRecognitionSupported((RawAddress*)addr);
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean startVoiceRecognitionNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->StartVoiceRecognition((RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to start voice recognition, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean stopVoiceRecognitionNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->StopVoiceRecognition((RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to stop voice recognition, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean setVolumeNative(JNIEnv* env, jobject object, jint volume_type,
|
|
jint volume, jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status = sBluetoothHfpInterface->VolumeControl(
|
|
(bluetooth::headset::bthf_volume_type_t)volume_type, volume,
|
|
(RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("FAILED to control volume, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean notifyDeviceStatusNative(JNIEnv* env, jobject object,
|
|
jint network_state, jint service_type,
|
|
jint signal, jint battery_charge,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status = sBluetoothHfpInterface->DeviceStatusNotification(
|
|
(bluetooth::headset::bthf_network_state_t)network_state,
|
|
(bluetooth::headset::bthf_service_type_t)service_type, signal,
|
|
battery_charge, (RawAddress*)addr);
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("FAILED to notify device status, status: %d", status);
|
|
}
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean copsResponseNative(JNIEnv* env, jobject object,
|
|
jstring operator_str, jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
const char* operator_name = env->GetStringUTFChars(operator_str, nullptr);
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->CopsResponse(operator_name, (RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed sending cops response, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
env->ReleaseStringUTFChars(operator_str, operator_name);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean cindResponseNative(JNIEnv* env, jobject object, jint service,
|
|
jint num_active, jint num_held,
|
|
jint call_state, jint signal, jint roam,
|
|
jint battery_charge, jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status = sBluetoothHfpInterface->CindResponse(
|
|
service, num_active, num_held,
|
|
(bluetooth::headset::bthf_call_state_t)call_state, signal, roam,
|
|
battery_charge, (RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("%s: failed, status: %d", __func__, status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean atResponseStringNative(JNIEnv* env, jobject object,
|
|
jstring response_str,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
const char* response = env->GetStringUTFChars(response_str, nullptr);
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->FormattedAtResponse(response, (RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed formatted AT response, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
env->ReleaseStringUTFChars(response_str, response);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean atResponseCodeNative(JNIEnv* env, jobject object,
|
|
jint response_code, jint cmee_code,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status = sBluetoothHfpInterface->AtResponse(
|
|
(bluetooth::headset::bthf_at_response_t)response_code, cmee_code,
|
|
(RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed AT response, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean clccResponseNative(JNIEnv* env, jobject object, jint index,
|
|
jint dir, jint callStatus, jint mode,
|
|
jboolean mpty, jstring number_str, jint type,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
const char* number = nullptr;
|
|
if (number_str) {
|
|
number = env->GetStringUTFChars(number_str, nullptr);
|
|
}
|
|
bt_status_t status = sBluetoothHfpInterface->ClccResponse(
|
|
index, (bluetooth::headset::bthf_call_direction_t)dir,
|
|
(bluetooth::headset::bthf_call_state_t)callStatus,
|
|
(bluetooth::headset::bthf_call_mode_t)mode,
|
|
mpty ? bluetooth::headset::BTHF_CALL_MPTY_TYPE_MULTI
|
|
: bluetooth::headset::BTHF_CALL_MPTY_TYPE_SINGLE,
|
|
number, (bluetooth::headset::bthf_call_addrtype_t)type,
|
|
(RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed sending CLCC response, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
if (number) {
|
|
env->ReleaseStringUTFChars(number_str, number);
|
|
}
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean phoneStateChangeNative(JNIEnv* env, jobject object,
|
|
jint num_active, jint num_held,
|
|
jint call_state, jstring number_str,
|
|
jint type, jstring name_str,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, nullptr);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
const char* number = env->GetStringUTFChars(number_str, nullptr);
|
|
const char* name = nullptr;
|
|
if (name_str != nullptr) {
|
|
name = env->GetStringUTFChars(name_str, nullptr);
|
|
}
|
|
bt_status_t status = sBluetoothHfpInterface->PhoneStateChange(
|
|
num_active, num_held, (bluetooth::headset::bthf_call_state_t)call_state,
|
|
number, (bluetooth::headset::bthf_call_addrtype_t)type, name,
|
|
(RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed report phone state change, status: %d", status);
|
|
}
|
|
env->ReleaseStringUTFChars(number_str, number);
|
|
if (name != nullptr) {
|
|
env->ReleaseStringUTFChars(name_str, name);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean setScoAllowedNative(JNIEnv* env, jobject object,
|
|
jboolean value) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status = sBluetoothHfpInterface->SetScoAllowed(value == JNI_TRUE);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed HF set sco allowed, status: %d", status);
|
|
}
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean sendBsirNative(JNIEnv* env, jobject object, jboolean value,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->SendBsir(value == JNI_TRUE, (RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed sending BSIR, value=%d, status=%d", value, status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean setActiveDeviceNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);
|
|
if (!sBluetoothHfpInterface) {
|
|
ALOGW("%s: sBluetoothHfpInterface is null", __func__);
|
|
return JNI_FALSE;
|
|
}
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
ALOGE("%s: failed to get device address", __func__);
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
bt_status_t status =
|
|
sBluetoothHfpInterface->SetActiveDevice((RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to set active device, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static JNINativeMethod sMethods[] = {
|
|
{"classInitNative", "()V", (void*)classInitNative},
|
|
{"initializeNative", "(IZ)V", (void*)initializeNative},
|
|
{"cleanupNative", "()V", (void*)cleanupNative},
|
|
{"connectHfpNative", "([B)Z", (void*)connectHfpNative},
|
|
{"disconnectHfpNative", "([B)Z", (void*)disconnectHfpNative},
|
|
{"connectAudioNative", "([B)Z", (void*)connectAudioNative},
|
|
{"disconnectAudioNative", "([B)Z", (void*)disconnectAudioNative},
|
|
{"isNoiseReductionSupportedNative", "([B)Z",
|
|
(void*)isNoiseReductionSupportedNative},
|
|
{"isVoiceRecognitionSupportedNative", "([B)Z",
|
|
(void*)isVoiceRecognitionSupportedNative},
|
|
{"startVoiceRecognitionNative", "([B)Z",
|
|
(void*)startVoiceRecognitionNative},
|
|
{"stopVoiceRecognitionNative", "([B)Z", (void*)stopVoiceRecognitionNative},
|
|
{"setVolumeNative", "(II[B)Z", (void*)setVolumeNative},
|
|
{"notifyDeviceStatusNative", "(IIII[B)Z", (void*)notifyDeviceStatusNative},
|
|
{"copsResponseNative", "(Ljava/lang/String;[B)Z",
|
|
(void*)copsResponseNative},
|
|
{"cindResponseNative", "(IIIIIII[B)Z", (void*)cindResponseNative},
|
|
{"atResponseStringNative", "(Ljava/lang/String;[B)Z",
|
|
(void*)atResponseStringNative},
|
|
{"atResponseCodeNative", "(II[B)Z", (void*)atResponseCodeNative},
|
|
{"clccResponseNative", "(IIIIZLjava/lang/String;I[B)Z",
|
|
(void*)clccResponseNative},
|
|
{"phoneStateChangeNative", "(IIILjava/lang/String;ILjava/lang/String;[B)Z",
|
|
(void*)phoneStateChangeNative},
|
|
{"setScoAllowedNative", "(Z)Z", (void*)setScoAllowedNative},
|
|
{"sendBsirNative", "(Z[B)Z", (void*)sendBsirNative},
|
|
{"setActiveDeviceNative", "([B)Z", (void*)setActiveDeviceNative},
|
|
};
|
|
|
|
int register_com_android_bluetooth_hfp(JNIEnv* env) {
|
|
return jniRegisterNativeMethods(
|
|
env, "com/android/bluetooth/hfp/HeadsetNativeInterface", sMethods,
|
|
NELEM(sMethods));
|
|
}
|
|
|
|
} /* namespace android */
|