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

Commit 409cb53b authored by Łukasz Rymanowski's avatar Łukasz Rymanowski Committed by Jakub Pawlowski
Browse files

vc: Add Volume Control Profile support 

This profile should be used internally by the LeAudio or other services.
In the future it could be exposed to the application. It make sense
especially when additions to control external audio input devices e.g. MIC, HDMI,
(via Audio Inputs Control Service) and external audio speakers (via
Volume Offset Control Service)

Test: atest VolumeControlStateMachineTest VolumeControlServiceTest
Tag: #feature
Bug: 159786353
Sponsor: jpawlowski@

Merged-In: Ic4bfa5cc0f26b904c6a6767182aed31d4fabac0a
Change-Id: Ic4bfa5cc0f26b904c6a6767182aed31d4fabac0a
parent 685d3d77

android/app/AndroidManifest.xml

+9 −0
Original line number Diff line number Diff line
@@ -407,6 +407,15 @@ 
                <action android:name="android.bluetooth.IBluetoothHearingAid"/>

            </intent-filter>

        </service>

        <service

            android:process="@string/process"

            android:name=".vc.VolumeControlService"

            android:exported="true"

            android:enabled="@bool/profile_supported_vc">

            <intent-filter>

                <action android:name="android.bluetooth.IBluetoothVolumeControl" />

            </intent-filter>

        </service>

        <service

            android:process="@string/process"

            android:name = ".le_audio.LeAudioService"

android/app/jni/com_android_bluetooth.h

+2 −0
Original line number Diff line number Diff line
@@ -159,6 +159,8 @@ int register_com_android_bluetooth_btservice_BluetoothKeystore(JNIEnv* env); 
int register_com_android_bluetooth_btservice_activity_attribution(JNIEnv* env);



int register_com_android_bluetooth_le_audio(JNIEnv* env);



int register_com_android_bluetooth_vc(JNIEnv* env);

}  // namespace android



#endif /* COM_ANDROID_BLUETOOTH_H */

android/app/jni/com_android_bluetooth_btservice_AdapterService.cpp

+6 −0
Original line number Diff line number Diff line
@@ -1814,5 +1814,11 @@ jint JNI_OnLoad(JavaVM* jvm, void* reserved) { 
    return JNI_ERR;

  }



  status = android::register_com_android_bluetooth_vc(e);

  if (status < 0) {

    ALOGE("jni vc registration failure: %d", status);

    return JNI_ERR;

  }



  return JNI_VERSION_1_6;

}

android/app/jni/com_android_bluetooth_vc.cpp

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

 * Copyright 2021 HIMSA II K/S - www.himsa.com.

 * Represented by EHIMA - www.ehima.com

 *

 * 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 "BluetoothVolumeControlServiceJni"



#define LOG_NDEBUG 0



#include <string.h>

#include <shared_mutex>



#include "base/logging.h"

#include "com_android_bluetooth.h"

#include "hardware/bt_vc.h"



using bluetooth::vc::ConnectionState;

using bluetooth::vc::VolumeControlCallbacks;

using bluetooth::vc::VolumeControlInterface;



namespace android {

static jmethodID method_onConnectionStateChanged;

static jmethodID method_onVolumeStateChanged;

static jmethodID method_onGroupVolumeStateChanged;



static VolumeControlInterface* sVolumeControlInterface = nullptr;

static std::shared_timed_mutex interface_mutex;



static jobject mCallbacksObj = nullptr;

static std::shared_timed_mutex callbacks_mutex;



class VolumeControlCallbacksImpl : public VolumeControlCallbacks {

 public:

  ~VolumeControlCallbacksImpl() = default;

  void OnConnectionState(ConnectionState state,

                         const RawAddress& bd_addr) override {

    LOG(INFO) << __func__;



    std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid() || mCallbacksObj == nullptr) return;



    ScopedLocalRef<jbyteArray> addr(

        sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));

    if (!addr.get()) {

      LOG(ERROR) << "Failed to new jbyteArray bd addr for connection state";

      return;

    }



    sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),

                                     (jbyte*)&bd_addr);

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onConnectionStateChanged,

                                 (jint)state, addr.get());

  }



  void OnVolumeStateChanged(const RawAddress& bd_addr, uint8_t volume,

                            bool mute) override {

    LOG(INFO) << __func__;



    std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid() || mCallbacksObj == nullptr) return;



    ScopedLocalRef<jbyteArray> addr(

        sCallbackEnv.get(), sCallbackEnv->NewByteArray(sizeof(RawAddress)));

    if (!addr.get()) {

      LOG(ERROR) << "Failed to new jbyteArray bd addr for connection state";

      return;

    }



    sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),

                                     (jbyte*)&bd_addr);

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onVolumeStateChanged,

                                 (jint)volume, (jboolean)mute, addr.get());

  }



  void OnGroupVolumeStateChanged(int group_id, uint8_t volume,

                                 bool mute) override {

    LOG(INFO) << __func__;



    std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);

    CallbackEnv sCallbackEnv(__func__);

    if (!sCallbackEnv.valid() || mCallbacksObj == nullptr) return;



    sCallbackEnv->CallVoidMethod(mCallbacksObj,

                                 method_onGroupVolumeStateChanged, (jint)volume,

                                 (jboolean)mute, group_id);

  }

};



static VolumeControlCallbacksImpl sVolumeControlCallbacks;



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

  method_onConnectionStateChanged =

      env->GetMethodID(clazz, "onConnectionStateChanged", "(I[B)V");



  method_onVolumeStateChanged =

      env->GetMethodID(clazz, "onVolumeStateChanged", "(IZ[B)V");



  method_onGroupVolumeStateChanged =

      env->GetMethodID(clazz, "onGroupVolumeStateChanged", "(IZI)V");



  LOG(INFO) << __func__ << ": succeeds";

}



static void initNative(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 == nullptr) {

    LOG(ERROR) << "Bluetooth module is not loaded";

    return;

  }



  if (sVolumeControlInterface != nullptr) {

    LOG(INFO) << "Cleaning up VolumeControl Interface before initializing...";

    sVolumeControlInterface->Cleanup();

    sVolumeControlInterface = nullptr;

  }



  if (mCallbacksObj != nullptr) {

    LOG(INFO) << "Cleaning up VolumeControl callback object";

    env->DeleteGlobalRef(mCallbacksObj);

    mCallbacksObj = nullptr;

  }



  if ((mCallbacksObj = env->NewGlobalRef(object)) == nullptr) {

    LOG(ERROR) << "Failed to allocate Global Ref for Volume control Callbacks";

    return;

  }



  sVolumeControlInterface =

      (VolumeControlInterface*)btInf->get_profile_interface(BT_PROFILE_VC_ID);

  if (sVolumeControlInterface == nullptr) {

    LOG(ERROR) << "Failed to get Bluetooth Volume Control Interface";

    return;

  }



  sVolumeControlInterface->Init(&sVolumeControlCallbacks);

}



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

    LOG(ERROR) << "Bluetooth module is not loaded";

    return;

  }



  if (sVolumeControlInterface != nullptr) {

    sVolumeControlInterface->Cleanup();

    sVolumeControlInterface = nullptr;

  }



  if (mCallbacksObj != nullptr) {

    env->DeleteGlobalRef(mCallbacksObj);

    mCallbacksObj = nullptr;

  }

}



static jboolean connectVolumeControlNative(JNIEnv* env, jobject object,

                                           jbyteArray address) {

  LOG(INFO) << __func__;

  std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);



  if (!sVolumeControlInterface) {

    LOG(ERROR) << __func__

               << ": Failed to get the Bluetooth Volume Control Interface";

    return JNI_FALSE;

  }



  jbyte* addr = env->GetByteArrayElements(address, nullptr);

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = (RawAddress*)addr;

  sVolumeControlInterface->Connect(*tmpraw);

  env->ReleaseByteArrayElements(address, addr, 0);

  return JNI_TRUE;

}



static jboolean disconnectVolumeControlNative(JNIEnv* env, jobject object,

                                              jbyteArray address) {

  LOG(INFO) << __func__;

  std::shared_lock<std::shared_timed_mutex> lock(interface_mutex);



  if (!sVolumeControlInterface) {

    LOG(ERROR) << __func__

               << ": Failed to get the Bluetooth Volume Control Interface";

    return JNI_FALSE;

  }



  jbyte* addr = env->GetByteArrayElements(address, nullptr);

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = (RawAddress*)addr;

  sVolumeControlInterface->Disconnect(*tmpraw);

  env->ReleaseByteArrayElements(address, addr, 0);

  return JNI_TRUE;

}



static void setVolumeNative(JNIEnv* env, jobject object, jbyteArray address,

                            jint volume) {

  if (!sVolumeControlInterface) {

    LOG(ERROR) << __func__

               << ": Failed to get the Bluetooth Volume Control Interface";

    return;

  }



  jbyte* addr = env->GetByteArrayElements(address, nullptr);

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return;

  }



  RawAddress* tmpraw = (RawAddress*)addr;

  sVolumeControlInterface->SetVolume(*tmpraw, volume);

  env->ReleaseByteArrayElements(address, addr, 0);

}



static void setVolumeGroupNative(JNIEnv* env, jobject object, jint group_id,

                                 jint volume) {

  if (!sVolumeControlInterface) {

    LOG(ERROR) << __func__

               << ": Failed to get the Bluetooth Volume Control Interface";

    return;

  }



  sVolumeControlInterface->SetVolume(group_id, volume);

}



static JNINativeMethod sMethods[] = {

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

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

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

    {"connectVolumeControlNative", "([B)Z", (void*)connectVolumeControlNative},

    {"disconnectVolumeControlNative", "([B)Z",

     (void*)disconnectVolumeControlNative},

    {"setVolumeNative", "([BI)V", (void*)setVolumeNative},

    {"setVolumeGroupNative", "(II)V", (void*)setVolumeGroupNative},

};



int register_com_android_bluetooth_vc(JNIEnv* env) {

  return jniRegisterNativeMethods(

      env, "com/android/bluetooth/vc/VolumeControlNativeInterface", sMethods,

      NELEM(sMethods));

}

}  // namespace android

android/app/res/values/config.xml

+1 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ 
    <bool name="profile_supported_pbapclient">false</bool>

    <bool name="profile_supported_mapmce">false</bool>

    <bool name="profile_supported_hid_device">true</bool>

    <bool name="profile_supported_vc">false</bool>



    <!-- If true, we will require location to be enabled on the device to

         fire Bluetooth LE scan result callbacks in addition to having one