Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 16a57925 authored by Hemant Gupta's avatar Hemant Gupta
Browse files

Submitted on behalf of 3rd party copied from 

packages/apps/Bluetooth/

Initial commit for HFP Client

Change-Id: I0dabd9df1cafc48d5e30e29c36898b6d1af6e874
parent 2f1256d4

android/app/jni/com_android_bluetooth_hfpclient.cpp

0 → 100644
+568 −0
Original line number Diff line number Diff line 
/*

 * 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



#define CHECK_CALLBACK_ENV                                                      \

   if (!checkCallbackThread()) {                                                \

       ALOGE("Callback: '%s' is not called on the correct thread", __FUNCTION__);\

       return;                                                                  \

   }



#include "com_android_bluetooth.h"

#include "hardware/bt_hf.h"

#include "utils/Log.h"

#include "android_runtime/AndroidRuntime.h"



#include <string.h>



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_onNoiceReductionEnable;

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 const bthf_interface_t *sBluetoothHfpInterface = NULL;

static jobject mCallbacksObj = NULL;

static JNIEnv *sCallbackEnv = NULL;



static bool checkCallbackThread() {

    // Always fetch the latest callbackEnv from AdapterService.

    // Caching this could cause this sCallbackEnv to go out-of-sync

    // with the AdapterService's ENV if an ASSOCIATE/DISASSOCIATE event

    // is received

    //if (sCallbackEnv == NULL) {

    sCallbackEnv = getCallbackEnv();

    //}

    JNIEnv* env = AndroidRuntime::getJNIEnv();

    if (sCallbackEnv != env || sCallbackEnv == NULL) return false;

    return true;

}



static void connection_state_callback(bthf_connection_state_t state, bt_bdaddr_t* bd_addr) {

    jbyteArray addr;



    ALOGI("%s", __FUNCTION__);



    CHECK_CALLBACK_ENV

    addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t));

    if (!addr) {

        ALOGE("Fail to new jbyteArray bd addr for connection state");

        checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

        return;

    }



    sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte*) bd_addr);

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectionStateChanged,

                                 (jint) state, addr);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

    sCallbackEnv->DeleteLocalRef(addr);

}



static void audio_state_callback(bthf_audio_state_t state, bt_bdaddr_t* bd_addr) {

    jbyteArray addr;



    CHECK_CALLBACK_ENV

    addr = sCallbackEnv->NewByteArray(sizeof(bt_bdaddr_t));

    if (!addr) {

        ALOGE("Fail to new jbyteArray bd addr for audio state");

        checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

        return;

    }



    sCallbackEnv->SetByteArrayRegion(addr, 0, sizeof(bt_bdaddr_t), (jbyte *) bd_addr);

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAudioStateChanged, (jint) state, addr);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

    sCallbackEnv->DeleteLocalRef(addr);

}



static void voice_recognition_callback(bthf_vr_state_t state) {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onVrStateChanged, (jint) state);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void answer_call_callback() {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAnswerCall);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void hangup_call_callback() {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onHangupCall);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void volume_control_callback(bthf_volume_type_t type, int volume) {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onVolumeChanged, (jint) type, (jint) volume);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void dial_call_callback(char *number) {

    CHECK_CALLBACK_ENV

    jstring js_number = sCallbackEnv->NewStringUTF(number);

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onDialCall,

                                 js_number);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

    sCallbackEnv->DeleteLocalRef(js_number);

}



static void dtmf_cmd_callback(char dtmf) {

    CHECK_CALLBACK_ENV

    // TBD dtmf has changed from int to char

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onSendDtmf, dtmf);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void noice_reduction_callback(bthf_nrec_t nrec) {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onNoiceReductionEnable,

                                 nrec == BTHF_NREC_START);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void at_chld_callback(bthf_chld_type_t chld) {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtChld, chld);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void at_cnum_callback() {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtCnum);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void at_cind_callback() {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtCind);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void at_cops_callback() {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtCops);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void at_clcc_callback() {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onAtClcc);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static void unknown_at_callback(char *at_string) {

    CHECK_CALLBACK_ENV

    jstring js_at_string = sCallbackEnv->NewStringUTF(at_string);

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onUnknownAt,

                                 js_at_string);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

    sCallbackEnv->DeleteLocalRef(js_at_string);

}



static void key_pressed_callback() {

    CHECK_CALLBACK_ENV

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onKeyPressed);

    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);

}



static bthf_callbacks_t sBluetoothHfpCallbacks = {

    sizeof(sBluetoothHfpCallbacks),

    connection_state_callback,

    audio_state_callback,

    voice_recognition_callback,

    answer_call_callback,

    hangup_call_callback,

    volume_control_callback,

    dial_call_callback,

    dtmf_cmd_callback,

    noice_reduction_callback,

    at_chld_callback,

    at_cnum_callback,

    at_cind_callback,

    at_cops_callback,

    at_clcc_callback,

    unknown_at_callback,

    key_pressed_callback

};



static void classInitNative(JNIEnv* env, jclass clazz) {

    int err;

    /*

    const bt_interface_t* btInf;

    bt_status_t status;

    */



    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)V");

    method_onAnswerCall = env->GetMethodID(clazz, "onAnswerCall", "()V");

    method_onHangupCall = env->GetMethodID(clazz, "onHangupCall", "()V");

    method_onVolumeChanged = env->GetMethodID(clazz, "onVolumeChanged", "(II)V");

    method_onDialCall = env->GetMethodID(clazz, "onDialCall", "(Ljava/lang/String;)V");

    method_onSendDtmf = env->GetMethodID(clazz, "onSendDtmf", "(I)V");

    method_onNoiceReductionEnable = env->GetMethodID(clazz, "onNoiceReductionEnable", "(Z)V");

    method_onAtChld = env->GetMethodID(clazz, "onAtChld", "(I)V");

    method_onAtCnum = env->GetMethodID(clazz, "onAtCnum", "()V");

    method_onAtCind = env->GetMethodID(clazz, "onAtCind", "()V");

    method_onAtCops = env->GetMethodID(clazz, "onAtCops", "()V");

    method_onAtClcc = env->GetMethodID(clazz, "onAtClcc", "()V");

    method_onUnknownAt = env->GetMethodID(clazz, "onUnknownAt", "(Ljava/lang/String;)V");

    method_onKeyPressed = env->GetMethodID(clazz, "onKeyPressed", "()V");



    /*

    if ( (btInf = getBluetoothInterface()) == NULL) {

        ALOGE("Bluetooth module is not loaded");

        return;

    }



    if ( (sBluetoothHfpInterface = (bthf_interface_t *)

          btInf->get_profile_interface(BT_PROFILE_HANDSFREE_ID)) == NULL) {

        ALOGE("Failed to get Bluetooth Handsfree Interface");

        return;

    }



    // TODO(BT) do this only once or

    //          Do we need to do this every time the BT reenables?

    if ( (status = sBluetoothHfpInterface->init(&sBluetoothHfpCallbacks)) != BT_STATUS_SUCCESS) {

        ALOGE("Failed to initialize Bluetooth HFP, status: %d", status);

        sBluetoothHfpInterface = NULL;

        return;

    }

    */



    ALOGI("%s: succeeds", __FUNCTION__);

}



static void initializeNative(JNIEnv *env, jobject object) {

    const bt_interface_t* btInf;

    bt_status_t status;



    if ( (btInf = getBluetoothInterface()) == NULL) {

        ALOGE("Bluetooth module is not loaded");

        return;

    }



    if (sBluetoothHfpInterface !=NULL) {

        ALOGW("Cleaning up Bluetooth Handsfree Interface before initializing...");

        sBluetoothHfpInterface->cleanup();

        sBluetoothHfpInterface = NULL;

    }



    if (mCallbacksObj != NULL) {

        ALOGW("Cleaning up Bluetooth Handsfree callback object");

        env->DeleteGlobalRef(mCallbacksObj);

        mCallbacksObj = NULL;

    }



    if ( (sBluetoothHfpInterface = (bthf_interface_t *)

          btInf->get_profile_interface(BT_PROFILE_HANDSFREE_ID)) == NULL) {

        ALOGE("Failed to get Bluetooth Handsfree Interface");

        return;

    }



    if ( (status = sBluetoothHfpInterface->init(&sBluetoothHfpCallbacks)) != BT_STATUS_SUCCESS) {

        ALOGE("Failed to initialize Bluetooth HFP, status: %d", status);

        sBluetoothHfpInterface = NULL;

        return;

    }



    mCallbacksObj = env->NewGlobalRef(object);

}



static void cleanupNative(JNIEnv *env, jobject object) {

    const bt_interface_t* btInf;

    bt_status_t status;



    if ( (btInf = getBluetoothInterface()) == NULL) {

        ALOGE("Bluetooth module is not loaded");

        return;

    }



    if (sBluetoothHfpInterface !=NULL) {

        ALOGW("Cleaning up Bluetooth Handsfree Interface...");

        sBluetoothHfpInterface->cleanup();

        sBluetoothHfpInterface = NULL;

    }



    if (mCallbacksObj != NULL) {

        ALOGW("Cleaning up Bluetooth Handsfree callback object");

        env->DeleteGlobalRef(mCallbacksObj);

        mCallbacksObj = NULL;

    }

}



static jboolean connectHfpNative(JNIEnv *env, jobject object, jbyteArray address) {

    jbyte *addr;

    bt_status_t status;



    ALOGI("%s: sBluetoothHfpInterface: %p", __FUNCTION__, sBluetoothHfpInterface);

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    addr = env->GetByteArrayElements(address, NULL);

    if (!addr) {

        jniThrowIOException(env, EINVAL);

        return JNI_FALSE;

    }



    if ((status = sBluetoothHfpInterface->connect((bt_bdaddr_t *)addr)) != 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) {

    jbyte *addr;

    bt_status_t status;



    if (!sBluetoothHfpInterface) return JNI_FALSE;



    addr = env->GetByteArrayElements(address, NULL);

    if (!addr) {

        jniThrowIOException(env, EINVAL);

        return JNI_FALSE;

    }



    if ( (status = sBluetoothHfpInterface->disconnect((bt_bdaddr_t *)addr)) != 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) {

    jbyte *addr;

    bt_status_t status;



    if (!sBluetoothHfpInterface) return JNI_FALSE;



    addr = env->GetByteArrayElements(address, NULL);

    if (!addr) {

        jniThrowIOException(env, EINVAL);

        return JNI_FALSE;

    }



    if ( (status = sBluetoothHfpInterface->connect_audio((bt_bdaddr_t *)addr)) !=

         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) {

    jbyte *addr;

    bt_status_t status;



    if (!sBluetoothHfpInterface) return JNI_FALSE;



    addr = env->GetByteArrayElements(address, NULL);

    if (!addr) {

        jniThrowIOException(env, EINVAL);

        return JNI_FALSE;

    }



    if ( (status = sBluetoothHfpInterface->disconnect_audio((bt_bdaddr_t *) addr)) !=

         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 startVoiceRecognitionNative(JNIEnv *env, jobject object) {

    bt_status_t status;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    if ( (status = sBluetoothHfpInterface->start_voice_recognition()) != BT_STATUS_SUCCESS) {

        ALOGE("Failed to start voice recognition, status: %d", status);

    }

    return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;

}



static jboolean stopVoiceRecognitionNative(JNIEnv *env, jobject object) {

    bt_status_t status;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    if ( (status = sBluetoothHfpInterface->stop_voice_recognition()) != BT_STATUS_SUCCESS) {

        ALOGE("Failed to stop voice recognition, status: %d", status);

    }

    return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;

}



static jboolean setVolumeNative(JNIEnv *env, jobject object, jint volume_type, jint volume) {

    bt_status_t status;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    if ( (status = sBluetoothHfpInterface->volume_control((bthf_volume_type_t) volume_type,

                                                          volume)) != BT_STATUS_SUCCESS) {

        ALOGE("FAILED to control volume, status: %d", status);

    }

    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) {

    bt_status_t status;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    if ( (status = sBluetoothHfpInterface->device_status_notification

          ((bthf_network_state_t) network_state, (bthf_service_type_t) service_type,

           signal, battery_charge)) != 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) {

    bt_status_t status;

    const char *operator_name;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    operator_name = env->GetStringUTFChars(operator_str, NULL);



    if ( (status = sBluetoothHfpInterface->cops_response(operator_name)) != BT_STATUS_SUCCESS) {

        ALOGE("Failed sending cops response, status: %d", status);

    }

    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) {

    bt_status_t status;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    if ( (status = sBluetoothHfpInterface->cind_response(service, num_active, num_held,

                       (bthf_call_state_t) call_state,

                       signal, roam, battery_charge)) != BT_STATUS_SUCCESS) {

        ALOGE("Failed cind_response, status: %d", status);

    }

    return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;

}





static jboolean atResponseStringNative(JNIEnv *env, jobject object, jstring response_str) {

    bt_status_t status;

    const char *response;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    response = env->GetStringUTFChars(response_str, NULL);



    if ( (status = sBluetoothHfpInterface->formatted_at_response(response)) != BT_STATUS_SUCCESS) {

        ALOGE("Failed formatted AT response, status: %d", status);

    }

    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) {

    bt_status_t status;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    if ( (status = sBluetoothHfpInterface->at_response((bthf_at_response_t) response_code, cmee_code)) !=

         BT_STATUS_SUCCESS) {

        ALOGE("Failed AT response, status: %d", status);

    }

    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) {

    bt_status_t status;

    const char *number = NULL;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    if (number_str)

        number = env->GetStringUTFChars(number_str, NULL);



    if ( (status = sBluetoothHfpInterface->clcc_response(index, (bthf_call_direction_t) dir,

                     (bthf_call_state_t) callStatus,  (bthf_call_mode_t) mode,

                     mpty ? BTHF_CALL_MPTY_TYPE_MULTI : BTHF_CALL_MPTY_TYPE_SINGLE,

                     number, (bthf_call_addrtype_t) type)) != BT_STATUS_SUCCESS) {

        ALOGE("Failed sending CLCC response, status: %d", status);

    }

    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) {

    bt_status_t status;

    const char *number;

    if (!sBluetoothHfpInterface) return JNI_FALSE;



    number = env->GetStringUTFChars(number_str, NULL);



    if ( (status = sBluetoothHfpInterface->phone_state_change(num_active, num_held,

                       (bthf_call_state_t) call_state, number,

                       (bthf_call_addrtype_t) type)) != BT_STATUS_SUCCESS) {

        ALOGE("Failed report phone state change, status: %d", status);

    }

    env->ReleaseStringUTFChars(number_str, number);

    return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;

}



static JNINativeMethod sMethods[] = {

    {"classInitNative", "()V", (void *) classInitNative},

    {"initializeNative", "()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},

    {"startVoiceRecognitionNative", "()Z", (void *) startVoiceRecognitionNative},

    {"stopVoiceRecognitionNative", "()Z", (void *) stopVoiceRecognitionNative},

    {"setVolumeNative", "(II)Z", (void *) setVolumeNative},

    {"notifyDeviceStatusNative", "(IIII)Z", (void *) notifyDeviceStatusNative},

    {"copsResponseNative", "(Ljava/lang/String;)Z", (void *) copsResponseNative},

    {"cindResponseNative", "(IIIIIII)Z", (void *) cindResponseNative},

    {"atResponseStringNative", "(Ljava/lang/String;)Z", (void *) atResponseStringNative},

    {"atResponseCodeNative", "(II)Z", (void *)atResponseCodeNative},

    {"clccResponseNative", "(IIIIZLjava/lang/String;I)Z", (void *) clccResponseNative},

    {"phoneStateChangeNative", "(IIILjava/lang/String;I)Z", (void *) phoneStateChangeNative},

};



int register_com_android_bluetooth_hfp(JNIEnv* env)

{

    return jniRegisterNativeMethods(env, "com/android/bluetooth/hfp/HeadsetStateMachine",

                                    sMethods, NELEM(sMethods));

}



} /* namespace android */

android/app/src/com/android/bluetooth/hfpclient/HandsfreeClientHalConstants.java

0 → 100644
+67 −0
Original line number Diff line number Diff line 
/*

 * 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.

 */



package com.android.bluetooth.hfp;



/*

 * @hide

 */



final public class HeadsetHalConstants {

    // Do not modify without upating the HAL bt_hf.h files.



    // match up with bthf_connection_state_t enum of bt_hf.h

    final static int CONNECTION_STATE_DISCONNECTED = 0;

    final static int CONNECTION_STATE_CONNECTING = 1;

    final static int CONNECTION_STATE_CONNECTED = 2;

    final static int CONNECTION_STATE_SLC_CONNECTED = 3;

    final static int CONNECTION_STATE_DISCONNECTING = 4;



    // match up with bthf_audio_state_t enum of bt_hf.h

    final static int AUDIO_STATE_DISCONNECTED = 0;

    final static int AUDIO_STATE_CONNECTING = 1;

    final static int AUDIO_STATE_CONNECTED = 2;

    final static int AUDIO_STATE_DISCONNECTING = 3;



    // match up with bthf_vr_state_t enum of bt_hf.h

    final static int VR_STATE_STOPPED = 0;

    final static int VR_STATE_STARTED = 1;



    // match up with bthf_volume_type_t enum of bt_hf.h

    final static int VOLUME_TYPE_SPK = 0;

    final static int VOLUME_TYPE_MIC = 1;



    // match up with bthf_network_state_t enum of bt_hf.h

    final static int NETWORK_STATE_NOT_AVAILABLE = 0;

    final static int NETWORK_STATE_AVAILABLE = 1;



    // match up with bthf_service_type_t enum of bt_hf.h

    final static int SERVICE_TYPE_HOME = 0;

    final static int SERVICE_TYPE_ROAMING = 1;



    // match up with bthf_at_response_t of bt_hf.h

    final static int AT_RESPONSE_ERROR = 0;

    final static int AT_RESPONSE_OK = 1;



    // match up with bthf_call_state_t of bt_hf.h

    final static int CALL_STATE_ACTIVE = 0;

    final static int CALL_STATE_HELD = 1;

    final static int CALL_STATE_DIALING = 2;

    final static int CALL_STATE_ALERTING = 3;

    final static int CALL_STATE_INCOMING = 4;

    final static int CALL_STATE_WAITING = 5;

    final static int CALL_STATE_IDLE = 6;

}

android/app/src/com/android/bluetooth/hfpclient/HandsfreeClientService.java

0 → 100644
+514 −0

File added.

Preview size limit exceeded, changes collapsed.

android/app/src/com/android/bluetooth/hfpclient/HandsfreeClientStateMachine.java

0 → 100644
+2089 −0

File added.

Preview size limit exceeded, changes collapsed.