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.
872 lines
31 KiB
872 lines
31 KiB
/*
|
|
* Copyright (c) 2014 The Android Open Source Project
|
|
* 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 "BluetoothHeadsetClientServiceJni"
|
|
#define LOG_NDEBUG 0
|
|
|
|
#include "com_android_bluetooth.h"
|
|
#include "hardware/bt_hf_client.h"
|
|
#include "utils/Log.h"
|
|
|
|
namespace android {
|
|
|
|
static bthf_client_interface_t* sBluetoothHfpClientInterface = NULL;
|
|
static jobject mCallbacksObj = NULL;
|
|
|
|
static jmethodID method_onConnectionStateChanged;
|
|
static jmethodID method_onAudioStateChanged;
|
|
static jmethodID method_onVrStateChanged;
|
|
static jmethodID method_onNetworkState;
|
|
static jmethodID method_onNetworkRoaming;
|
|
static jmethodID method_onNetworkSignal;
|
|
static jmethodID method_onBatteryLevel;
|
|
static jmethodID method_onCurrentOperator;
|
|
static jmethodID method_onCall;
|
|
static jmethodID method_onCallSetup;
|
|
static jmethodID method_onCallHeld;
|
|
static jmethodID method_onRespAndHold;
|
|
static jmethodID method_onClip;
|
|
static jmethodID method_onCallWaiting;
|
|
static jmethodID method_onCurrentCalls;
|
|
static jmethodID method_onVolumeChange;
|
|
static jmethodID method_onCmdResult;
|
|
static jmethodID method_onSubscriberInfo;
|
|
static jmethodID method_onInBandRing;
|
|
static jmethodID method_onLastVoiceTagNumber;
|
|
static jmethodID method_onRingIndication;
|
|
static jmethodID method_onUnknownEvent;
|
|
|
|
static jbyteArray marshall_bda(const RawAddress* bd_addr) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return NULL;
|
|
|
|
jbyteArray addr = sCallbackEnv->NewByteArray(sizeof(RawAddress));
|
|
if (!addr) {
|
|
ALOGE("Fail to new jbyteArray bd addr");
|
|
return NULL;
|
|
}
|
|
sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(RawAddress),
|
|
(jbyte*)bd_addr);
|
|
return addr;
|
|
}
|
|
|
|
static void connection_state_cb(const RawAddress* bd_addr,
|
|
bthf_client_connection_state_t state,
|
|
unsigned int peer_feat,
|
|
unsigned int chld_feat) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
ALOGD("%s: state %d peer_feat %d chld_feat %d", __func__, state, peer_feat, chld_feat);
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectionStateChanged,
|
|
(jint)state, (jint)peer_feat, (jint)chld_feat,
|
|
addr.get());
|
|
}
|
|
|
|
static void audio_state_cb(const RawAddress* bd_addr,
|
|
bthf_client_audio_state_t state) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAudioStateChanged,
|
|
(jint)state, addr.get());
|
|
}
|
|
|
|
static void vr_cmd_cb(const RawAddress* bd_addr, bthf_client_vr_state_t state) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onVrStateChanged,
|
|
(jint)state, addr.get());
|
|
}
|
|
|
|
static void network_state_cb(const RawAddress* bd_addr,
|
|
bthf_client_network_state_t state) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNetworkState,
|
|
(jint)state, addr.get());
|
|
}
|
|
|
|
static void network_roaming_cb(const RawAddress* bd_addr,
|
|
bthf_client_service_type_t type) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNetworkRoaming,
|
|
(jint)type, addr.get());
|
|
}
|
|
|
|
static void network_signal_cb(const RawAddress* bd_addr, int signal) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNetworkSignal,
|
|
(jint)signal, addr.get());
|
|
}
|
|
|
|
static void battery_level_cb(const RawAddress* bd_addr, int level) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onBatteryLevel,
|
|
(jint)level, addr.get());
|
|
}
|
|
|
|
static void current_operator_cb(const RawAddress* bd_addr, const char* name) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
const char null_str[] = "";
|
|
if (!sCallbackEnv.isValidUtf(name)) {
|
|
android_errorWriteLog(0x534e4554, "109838537");
|
|
ALOGE("%s: name is not a valid UTF string.", __func__);
|
|
name = null_str;
|
|
}
|
|
|
|
ScopedLocalRef<jstring> js_name(sCallbackEnv.get(),
|
|
sCallbackEnv->NewStringUTF(name));
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onCurrentOperator,
|
|
js_name.get(), addr.get());
|
|
}
|
|
|
|
static void call_cb(const RawAddress* bd_addr, bthf_client_call_t call) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onCall, (jint)call,
|
|
addr.get());
|
|
}
|
|
|
|
static void callsetup_cb(const RawAddress* bd_addr,
|
|
bthf_client_callsetup_t callsetup) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
ALOGD("callsetup_cb bdaddr %02x:%02x:%02x:%02x:%02x:%02x",
|
|
bd_addr->address[0], bd_addr->address[1], bd_addr->address[2],
|
|
bd_addr->address[3], bd_addr->address[4], bd_addr->address[5]);
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onCallSetup,
|
|
(jint)callsetup, addr.get());
|
|
}
|
|
|
|
static void callheld_cb(const RawAddress* bd_addr,
|
|
bthf_client_callheld_t callheld) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onCallHeld, (jint)callheld,
|
|
addr.get());
|
|
}
|
|
|
|
static void resp_and_hold_cb(const RawAddress* bd_addr,
|
|
bthf_client_resp_and_hold_t resp_and_hold) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onRespAndHold,
|
|
(jint)resp_and_hold, addr.get());
|
|
}
|
|
|
|
static void clip_cb(const RawAddress* bd_addr, const char* number) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
const 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_onClip, js_number.get(),
|
|
addr.get());
|
|
}
|
|
|
|
static void call_waiting_cb(const RawAddress* bd_addr, const char* number) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
const 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_onCallWaiting,
|
|
js_number.get(), addr.get());
|
|
}
|
|
|
|
static void current_calls_cb(const RawAddress* bd_addr, int index,
|
|
bthf_client_call_direction_t dir,
|
|
bthf_client_call_state_t state,
|
|
bthf_client_call_mpty_type_t mpty,
|
|
const char* number) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
const 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_onCurrentCalls, index, dir,
|
|
state, mpty, js_number.get(), addr.get());
|
|
}
|
|
|
|
static void volume_change_cb(const RawAddress* bd_addr,
|
|
bthf_client_volume_type_t type, int volume) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onVolumeChange, (jint)type,
|
|
(jint)volume, addr.get());
|
|
}
|
|
|
|
static void cmd_complete_cb(const RawAddress* bd_addr,
|
|
bthf_client_cmd_complete_t type, int cme) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onCmdResult, (jint)type,
|
|
(jint)cme, addr.get());
|
|
}
|
|
|
|
static void subscriber_info_cb(const RawAddress* bd_addr, const char* name,
|
|
bthf_client_subscriber_service_type_t type) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
const char null_str[] = "";
|
|
if (!sCallbackEnv.isValidUtf(name)) {
|
|
android_errorWriteLog(0x534e4554, "109838537");
|
|
ALOGE("%s: name is not a valid UTF string.", __func__);
|
|
name = null_str;
|
|
}
|
|
|
|
ScopedLocalRef<jstring> js_name(sCallbackEnv.get(),
|
|
sCallbackEnv->NewStringUTF(name));
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onSubscriberInfo,
|
|
js_name.get(), (jint)type, addr.get());
|
|
}
|
|
|
|
static void in_band_ring_cb(const RawAddress* bd_addr,
|
|
bthf_client_in_band_ring_state_t in_band) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onInBandRing,
|
|
(jint)in_band, addr.get());
|
|
}
|
|
|
|
static void last_voice_tag_number_cb(const RawAddress* bd_addr,
|
|
const char* number) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
const 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_onLastVoiceTagNumber,
|
|
js_number.get(), addr.get());
|
|
}
|
|
|
|
static void ring_indication_cb(const RawAddress* bd_addr) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onRingIndication,
|
|
addr.get());
|
|
}
|
|
|
|
static void unknown_event_cb(const RawAddress* bd_addr,
|
|
const char* eventString) {
|
|
CallbackEnv sCallbackEnv(__func__);
|
|
if (!sCallbackEnv.valid()) return;
|
|
|
|
ScopedLocalRef<jbyteArray> addr(sCallbackEnv.get(), marshall_bda(bd_addr));
|
|
if (!addr.get()) return;
|
|
|
|
ScopedLocalRef<jstring> js_event(sCallbackEnv.get(),
|
|
sCallbackEnv->NewStringUTF(eventString));
|
|
sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onUnknownEvent,
|
|
js_event.get(), addr.get());
|
|
}
|
|
|
|
static bthf_client_callbacks_t sBluetoothHfpClientCallbacks = {
|
|
sizeof(sBluetoothHfpClientCallbacks),
|
|
connection_state_cb,
|
|
audio_state_cb,
|
|
vr_cmd_cb,
|
|
network_state_cb,
|
|
network_roaming_cb,
|
|
network_signal_cb,
|
|
battery_level_cb,
|
|
current_operator_cb,
|
|
call_cb,
|
|
callsetup_cb,
|
|
callheld_cb,
|
|
resp_and_hold_cb,
|
|
clip_cb,
|
|
call_waiting_cb,
|
|
current_calls_cb,
|
|
volume_change_cb,
|
|
cmd_complete_cb,
|
|
subscriber_info_cb,
|
|
in_band_ring_cb,
|
|
last_voice_tag_number_cb,
|
|
ring_indication_cb,
|
|
unknown_event_cb,
|
|
};
|
|
|
|
static void classInitNative(JNIEnv* env, jclass clazz) {
|
|
method_onConnectionStateChanged =
|
|
env->GetMethodID(clazz, "onConnectionStateChanged", "(III[B)V");
|
|
method_onAudioStateChanged =
|
|
env->GetMethodID(clazz, "onAudioStateChanged", "(I[B)V");
|
|
method_onVrStateChanged =
|
|
env->GetMethodID(clazz, "onVrStateChanged", "(I[B)V");
|
|
method_onNetworkState = env->GetMethodID(clazz, "onNetworkState", "(I[B)V");
|
|
method_onNetworkRoaming = env->GetMethodID(clazz, "onNetworkRoaming", "(I[B)V");
|
|
method_onNetworkSignal = env->GetMethodID(clazz, "onNetworkSignal", "(I[B)V");
|
|
method_onBatteryLevel = env->GetMethodID(clazz, "onBatteryLevel", "(I[B)V");
|
|
method_onCurrentOperator =
|
|
env->GetMethodID(clazz, "onCurrentOperator", "(Ljava/lang/String;[B)V");
|
|
method_onCall = env->GetMethodID(clazz, "onCall", "(I[B)V");
|
|
method_onCallSetup = env->GetMethodID(clazz, "onCallSetup", "(I[B)V");
|
|
method_onCallHeld = env->GetMethodID(clazz, "onCallHeld", "(I[B)V");
|
|
method_onRespAndHold = env->GetMethodID(clazz, "onRespAndHold", "(I[B)V");
|
|
method_onClip = env->GetMethodID(clazz, "onClip", "(Ljava/lang/String;[B)V");
|
|
method_onCallWaiting =
|
|
env->GetMethodID(clazz, "onCallWaiting", "(Ljava/lang/String;[B)V");
|
|
method_onCurrentCalls =
|
|
env->GetMethodID(clazz, "onCurrentCalls", "(IIIILjava/lang/String;[B)V");
|
|
method_onVolumeChange = env->GetMethodID(clazz, "onVolumeChange", "(II[B)V");
|
|
method_onCmdResult = env->GetMethodID(clazz, "onCmdResult", "(II[B)V");
|
|
method_onSubscriberInfo =
|
|
env->GetMethodID(clazz, "onSubscriberInfo", "(Ljava/lang/String;I[B)V");
|
|
method_onInBandRing = env->GetMethodID(clazz, "onInBandRing", "(I[B)V");
|
|
method_onLastVoiceTagNumber =
|
|
env->GetMethodID(clazz, "onLastVoiceTagNumber", "(Ljava/lang/String;[B)V");
|
|
method_onRingIndication = env->GetMethodID(clazz, "onRingIndication", "([B)V");
|
|
method_onUnknownEvent =
|
|
env->GetMethodID(clazz, "onUnknownEvent", "(Ljava/lang/String;[B)V");
|
|
|
|
ALOGI("%s succeeds", __func__);
|
|
}
|
|
|
|
static void initializeNative(JNIEnv* env, jobject object) {
|
|
ALOGD("%s: HfpClient", __func__);
|
|
const bt_interface_t* btInf = getBluetoothInterface();
|
|
if (btInf == NULL) {
|
|
ALOGE("Bluetooth module is not loaded");
|
|
return;
|
|
}
|
|
|
|
if (sBluetoothHfpClientInterface != NULL) {
|
|
ALOGW("Cleaning up Bluetooth HFP Client Interface before initializing");
|
|
sBluetoothHfpClientInterface->cleanup();
|
|
sBluetoothHfpClientInterface = NULL;
|
|
}
|
|
|
|
if (mCallbacksObj != NULL) {
|
|
ALOGW("Cleaning up Bluetooth HFP Client callback object");
|
|
env->DeleteGlobalRef(mCallbacksObj);
|
|
mCallbacksObj = NULL;
|
|
}
|
|
|
|
sBluetoothHfpClientInterface =
|
|
(bthf_client_interface_t*)btInf->get_profile_interface(
|
|
BT_PROFILE_HANDSFREE_CLIENT_ID);
|
|
if (sBluetoothHfpClientInterface == NULL) {
|
|
ALOGE("Failed to get Bluetooth HFP Client Interface");
|
|
return;
|
|
}
|
|
|
|
bt_status_t status =
|
|
sBluetoothHfpClientInterface->init(&sBluetoothHfpClientCallbacks);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to initialize Bluetooth HFP Client, status: %d", status);
|
|
sBluetoothHfpClientInterface = NULL;
|
|
return;
|
|
}
|
|
|
|
mCallbacksObj = env->NewGlobalRef(object);
|
|
}
|
|
|
|
static void cleanupNative(JNIEnv* env, jobject object) {
|
|
const bt_interface_t* btInf = getBluetoothInterface();
|
|
if (btInf == NULL) {
|
|
ALOGE("Bluetooth module is not loaded");
|
|
return;
|
|
}
|
|
|
|
if (sBluetoothHfpClientInterface != NULL) {
|
|
ALOGW("Cleaning up Bluetooth HFP Client Interface...");
|
|
sBluetoothHfpClientInterface->cleanup();
|
|
sBluetoothHfpClientInterface = NULL;
|
|
}
|
|
|
|
if (mCallbacksObj != NULL) {
|
|
ALOGW("Cleaning up Bluetooth HFP Client callback object");
|
|
env->DeleteGlobalRef(mCallbacksObj);
|
|
mCallbacksObj = NULL;
|
|
}
|
|
}
|
|
|
|
static jboolean connectNative(JNIEnv* env, jobject object, jbyteArray address) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->connect((RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed AG connection, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean disconnectNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status =
|
|
sBluetoothHfpClientInterface->disconnect((const RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed AG 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) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status =
|
|
sBluetoothHfpClientInterface->connect_audio((const RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed AG 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) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status =
|
|
sBluetoothHfpClientInterface->disconnect_audio((const RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed AG audio disconnection, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean startVoiceRecognitionNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->start_voice_recognition(
|
|
(const 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) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->stop_voice_recognition(
|
|
(const 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, jbyteArray address,
|
|
jint volume_type, jint volume) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->volume_control(
|
|
(const RawAddress*)addr, (bthf_client_volume_type_t)volume_type, volume);
|
|
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 dialNative(JNIEnv* env, jobject object, jbyteArray address,
|
|
jstring number_str) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
const char* number = nullptr;
|
|
if (number_str != nullptr) {
|
|
number = env->GetStringUTFChars(number_str, nullptr);
|
|
}
|
|
bt_status_t status =
|
|
sBluetoothHfpClientInterface->dial((const RawAddress*)addr,
|
|
number == nullptr ? "" : number);
|
|
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to dial, status: %d", status);
|
|
}
|
|
if (number != nullptr) {
|
|
env->ReleaseStringUTFChars(number_str, number);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean dialMemoryNative(JNIEnv* env, jobject object,
|
|
jbyteArray address, jint location) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->dial_memory(
|
|
(const RawAddress*)addr, (int)location);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to dial from memory, status: %d", status);
|
|
}
|
|
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean handleCallActionNative(JNIEnv* env, jobject object,
|
|
jbyteArray address, jint action,
|
|
jint index) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->handle_call_action(
|
|
(const RawAddress*)addr, (bthf_client_call_action_t)action, (int)index);
|
|
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to enter private mode, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean queryCurrentCallsNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->query_current_calls(
|
|
(const RawAddress*)addr);
|
|
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to query current calls, status: %d", status);
|
|
}
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean queryCurrentOperatorNameNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status =
|
|
sBluetoothHfpClientInterface->query_current_operator_name(
|
|
(const RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to query current operator name, status: %d", status);
|
|
}
|
|
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean retrieveSubscriberInfoNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->retrieve_subscriber_info(
|
|
(const RawAddress*)addr);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to retrieve subscriber info, status: %d", status);
|
|
}
|
|
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean sendDtmfNative(JNIEnv* env, jobject object, jbyteArray address,
|
|
jbyte code) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->send_dtmf(
|
|
(const RawAddress*)addr, (char)code);
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to send DTMF, status: %d", status);
|
|
}
|
|
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean requestLastVoiceTagNumberNative(JNIEnv* env, jobject object,
|
|
jbyteArray address) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
bt_status_t status =
|
|
sBluetoothHfpClientInterface->request_last_voice_tag_number(
|
|
(const RawAddress*)addr);
|
|
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to request last Voice Tag number, status: %d", status);
|
|
}
|
|
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static jboolean sendATCmdNative(JNIEnv* env, jobject object, jbyteArray address,
|
|
jint cmd, jint val1, jint val2,
|
|
jstring arg_str) {
|
|
if (!sBluetoothHfpClientInterface) return JNI_FALSE;
|
|
|
|
jbyte* addr = env->GetByteArrayElements(address, NULL);
|
|
if (!addr) {
|
|
jniThrowIOException(env, EINVAL);
|
|
return JNI_FALSE;
|
|
}
|
|
const char* arg = NULL;
|
|
if (arg_str != NULL) {
|
|
arg = env->GetStringUTFChars(arg_str, NULL);
|
|
}
|
|
|
|
bt_status_t status = sBluetoothHfpClientInterface->send_at_cmd(
|
|
(const RawAddress*)addr, cmd, val1, val2, arg);
|
|
|
|
if (status != BT_STATUS_SUCCESS) {
|
|
ALOGE("Failed to send cmd, status: %d", status);
|
|
}
|
|
|
|
if (arg != NULL) {
|
|
env->ReleaseStringUTFChars(arg_str, arg);
|
|
}
|
|
|
|
env->ReleaseByteArrayElements(address, addr, 0);
|
|
return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
|
|
}
|
|
|
|
static JNINativeMethod sMethods[] = {
|
|
{"classInitNative", "()V", (void*)classInitNative},
|
|
{"initializeNative", "()V", (void*)initializeNative},
|
|
{"cleanupNative", "()V", (void*)cleanupNative},
|
|
{"connectNative", "([B)Z", (void*)connectNative},
|
|
{"disconnectNative", "([B)Z", (void*)disconnectNative},
|
|
{"connectAudioNative", "([B)Z", (void*)connectAudioNative},
|
|
{"disconnectAudioNative", "([B)Z", (void*)disconnectAudioNative},
|
|
{"startVoiceRecognitionNative", "([B)Z",
|
|
(void*)startVoiceRecognitionNative},
|
|
{"stopVoiceRecognitionNative", "([B)Z", (void*)stopVoiceRecognitionNative},
|
|
{"setVolumeNative", "([BII)Z", (void*)setVolumeNative},
|
|
{"dialNative", "([BLjava/lang/String;)Z", (void*)dialNative},
|
|
{"dialMemoryNative", "([BI)Z", (void*)dialMemoryNative},
|
|
{"handleCallActionNative", "([BII)Z", (void*)handleCallActionNative},
|
|
{"queryCurrentCallsNative", "([B)Z", (void*)queryCurrentCallsNative},
|
|
{"queryCurrentOperatorNameNative", "([B)Z",
|
|
(void*)queryCurrentOperatorNameNative},
|
|
{"retrieveSubscriberInfoNative", "([B)Z",
|
|
(void*)retrieveSubscriberInfoNative},
|
|
{"sendDtmfNative", "([BB)Z", (void*)sendDtmfNative},
|
|
{"requestLastVoiceTagNumberNative", "([B)Z",
|
|
(void*)requestLastVoiceTagNumberNative},
|
|
{"sendATCmdNative", "([BIIILjava/lang/String;)Z", (void*)sendATCmdNative},
|
|
};
|
|
|
|
int register_com_android_bluetooth_hfpclient(JNIEnv* env) {
|
|
return jniRegisterNativeMethods(
|
|
env, "com/android/bluetooth/hfpclient/NativeInterface",
|
|
sMethods, NELEM(sMethods));
|
|
}
|
|
|
|
} /* namespace android */
|