Android Q Audio 自上而下的调用逻辑和各模块相关初始化（四）——hal层通信

Android Q Audio 自上而下的调用逻辑和各模块相关初始化（AudioFlinger通信、Audio hal 加载、AudioDevice 选择）

随手笔记系列，内容较多较繁琐，用于结合目录快速查询

本文将通过AudioManger的setMastermute Api的通信传递实现逻辑，自上而下梳理一下调用顺序和各模块相关初始化，最终到的audio_hw.c来实现静音

四、hal层通信

4.1 AudioFlinger到libAudioHal的setMasterMute逻辑

在2.1.7的时候 setMasterMute实现逻辑是 通过dev->hwDevice()->setMasterMute(muted);

    for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
        AutoMutex lock(mHardwareLock);
        AudioHwDevice *dev = mAudioHwDevs.valueAt(i);

        mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
        if (dev->canSetMasterMute()) {
            //调用到hal的加载
            dev->hwDevice()->setMasterMute(muted);
        }
        mHardwareStatus = AUDIO_HW_IDLE;
    }   

先看这个dev->hwDevice

在3.1.5里 这个 dev是AudioHwDevice，hwDevice是存放的DeviceHalInterface

	int rc = mDevicesFactoryHal->openDevice(name, &dev);
	audio_module_handle_t handle = (audio_module_handle_t) nextUniqueId(AUDIO_UNIQUE_ID_USE_MODULE);
    mAudioHwDevs.add(handle, new AudioHwDevice(handle, name, dev, flags));

    AudioHwDevice(audio_module_handle_t handle,
                  const char *moduleName,
                  sp<DeviceHalInterface> hwDevice,
                  Flags flags)
        : mHandle(handle)
        , mModuleName(strdup(moduleName))
        , mHwDevice(hwDevice)
        , mFlags(flags) { }
sp<DeviceHalInterface> hwDevice() const { return mHwDevice; }

mDevicesFactoryHal->openDevice(name, &dev); 初始化这个DeviceHalInterface

在3.2.2里 DeviceHalInterface 其实就是DeviceHALHidl

        Return<void> ret = factory->openDevice(
                hidlId,
                [&](Result r, const sp<IDevice>& result) {
                    retval = r;
                    if (retval == Result::OK) {
                        *device = new DeviceHalHidl(result);
                    }
                });

所以 dev->hwDevice()->setMasterMute(muted); 就是 DeviceHalHidl的 setMasterMute(mute);

4.2 DeviceHalHidl setMasterMute(mute)

status_t DeviceHalHidl::setMasterMute(bool state) {
    if (mDevice == 0) return NO_INIT;
    return processReturn("setMasterMute", mDevice->setMasterMute(state));
}

看一下返回值如何处理

在ConversionHelperHidl进行 result分析 从而返回一个status_t值

ConversionHelperHidl.h (f:\qcom-q\frameworks\av\media\libaudiohal\impl) 3210 2020/2/22

    template<typename T>
    status_t processReturn(const char* funcName, const Return<T>& ret) {
        if (!ret.isOk()) {
            emitError(funcName, ret.description().c_str());
        }
        return ret.isOk() ? OK : FAILED_TRANSACTION;
    }

    status_t processReturn(const char* funcName, const Return<CoreResult>& ret) {
        if (!ret.isOk()) {
            emitError(funcName, ret.description().c_str());
        }
        return ret.isOk() ? analyzeResult(ret) : FAILED_TRANSACTION;
    }

    template<typename T>
    status_t processReturn(
            const char* funcName, const Return<T>& ret, CoreResult retval) {
        if (!ret.isOk()) {
            emitError(funcName, ret.description().c_str());
        }
        return ret.isOk() ? analyzeResult(retval) : FAILED_TRANSACTION;
    }

在3.2.2和3.3.2里可知，mDevice为 PrimaryDevice

result = new DeviceShim(halDevice);

4.3 PrimaryDevice setMasterMute(state)

Return<Result> PrimaryDevice::setMasterMute(bool mute) {
    return mDevice->setMasterMute(mute);
}

由3.2.2可知，mDevice为Device

PrimaryDevice::PrimaryDevice(audio_hw_device_t* device) : mDevice(new Device(device)) {}

4.4 Device setMastMuste(state)

Return<Result> Device::setMasterMute(bool mute) {
    Result retval(Result::NOT_SUPPORTED);
    if (mDevice->set_master_mute != NULL) {
        retval = analyzeStatus("set_master_mute", mDevice->set_master_mute(mDevice, mute));
    }
    return retval;
}

由3.2.2和3.3.4可知，mDevice为audio_hw_device_t

4.5 audio_hw_device_t set_master_mute(mDevice, mute)

struct audio_hw_device {
	int (*set_master_mute)(struct audio_hw_device *dev, bool mute);

    int (*get_master_mute)(struct audio_hw_device *dev, bool *mute);
}

在open过程中 adev_open 将各个函数进行赋值

struct audio_hw_device {
    struct hw_device_t common;
	adev->device.set_master_mute = adev_set_master_mute;
    adev->device.get_master_mute = adev_get_master_mute;
}; 

所以 mDevice->set_master_mute(mDevice, mute)); 最后就是

adev_get_master_mute

4.6 Audio_hw.c adev_set_master_mute

高通的代码不能展示，这是模拟器的代码

static int adev_set_master_mute(struct audio_hw_device *dev, bool muted) {
    ALOGD("%s: %s", __func__, _bool_str(muted));
    struct generic_audio_device *adev = (struct generic_audio_device *)dev;
    pthread_mutex_lock(&adev->lock);
    adev->master_mute = muted;
    pthread_mutex_unlock(&adev->lock);
    return 0;
}

最终AudioManger的setMasterMute 最后就是这个Audio_hw.c adev_set_master_mute

五、总结

同理这些方法的调用过程 基本上是相同的

    adev->device.init_check = adev_init_check;               // no op
    adev->device.set_voice_volume = adev_set_voice_volume;   // no op
    adev->device.set_master_volume = adev_set_master_volume; // no op
    adev->device.get_master_volume = adev_get_master_volume; // no op
    adev->device.set_master_mute = adev_set_master_mute;
    adev->device.get_master_mute = adev_get_master_mute;
    adev->device.set_mode = adev_set_mode;                   // no op
    adev->device.set_mic_mute = adev_set_mic_mute;
    adev->device.get_mic_mute = adev_get_mic_mute;
    adev->device.set_parameters = adev_set_parameters;       // no op
    adev->device.get_parameters = adev_get_parameters;       // no op
    adev->device.get_input_buffer_size = adev_get_input_buffer_size;
    adev->device.open_output_stream = adev_open_output_stream;
    adev->device.close_output_stream = adev_close_output_stream;
    adev->device.open_input_stream = adev_open_input_stream;
    adev->device.close_input_stream = adev_close_input_stream;
    adev->device.dump = adev_dump;