devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

分析Android O的AudioPolicyService服务（一）_audiopolicyservice::onfirstref()

作者：正经夜光杯 | 2024-07-24 17:21:22

赞

踩

audiopolicyservice::onfirstref()
AudioPolicyManager.cpp:音频策略的管理类，也可以说是服务端；
  • 分析createAudioPolicyManager函数的初始化；
  1. void AudioPolicyService::onFirstRef()
  2. {
  3. .......
  4. mAudioPolicyManager = createAudioPolicyManager(mAudioPolicyClient);
  5. ......
  6. }

createAudioPolicyManager函数在如下文件中进行声明和实现

路径：frameworks/av/services/audiopolicy/manager/AudioPolicyFactory.cpp

  1. #include "managerdefault/AudioPolicyManager.h"
  2.  
  3. namespace android {
  4.  
  5. extern "C" AudioPolicyInterface* createAudioPolicyManager(
  6.         AudioPolicyClientInterface *clientInterface)
  7. {
  8.     return new AudioPolicyManager(clientInterface);
  9. }
  10.  
  11. extern "C" void destroyAudioPolicyManager(AudioPolicyInterface *interface)
  12. {
  13.     delete interface;
  14. }
  15.  
  16. } // namespace android

通过new 一个AudioPolicyManager对象，

路径：frameworks/av/services/audiopolicy/managerdefault/AudioPolicyManager.cpp

  1. AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
  2.         : AudioPolicyManager(clientInterface, false /*forTesting*/)
  3. {
  4.     loadConfig(); //加载音频的配置文件,配置文件在哪里呢？请看下面
  5.     initialize(); //初始化对象
  6. }
  • 接下来就看loadConfig()的函数中具体加载什么样的配置文件呢？
  1. #define AUDIO_POLICY_VENDOR_CONFIG_FILE "/vendor/etc/audio_policy.conf
  2.  
  3. void AudioPolicyManager::loadConfig() {
  4. #ifdef USE_XML_AUDIO_POLICY_CONF //如果这个宏在Android.mk文件中有定义则执行
  5.     if (deserializeAudioPolicyXmlConfig(getConfig()) != NO_ERROR) {
  6. #else
  7. 　　//加载两个配置文件；
  8.     if ((ConfigParsingUtils::loadConfig(AUDIO_POLICY_VENDOR_CONFIG_FILE, getConfig()) != NO_ERROR)
  9.            && (ConfigParsingUtils::loadConfig(AUDIO_POLICY_CONFIG_FILE, getConfig()) != NO_ERROR)) {
  10. #endif
  11.         ALOGE("could not load audio policy configuration file, setting defaults");
  12.         getConfig().setDefault();
  13.     }
  14. }

两个配置文件的宏定义如下：
frameworks/av/services/audiopolicy/common/managerdefinitions/include/audio_policy_conf.h

  1. /
  2. //      Definitions for audio policy configuration file (audio_policy.conf)
  3. /
  4.  
  5. #define AUDIO_HARDWARE_MODULE_ID_MAX_LEN 32
  6.  
  7. #define AUDIO_POLICY_CONFIG_FILE "/system/etc/audio_policy.conf"
  8. #define AUDIO_POLICY_VENDOR_CONFIG_FILE "/vendor/etc/audio_policy.conf"

如果配置不存在，则加载默认的配置；

  • 第二函数就是initialize()，它做了哪些工作呢？？
  1. status_t AudioPolicyManager::initialize() {
  2.     mVolumeCurves->initializeVolumeCurves(getConfig().isSpeakerDrcEnabled());
  3.  
  4.     // Once policy config has been parsed, retrieve an instance of the engine and initialize it.
  5.     //分析完策略配置后，声明引擎的实例并初始化它。
  6.     audio_policy::EngineInstance *engineInstance = audio_policy::EngineInstance::getInstance();
  7.     if (!engineInstance) {
  8.         ALOGE("%s:  Could not get an instance of policy engine", __FUNCTION__);
  9.         return NO_INIT;
  10.     }
  11.     // Retrieve the Policy Manager Interface
  12.     //通过实例engineInstance查询AudioPolicyManagerInterface接口
  13.     mEngine = engineInstance->queryInterface<AudioPolicyManagerInterface>();
  14.     if (mEngine == NULL) {
  15.         ALOGE("%s: Failed to get Policy Engine Interface", __FUNCTION__);
  16.         return NO_INIT;
  17.     }
  18.     //　将AudioPolicyManager设置观察者
  19.     mEngine->setObserver(this);
  20.     //检测策略引擎是否初始化成功
  21.     status_t status = mEngine->initCheck();
  22.     if (status != NO_ERROR) {
  23.         LOG_FATAL("Policy engine not initialized(err=%d)", status);
  24.         return status;
  25.     }
  26.     // mAvailableOutputDevices and mAvailableInputDevices now contain all attached devices
  27.     // open all output streams needed to access attached devices
  28.     //现在mAvailableOutputDevices和mAvailableInputDevices变量包含所有连接的设备
  29.     //打开所有输出流必须能访问连接设备
  30.     audio_devices_t outputDeviceTypes = mAvailableOutputDevices.types();
  31.     audio_devices_t inputDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN;
  32.     for (const auto& hwModule : mHwModulesAll) {
  33.        ......
  34.         //初始化所有的硬件模块
  35.     }
  36.     // open input streams needed to access attached devices to validate
  37.     // mAvailableInputDevices list
  38.     //使mAvailableInputDevices列表的设备生效
  39.     for (const auto& inProfile : hwModule->getInputProfiles()) {
  40.     }
  41.     ......
  42.     // make sure all attached devices have been allocated a unique ID
  43.     // 保证所有的连接设备都有一个独一无二的ID
  44.     for (size_t i = 0; i  < mAvailableOutputDevices.size();) {
  45.         if (!mAvailableOutputDevices[i]->isAttached()) {
  46.             ALOGW("Output device %08x unreachable", mAvailableOutputDevices[i]->type());
  47.             mAvailableOutputDevices.remove(mAvailableOutputDevices[i]);
  48.             continue;
  49.         }
  50.         // The device is now validated and can be appended to the available devices of the engine
  51.         mEngine->setDeviceConnectionState(mAvailableOutputDevices[i],
  52.                                           AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
  53.         i++;
  54.     }
  55. 	// 保证所有输入连接设备都有一个独一无二的ID
  56.     for (size_t i = 0; i  < mAvailableInputDevices.size();) {
  57.         if (!mAvailableInputDevices[i]->isAttached()) {
  58.             ALOGW("Input device %08x unreachable", mAvailableInputDevices[i]->type());
  59.             mAvailableInputDevices.remove(mAvailableInputDevices[i]);
  60.             continue;
  61.         }
  62.         // The device is now validated and can be appended to the available devices of the engine
  63.         mEngine->setDeviceConnectionState(mAvailableInputDevices[i],
  64.                                           AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
  65.         i++;
  66.     }
  67.     // make sure default device is reachable
  68.     // 保证默认音频设备可用
  69.     if (mDefaultOutputDevice == 0 || mAvailableOutputDevices.indexOf(mDefaultOutputDevice) < 0) {
  70.         ALOGE("Default device %08x is unreachable", mDefaultOutputDevice->type());
  71.         status = NO_INIT;
  72.     }
  73.     // If microphones address is empty, set it according to device type
  74.     // 如果麦克风地址为空，需根据设备类型来设置麦克风的地址
  75.     for (size_t i = 0; i  < mAvailableInputDevices.size(); i++) {
  76.         if (mAvailableInputDevices[i]->mAddress.isEmpty()) {
  77.             if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BUILTIN_MIC) {
  78.                 mAvailableInputDevices[i]->mAddress = String8(AUDIO_BOTTOM_MICROPHONE_ADDRESS);
  79.             } else if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BACK_MIC) {
  80.                 mAvailableInputDevices[i]->mAddress = String8(AUDIO_BACK_MICROPHONE_ADDRESS);
  81.             }
  82.         }
  83.     }
  84.     //更新设备和输出设备，其实就是根据系统的当前状态选择最后的输出设备
  85.     updateDevicesAndOutputs();
  86.     return status;
  87. }

至此初始化的任务就已经执行完毕，该函数整理来说干了四件事：
第一，获取AudioPolicyManagerInterface的引擎对象mEngine
第二，设置AudioPolicyManager的观察者，允许引擎可获取有关设备、流、hwmodules等集合的信息。
第三，打通音频的输出输入设备
第四，根据音频的输出输入设备类型的策略设置当前的路由策略

 

  • 下面来具体分析EngineInstance的实例对做了什么：
  1.     // Once policy config has been parsed, retrieve an instance of the engine and initialize it.
  2.     audio_policy::EngineInstance *engineInstance = audio_policy::EngineInstance::getInstance();
  3.     if (!engineInstance) {
  4.         ALOGE("%s:  Could not get an instance of policy engine", __FUNCTION__);
  5.         return NO_INIT;
  6.     }

通过命名空间的audio_policy得到EngineInstance单例类然后在通过getInstance()获取engineInstance的指针对象；
EngineInstance.cpp的类，路径：
frameworks/av/services/audiopolicy/enginedefault/src/EngineInstance.cpp

  1. #include <AudioPolicyManagerInterface.h>
  2. #include "AudioPolicyEngineInstance.h"
  3. #include "Engine.h"
  4.  
  5. namespace android
  6. {
  7. namespace audio_policy //命名空间为audio_policy
  8. {
  9. //构造函数,没有做任何事情，因为是单例
  10. EngineInstance::EngineInstance()
  11. {
  12. }
  13. //返回EngineInstance对象的地址
  14. EngineInstance *EngineInstance::getInstance()
  15. {
  16.     static EngineInstance instance;
  17.     return &instance;
  18. }
  19. //返回Engine对象的地址，也就是指针
  20. Engine *EngineInstance::getEngine() const
  21. {
  22.     static Engine engine;
  23.     return &engine;
  24. }
  25. //模板函数，返回AudioPolicyManagerInterface对象的指针
  26. template <>
  27. AudioPolicyManagerInterface *EngineInstance::queryInterface() const
  28. {
  29.     return getEngine()->queryInterface<AudioPolicyManagerInterface>();
  30. }
  31.  
  32. } // namespace audio_policy
  33. } // namespace android

既然已经得到了单例，那么有什么作用？？？
作用就是通过queryInterface函数获取Engine对象指针，如上面的代码，这个Engine的作用就比较大了，稍后分析，
调用下面的代码，首先通过queryInterface函数获取mEngine对象指针，然后再设置AudioPolicyManagerObserver为作为观察者，最后，通过mEngine->initCheck()函数检测观察者模式是否设置成功；

  1. // Retrieve the Policy Manager Interface
  2. mEngine = engineInstance->queryInterface<AudioPolicyManagerInterface>();
  3. if (mEngine == NULL) {
  4.     ALOGE("%s: Failed to get Policy Engine Interface", __FUNCTION__);
  5.     return NO_INIT;
  6. }
  7. mEngine->setObserver(this);
  8. status_t status = mEngine->initCheck();
  9. if (status != NO_ERROR) {
  10.     LOG_FATAL("Policy engine not initialized(err=%d)", status);
  11.     return status;
  12. }

所有与音频策略相关的设置和获取都在Engine.cpp类中：
frameworks/av/services/audiopolicy/enginedefault/src/Engine.cpp

  • 再来分析音频设备：
  1.     // mAvailableOutputDevices and mAvailableInputDevices now contain all attached devices
  2.     // open all output streams needed to access attached devices
  3.     audio_devices_t outputDeviceTypes = mAvailableOutputDevices.types();
  4.     audio_devices_t inputDeviceTypes = mAvailableInputDevices.types() & ~AUDIO_DEVICE_BIT_IN;

首先从DeviceVector得到输入、输出的设备类型变量：
下面的这个for循环有点长，需要有点耐心：
 

  1. //变量mHwModulesAll的声明在.h文件中：HwModuleCollection mHwModulesAll;
  2. //开始循环遍历所有的音频模块，这些音频模块不一定每个都可用
  3. for (const auto& hwModule : mHwModulesAll) {
  4.     //通过模块名称加载硬件模块，如果不能打开相应模块，则继续循环
  5.     hwModule->setHandle(mpClientInterface->loadHwModule(hwModule->getName()));
  6.     if (hwModule->getHandle() == AUDIO_MODULE_HANDLE_NONE) {
  7.         ALOGW("could not open HW module %s", hwModule->getName());
  8.         continue;
  9.     }
  10.     //将加载的模块保存到集合：mHwModules中，声明：HwModuleCollection mHwModules;这个变量只保存加载成功的音频硬件模块
  11.     mHwModules.push_back(hwModule);
  12.     // open all output streams needed to access attached devices
  13.     // except for direct output streams that are only opened when they are actually
  14.     // required by an app.
  15.     // This also validates mAvailableOutputDevices list
  16.     for (const auto& outProfile : hwModule->getOutputProfiles()) {
  17.         //得到InputProfileCollection实例，outProfile实质就是IOProfile对象的引用
  18.         //判断输出设备是可以打开
  19.         if (!outProfile->canOpenNewIo()) {
  20.             ALOGE("Invalid Output profile max open count %u for profile %s",
  21.                   outProfile->maxOpenCount, outProfile->getTagName().c_str());
  22.             continue;
  23.         }
  24.         //是否支持设备
  25.         if (!outProfile->hasSupportedDevices()) {
  26.             ALOGW("Output profile contains no device on module %s", hwModule->getName());
  27.             continue;
  28.         }
  29.         //得到tts输出设备是否可用
  30.         if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_TTS) != 0) {
  31.             mTtsOutputAvailable = true;
  32.         }
  33.  
  34.         if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {
  35.             continue;
  36.         }
  37.         //获取支持的输出设备类型
  38.         audio_devices_t profileType = outProfile->getSupportedDevicesType();
  39.         if ((profileType & mDefaultOutputDevice->type()) != AUDIO_DEVICE_NONE) {
  40.             profileType = mDefaultOutputDevice->type();
  41.         } else {
  42.             // chose first device present in profile's SupportedDevices also part of
  43.             // outputDeviceTypes
  44.             profileType = outProfile->getSupportedDeviceForType(outputDeviceTypes);
  45.         }
  46.         if ((profileType & outputDeviceTypes) == 0) {
  47.             continue;
  48.         }
  49.         //new 一个输出设备的描述符
  50.         sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
  51.                                                                              mpClientInterface);
  52.         const DeviceVector &supportedDevices = outProfile->getSupportedDevices();
  53.         const DeviceVector &devicesForType = supportedDevices.getDevicesFromType(profileType);
  54.         String8 address = devicesForType.size() > 0 ? devicesForType.itemAt(0)->mAddress
  55.                 : String8("");
  56.         audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
  57.         //通过描述符打开输出设备的地址
  58.         status_t status = outputDesc->open(nullptr, profileType, address,
  59.                                        AUDIO_STREAM_DEFAULT, AUDIO_OUTPUT_FLAG_NONE, &output);
  60.  
  61.         if (status != NO_ERROR) {
  62.             ALOGW("Cannot open output stream for device %08x on hw module %s",
  63.                   outputDesc->mDevice,
  64.                   hwModule->getName());
  65.         } else {
  66. 　　　　　　　 //循环遍历支持的设备
  67.             for (const auto& dev : supportedDevices) {
  68.                 ssize_t index = mAvailableOutputDevices.indexOf(dev);
  69.                 // give a valid ID to an attached device once confirmed it is reachable
  70.                 if (index >= 0 && !mAvailableOutputDevices[index]->isAttached()) {
  71.                     mAvailableOutputDevices[index]->attach(hwModule);
  72.                 }
  73.             }
  74.             if (mPrimaryOutput == 0 &&
  75.                     outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
  76.                 mPrimaryOutput = outputDesc;
  77.             }
  78.             //将输出设备添加到列表中mOutputs，然后设备输出设备
  79.             addOutput(output, outputDesc);
  80.             setOutputDevice(outputDesc,
  81.                             profileType,
  82.                             true,
  83.                             0,
  84.                             NULL,
  85.                             address);
  86.         }
  87.     }
  88.     // open input streams needed to access attached devices to validate
  89.     // mAvailableInputDevices list
  90.     //获取可用的输入设备，方法同输出设备的方法一样，不做分析
  91.     for (const auto& inProfile : hwModule->getInputProfiles()) {
  92.         if (!inProfile->canOpenNewIo()) {
  93.             ALOGE("Invalid Input profile max open count %u for profile %s",
  94.                   inProfile->maxOpenCount, inProfile->getTagName().c_str());
  95.             continue;
  96.         }
  97.         if (!inProfile->hasSupportedDevices()) {
  98.             ALOGW("Input profile contains no device on module %s", hwModule->getName());
  99.             continue;
  100.         }
  101.         // chose first device present in profile's SupportedDevices also part of
  102.         // inputDeviceTypes
  103.         audio_devices_t profileType = inProfile->getSupportedDeviceForType(inputDeviceTypes);
  104.  
  105.         if ((profileType & inputDeviceTypes) == 0) {
  106.             continue;
  107.         }
  108.         sp<AudioInputDescriptor> inputDesc =
  109.                 new AudioInputDescriptor(inProfile, mpClientInterface);
  110.  
  111.         DeviceVector inputDevices = mAvailableInputDevices.getDevicesFromType(profileType);
  112.         //   the inputs vector must be of size >= 1, but we don't want to crash here
  113.         String8 address = inputDevices.size() > 0 ? inputDevices.itemAt(0)->mAddress
  114.                 : String8("");
  115.         ALOGV("  for input device 0x%x using address %s", profileType, address.string());
  116.         ALOGE_IF(inputDevices.size() == 0, "Input device list is empty!");
  117.  
  118.         audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
  119.         status_t status = inputDesc->open(nullptr,
  120.                                           profileType,
  121.                                           address,
  122.                                           AUDIO_SOURCE_MIC,
  123.                                           AUDIO_INPUT_FLAG_NONE,
  124.                                           &input);
  125.  
  126.         if (status == NO_ERROR) {
  127.             for (const auto& dev : inProfile->getSupportedDevices()) {
  128.                 ssize_t index = mAvailableInputDevices.indexOf(dev);
  129.                 // give a valid ID to an attached device once confirmed it is reachable
  130.                 if (index >= 0) {
  131.                     sp<DeviceDescriptor> devDesc = mAvailableInputDevices[index];
  132.                     if (!devDesc->isAttached()) {
  133.                         devDesc->attach(hwModule);
  134.                         devDesc->importAudioPort(inProfile, true);
  135.                     }
  136.                 }
  137.             }
  138.             inputDesc->close();
  139.         } else {
  140.             ALOGW("Cannot open input stream for device %08x on hw module %s",
  141.                   profileType,
  142.                   hwModule->getName());
  143.         }
  144.     }
  145. }

接下来就为可用的输入、输出设备分析独一无二的ID：

  1. // make sure all attached devices have been allocated a unique ID
  2. for (size_t i = 0; i  < mAvailableOutputDevices.size();) {
  3. 		//调用的路径：DeviceVector->DeviceDescriptor.h->AudioPort.h->isAttached()
  4. 		//判断是音频硬件模块是否真的可用
  5.     if (!mAvailableOutputDevices[i]->isAttached()) {
  6.         ALOGW("Output device %08x unreachable", mAvailableOutputDevices[i]->type());
  7.         mAvailableOutputDevices.remove(mAvailableOutputDevices[i]);
  8.         continue;
  9.     }
  10.     // The device is now validated and can be appended to the available devices of the engine
  11.     //　该设备现在已经过验证，可以附加到发动机的可用设备上。设置设备的连接状态为：音频策略设备状态可用
  12.     mEngine->setDeviceConnectionState(mAvailableOutputDevices[i],
  13.                                       AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
  14.     i++;
  15. }
  16. //输入设备同上
  17. for (size_t i = 0; i  < mAvailableInputDevices.size();) {
  18.     if (!mAvailableInputDevices[i]->isAttached()) {
  19.         ALOGW("Input device %08x unreachable", mAvailableInputDevices[i]->type());
  20.         mAvailableInputDevices.remove(mAvailableInputDevices[i]);
  21.         continue;
  22.     }
  23.     // The device is now validated and can be appended to the available devices of the engine
  24.     mEngine->setDeviceConnectionState(mAvailableInputDevices[i],
  25.                                       AUDIO_POLICY_DEVICE_STATE_AVAILABLE);
  26.     i++;
  27. }
  1. // make sure default device is reachable
  2. //确定默认的输出设备是否可用
  3. if (mDefaultOutputDevice == 0 || mAvailableOutputDevices.indexOf(mDefaultOutputDevice) < 0) {
  4.     ALOGE("Default device %08x is unreachable", mDefaultOutputDevice->type());
  5.     status = NO_INIT;
  6. }
  7. // If microphones address is empty, set it according to device type
  8. //如果麦克风地址为空，则设置
  9. for (size_t i = 0; i  < mAvailableInputDevices.size(); i++) {
  10.     if (mAvailableInputDevices[i]->mAddress.isEmpty()) {
  11.         if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BUILTIN_MIC) {
  12.             mAvailableInputDevices[i]->mAddress = String8(AUDIO_BOTTOM_MICROPHONE_ADDRESS);
  13.         } else if (mAvailableInputDevices[i]->type() == AUDIO_DEVICE_IN_BACK_MIC) {
  14.             mAvailableInputDevices[i]->mAddress = String8(AUDIO_BACK_MICROPHONE_ADDRESS);
  15.         }
  16.     }
  17. }
  • 最后一个方法：updateDevicesAndOutputs()，根据当前系统设备状态设置音频策略：
  1. void AudioPolicyManager::updateDevicesAndOutputs()
  2. {
  3.     for (int i = 0; i < NUM_STRATEGIES; i++) {
  4.     		//为设备获取音频策略
  5.         mDeviceForStrategy[i] = getDeviceForStrategy((routing_strategy)i, false /*fromCache*/);
  6.     }
  7.     mPreviousOutputs = mOutputs;
  8. }

至此分析完成，如有不正确的地方，请指教

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/875972
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号