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

Commit 3525c228 authored by Łukasz Rymanowski (xWF)'s avatar Łukasz Rymanowski (xWF) Committed by Gerrit Code Review
Browse files

Merge changes I28f9c9b8,I68dd438c,I9a0e1fb3 into main 

* changes:
  VolumeControlService: Add AICS support
  vc: Add AICS support
  vc: Store and add description to dumpsys
parents 62b5b95c 7f5b57c0

android/app/jni/com_android_bluetooth_vc.cpp

+336 −3
Original line number Diff line number Diff line
@@ -36,6 +36,11 @@ static jmethodID method_onDeviceAvailable; 
static jmethodID method_onExtAudioOutVolumeOffsetChanged;

static jmethodID method_onExtAudioOutLocationChanged;

static jmethodID method_onExtAudioOutDescriptionChanged;

static jmethodID method_onExtAudioInStateChanged;

static jmethodID method_onExtAudioInStatusChanged;

static jmethodID method_onExtAudioInTypeChanged;

static jmethodID method_onExtAudioInGainPropsChanged;

static jmethodID method_onExtAudioInDescriptionChanged;



static VolumeControlInterface* sVolumeControlInterface = nullptr;

static std::shared_timed_mutex interface_mutex;
@@ -105,7 +110,8 @@ public: 
                                 (jboolean)mute, group_id, (jboolean)isAutonomous);

  }



  void OnDeviceAvailable(const RawAddress& bd_addr, uint8_t num_offsets) override {

  void OnDeviceAvailable(const RawAddress& bd_addr, uint8_t num_offsets,

                         uint8_t num_inputs) override {

    log::info("");



    std::shared_lock<std::shared_timed_mutex> lock(callbacks_mutex);
@@ -124,7 +130,7 @@ public: 
    sCallbackEnv->SetByteArrayRegion(addr.get(), 0, sizeof(RawAddress),

                                     reinterpret_cast<const jbyte*>(&bd_addr));

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onDeviceAvailable, (jint)num_offsets,

                                 addr.get());

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

  }



  void OnExtAudioOutVolumeOffsetChanged(const RawAddress& bd_addr, uint8_t ext_output_id,
@@ -200,6 +206,122 @@ public: 
    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioOutDescriptionChanged,

                                 (jint)ext_output_id, description, addr.get());

  }



  void OnExtAudioInStateChanged(const RawAddress& bd_addr, uint8_t ext_input_id, int8_t gain_val,

                                uint8_t gain_mode, bool mute) override {

    log::info("");



    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 get addr for {}", bd_addr);

      return;

    }



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

                                     reinterpret_cast<const jbyte*>(&bd_addr));

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInStateChanged, (jint)ext_input_id,

                                 (jint)gain_val, (jint)gain_mode, (jboolean)mute, addr.get());

  }



  void OnExtAudioInStatusChanged(const RawAddress& bd_addr, uint8_t ext_input_id,

                                 bluetooth::vc::VolumeInputStatus status) override {

    log::info("");



    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 get addr for {}", bd_addr);

      return;

    }



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

                                     reinterpret_cast<const jbyte*>(&bd_addr));

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInStatusChanged,

                                 (jint)ext_input_id, (jint)status, addr.get());

  }



  void OnExtAudioInTypeChanged(const RawAddress& bd_addr, uint8_t ext_input_id,

                               bluetooth::vc::VolumeInputType type) override {

    log::info("");



    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 get addr for {}", bd_addr);

      return;

    }



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

                                     reinterpret_cast<const jbyte*>(&bd_addr));

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInTypeChanged, (jint)ext_input_id,

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

  }



  void OnExtAudioInGainPropsChanged(const RawAddress& bd_addr, uint8_t ext_input_id, uint8_t unit,

                                    int8_t min, int8_t max) override {

    log::info("");



    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 get addr for {}", bd_addr);

      return;

    }



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

                                     reinterpret_cast<const jbyte*>(&bd_addr));

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInGainPropsChanged,

                                 (jint)ext_input_id, (jint)unit, (jint)min, (jint)max, addr.get());

  }



  void OnExtAudioInDescriptionChanged(const RawAddress& bd_addr, uint8_t ext_input_id,

                                      std::string descr) override {

    log::info("");



    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 get addr for {}", bd_addr);

      return;

    }



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

                                     reinterpret_cast<const jbyte*>(&bd_addr));

    jstring description = sCallbackEnv->NewStringUTF(descr.c_str());

    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onExtAudioInDescriptionChanged,

                                 (jint)ext_input_id, description, addr.get());

  }

};



static VolumeControlCallbacksImpl sVolumeControlCallbacks;
@@ -514,6 +636,195 @@ static jboolean setExtAudioOutDescriptionNative(JNIEnv* env, jobject /* object * 
  return JNI_TRUE;

}



/* Native methods for external audio inputs */

static jboolean getExtAudioInStateNative(JNIEnv* env, jobject /* object */, jbyteArray address,

                                         jint ext_input_id) {

  log::info("");

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

  if (!sVolumeControlInterface) {

    return JNI_FALSE;

  }



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

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);

  sVolumeControlInterface->GetExtAudioInState(*tmpraw, ext_input_id);

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

  return JNI_TRUE;

}



static jboolean getExtAudioInStatusNative(JNIEnv* env, jobject /* object */, jbyteArray address,

                                          jint ext_input_id) {

  log::info("");

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

  if (!sVolumeControlInterface) {

    return JNI_FALSE;

  }



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

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);

  sVolumeControlInterface->GetExtAudioInStatus(*tmpraw, ext_input_id);

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

  return JNI_TRUE;

}



static jboolean getExtAudioInTypeNative(JNIEnv* env, jobject /* object */, jbyteArray address,

                                        jint ext_input_id) {

  log::info("");

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

  if (!sVolumeControlInterface) {

    return JNI_FALSE;

  }



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

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);

  sVolumeControlInterface->GetExtAudioInType(*tmpraw, ext_input_id);

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

  return JNI_TRUE;

}



static jboolean getExtAudioInGainPropsNative(JNIEnv* env, jobject /* object */, jbyteArray address,

                                             jint ext_input_id) {

  log::info("");

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

  if (!sVolumeControlInterface) {

    return JNI_FALSE;

  }



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

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);

  sVolumeControlInterface->GetExtAudioInGainProps(*tmpraw, ext_input_id);

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

  return JNI_TRUE;

}



static jboolean getExtAudioInDescriptionNative(JNIEnv* env, jobject /* object */,

                                               jbyteArray address, jint ext_input_id) {

  log::info("");

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

  if (!sVolumeControlInterface) {

    return JNI_FALSE;

  }



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

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);

  sVolumeControlInterface->GetExtAudioInDescription(*tmpraw, ext_input_id);

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

  return JNI_TRUE;

}



static jboolean setExtAudioInDescriptionNative(JNIEnv* env, jobject /* object */,

                                               jbyteArray address, jint ext_input_id,

                                               jstring descr) {

  log::info("");

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

  if (!sVolumeControlInterface) {

    return JNI_FALSE;

  }



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

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  std::string description;

  if (descr != nullptr) {

    const char* value = env->GetStringUTFChars(descr, nullptr);

    description = std::string(value);

    env->ReleaseStringUTFChars(descr, value);

  }



  RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);

  sVolumeControlInterface->SetExtAudioInDescription(*tmpraw, ext_input_id, description);

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

  return JNI_TRUE;

}



static jboolean setExtAudioInGainValueNative(JNIEnv* env, jobject /* object */, jbyteArray address,

                                             jint ext_input_id, jint gain_val) {

  log::info("");

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

  if (!sVolumeControlInterface) {

    return JNI_FALSE;

  }



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

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);

  sVolumeControlInterface->SetExtAudioInGainValue(*tmpraw, ext_input_id, gain_val);

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

  return JNI_TRUE;

}



static jboolean setExtAudioInGainModeNative(JNIEnv* env, jobject /* object */, jbyteArray address,

                                            jint ext_input_id, jboolean mode_auto) {

  log::info("");

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

  if (!sVolumeControlInterface) {

    return JNI_FALSE;

  }



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

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);

  sVolumeControlInterface->SetExtAudioInGainMode(*tmpraw, ext_input_id, mode_auto);

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

  return JNI_TRUE;

}



static jboolean setExtAudioInGainMuteNative(JNIEnv* env, jobject /* object */, jbyteArray address,

                                            jint ext_input_id, jboolean mute) {

  log::info("");

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

  if (!sVolumeControlInterface) {

    return JNI_FALSE;

  }



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

  if (!addr) {

    jniThrowIOException(env, EINVAL);

    return JNI_FALSE;

  }



  RawAddress* tmpraw = reinterpret_cast<RawAddress*>(addr);

  sVolumeControlInterface->SetExtAudioInGainMute(*tmpraw, ext_input_id, mute);

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

  return JNI_TRUE;

}



int register_com_android_bluetooth_vc(JNIEnv* env) {

  const JNINativeMethod methods[] = {

          {"initNative", "()V", reinterpret_cast<void*>(initNative)},
@@ -540,6 +851,22 @@ int register_com_android_bluetooth_vc(JNIEnv* env) { 
           reinterpret_cast<void*>(getExtAudioOutDescriptionNative)},

          {"setExtAudioOutDescriptionNative", "([BILjava/lang/String;)Z",

           reinterpret_cast<void*>(setExtAudioOutDescriptionNative)},

          {"getExtAudioInStateNative", "([BI)Z", reinterpret_cast<void*>(getExtAudioInStateNative)},

          {"getExtAudioInStatusNative", "([BI)Z",

           reinterpret_cast<void*>(getExtAudioInStatusNative)},

          {"getExtAudioInTypeNative", "([BI)Z", reinterpret_cast<void*>(getExtAudioInTypeNative)},

          {"getExtAudioInGainPropsNative", "([BI)Z",

           reinterpret_cast<void*>(getExtAudioInGainPropsNative)},

          {"getExtAudioInDescriptionNative", "([BI)Z",

           reinterpret_cast<void*>(getExtAudioInDescriptionNative)},

          {"setExtAudioInDescriptionNative", "([BILjava/lang/String;)Z",

           reinterpret_cast<void*>(setExtAudioInDescriptionNative)},

          {"setExtAudioInGainValueNative", "([BII)Z",

           reinterpret_cast<void*>(setExtAudioInGainValueNative)},

          {"setExtAudioInGainModeNative", "([BIZ)Z",

           reinterpret_cast<void*>(setExtAudioInGainModeNative)},

          {"setExtAudioInGainMuteNative", "([BIZ)Z",

           reinterpret_cast<void*>(setExtAudioInGainMuteNative)},

  };

  const int result = REGISTER_NATIVE_METHODS(

          env, "com/android/bluetooth/vc/VolumeControlNativeInterface", methods);
@@ -551,11 +878,17 @@ int register_com_android_bluetooth_vc(JNIEnv* env) { 
          {"onConnectionStateChanged", "(I[B)V", &method_onConnectionStateChanged},

          {"onVolumeStateChanged", "(IZI[BZ)V", &method_onVolumeStateChanged},

          {"onGroupVolumeStateChanged", "(IZIZ)V", &method_onGroupVolumeStateChanged},

          {"onDeviceAvailable", "(I[B)V", &method_onDeviceAvailable},

          {"onDeviceAvailable", "(II[B)V", &method_onDeviceAvailable},

          {"onExtAudioOutVolumeOffsetChanged", "(II[B)V", &method_onExtAudioOutVolumeOffsetChanged},

          {"onExtAudioOutLocationChanged", "(II[B)V", &method_onExtAudioOutLocationChanged},

          {"onExtAudioOutDescriptionChanged", "(ILjava/lang/String;[B)V",

           &method_onExtAudioOutDescriptionChanged},

          {"onExtAudioInStateChanged", "(IIIZ[B)V", &method_onExtAudioInStateChanged},

          {"onExtAudioInStatusChanged", "(II[B)V", &method_onExtAudioInStatusChanged},

          {"onExtAudioInTypeChanged", "(II[B)V", &method_onExtAudioInTypeChanged},

          {"onExtAudioInGainPropsChanged", "(IIII[B)V", &method_onExtAudioInGainPropsChanged},

          {"onExtAudioInDescriptionChanged", "(ILjava/lang/String;[B)V",

           &method_onExtAudioInDescriptionChanged},

  };

  GET_JAVA_METHODS(env, "com/android/bluetooth/vc/VolumeControlNativeInterface", javaMethods);

android/app/src/com/android/bluetooth/vc/VolumeControlInputDescriptor.java

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

 * Copyright (C) 2024 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.vc;



import android.bluetooth.BluetoothVolumeControl;

import android.util.Log;



import com.android.bluetooth.btservice.ProfileService;



import java.util.HashMap;

import java.util.Map;



class VolumeControlInputDescriptor {

    private static final String TAG = "VolumeControlInputDescriptor";

    final Map<Integer, Descriptor> mVolumeInputs = new HashMap<>();



    public static final int AUDIO_INPUT_TYPE_UNSPECIFIED = 0x00;

    public static final int AUDIO_INPUT_TYPE_BLUETOOTH = 0x01;

    public static final int AUDIO_INPUT_TYPE_MICROPHONE = 0x02;

    public static final int AUDIO_INPUT_TYPE_ANALOG = 0x03;

    public static final int AUDIO_INPUT_TYPE_DIGITAL = 0x04;

    public static final int AUDIO_INPUT_TYPE_RADIO = 0x05;

    public static final int AUDIO_INPUT_TYPE_STREAMING = 0x06;

    public static final int AUDIO_INPUT_TYPE_AMBIENT = 0x07;



    private static class Descriptor {

        /* True when input is active, false otherwise */

        boolean mIsActive = false;



        /* Defined as in Assigned Numbers in the BluetoothVolumeControl.AUDIO_INPUT_TYPE_ */

        int mType = AUDIO_INPUT_TYPE_UNSPECIFIED;



        int mGainValue = 0;



        /* As per AICS 1.0

         * 3.1.3. Gain_Mode field

         * The Gain_Mode field shall be set to a value that reflects whether gain modes are

         *  manual or automatic.

         *

         * If the Gain_Mode field value is Manual Only, the server allows only manual gain.

         * If the Gain_Mode field is Automatic Only, the server allows only automatic gain.

         *

         * For all other Gain_Mode field values, the server allows switchable

         * automatic/manual gain.

         */

        int mGainMode = 0;



        boolean mIsMute = false;



        /* As per AICS 1.0

         * The Gain_Setting (mGainValue) field is a signed value for which a single increment

         * or decrement should result in a corresponding increase or decrease of the input

         * amplitude by the value of the Gain_Setting_Units (mGainSettingsUnits)

         * field of the Gain Setting Properties characteristic value.

         */

        int mGainSettingsUnits = 0;



        int mGainSettingsMaxSetting = 0;

        int mGainSettingsMinSetting = 0;



        String mDescription = "";

    }



    int size() {

        return mVolumeInputs.size();

    }



    void add(int id) {

        if (!mVolumeInputs.containsKey(id)) {

            mVolumeInputs.put(id, new Descriptor());

        }

    }



    boolean setActive(int id, boolean active) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "setActive, Id " + id + " is unknown");

            return false;

        }

        desc.mIsActive = active;

        return true;

    }



    boolean isActive(int id) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "isActive, Id " + id + " is unknown");

            return false;

        }

        return desc.mIsActive;

    }



    boolean setDescription(int id, String description) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "setDescription, Id " + id + " is unknown");

            return false;

        }

        desc.mDescription = description;

        return true;

    }



    String getDescription(int id) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "getDescription, Id " + id + " is unknown");

            return null;

        }

        return desc.mDescription;

    }



    boolean setType(int id, int type) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "setType, Id " + id + " is unknown");

            return false;

        }



        if (type > AUDIO_INPUT_TYPE_AMBIENT) {

            Log.e(TAG, "setType, Type " + type + "for id " + id + " is invalid");

            return false;

        }



        desc.mType = type;

        return true;

    }



    int getType(int id) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "getType, Id " + id + " is unknown");

            return AUDIO_INPUT_TYPE_UNSPECIFIED;

        }

        return desc.mType;

    }



    int getGain(int id) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "getGain, Id " + id + " is unknown");

            return 0;

        }

        return desc.mGainValue;

    }



    boolean isMuted(int id) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "isMuted, Id " + id + " is unknown");

            return false;

        }

        return desc.mIsMute;

    }



    boolean setPropSettings(int id, int gainUnit, int gainMin, int gainMax) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "setPropSettings, Id " + id + " is unknown");

            return false;

        }



        desc.mGainSettingsUnits = gainUnit;

        desc.mGainSettingsMinSetting = gainMin;

        desc.mGainSettingsMaxSetting = gainMax;



        return true;

    }



    boolean setState(int id, int gainValue, int gainMode, boolean mute) {

        Descriptor desc = mVolumeInputs.get(id);

        if (desc == null) {

            Log.e(TAG, "Id " + id + " is unknown");

            return false;

        }



        if (gainValue > desc.mGainSettingsMaxSetting || gainValue < desc.mGainSettingsMinSetting) {

            Log.e(TAG, "Invalid gainValue " + gainValue);

            return false;

        }



        desc.mGainValue = gainValue;

        desc.mGainMode = gainMode;

        desc.mIsMute = mute;



        return true;

    }



    void remove(int id) {

        Log.d(TAG, "remove, id: " + id);

        mVolumeInputs.remove(id);

    }



    void clear() {

        Log.d(TAG, "clear all inputs");

        mVolumeInputs.clear();

    }



    void dump(StringBuilder sb) {

        for (Map.Entry<Integer, Descriptor> entry : mVolumeInputs.entrySet()) {

            Descriptor desc = entry.getValue();

            Integer id = entry.getKey();

            ProfileService.println(sb, "        id: " + id);

            ProfileService.println(sb, "        description: " + desc.mDescription);

            ProfileService.println(sb, "        type: " + desc.mType);

            ProfileService.println(sb, "        isActive: " + desc.mIsActive);

            ProfileService.println(sb, "        gainValue: " + desc.mGainValue);

            ProfileService.println(sb, "        gainMode: " + desc.mGainMode);

            ProfileService.println(sb, "        mute: " + desc.mIsMute);

            ProfileService.println(sb, "        units:" + desc.mGainSettingsUnits);

            ProfileService.println(sb, "        minGain:" + desc.mGainSettingsMinSetting);

            ProfileService.println(sb, "        maxGain:" + desc.mGainSettingsMaxSetting);

        }

    }

}