[audio] AudioPolicy (一) 启动分析

原创 已于 2026-01-06 11:33:03 修改 · 443 阅读 · 8 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#android
于 2026-01-04 08:55:10 首次发布

av/media/audioserver/main_audioserver.cpp

        这里面 make 了 AudioFlinger 和 AudioPolicyService

int main(int argc __unused, char **argv)
{
    
    const auto af = sp<AudioFlinger>::make();

    const auto afAdapter = sp<AudioFlingerServerAdapter>::make(af);

    AudioSystem::setLocalAudioFlinger(af)

    const auto aps = sp<AudioPolicyService>::make();

    sp<IServiceManager> sm = defaultServiceManager();

    sm->addService(String16(IAudioFlinger::DEFAULT_SERVICE_NAME), afAdapter,
                false /* allowIsolated */, IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
    sm->addService(String16(AudioPolicyService::getServiceName()), aps,
                false /* allowIsolated */, IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
}

av/services/audiopolicy/service/AudioPolicyService.cpp

        看下构造，这边主要是要注意在初始化 mCreateAudioPolicyManager 成员变量是调了一个函数  createAudioPolicyManager

        然后看下 onFirstRef

AudioPolicyService::AudioPolicyService()
    : BnAudioPolicyService(),
      mAudioPolicyManager(NULL),
      mAudioPolicyClient(NULL),
      mPhoneState(AUDIO_MODE_INVALID),
      mCaptureStateNotifier(false),
      mCreateAudioPolicyManager(createAudioPolicyManager),
      mDestroyAudioPolicyManager(destroyAudioPolicyManager),
      mUsecaseValidator(media::createUsecaseValidator()),
      mPermissionController(sp<NativePermissionController>::make())
{
      setMinSchedulerPolicy(SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
      setInheritRt(true);
}

av/services/audiopolicy/service/AudioPolicyService.cpp  onFirstRef

        构造了 mAudioPolicyClient  AudioPolicyClient

        这里可以看到初始化了 mCreateAudioPolicyManager        

        调用 createAudioPolicyManager

void AudioPolicyService::onFirstRef()
{
    // start audio commands thread
    mAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);

    // start output activity command thread
    mOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);

    mAudioPolicyClient = new AudioPolicyClient(this);

    loadAudioPolicyManager();

    mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);

}

//  av/services/audiopolicy/service/AudioPolicyService.h

AudioPolicyInterface *mAudioPolicyManager;
AudioPolicyClient *mAudioPolicyClient;

av/services/audiopolicy/service/AudioPolicyService.cpp  createAudioPolicyManager mAudioPolicyClient

        从 xml 装载后构造  AudioPolicyManager 

        然后调用 initialize

static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
{
    AudioPolicyManager *apm = nullptr;

    media::AudioPolicyConfig apmConfig;

    if (status_t status = clientInterface->getAudioPolicyConfig(&apmConfig); status == OK) {


    } else {

        auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback();  // This can't fail.

        apm = new AudioPolicyManager(config,
                loadApmEngineLibraryAndCreateEngine(config->getEngineLibraryNameSuffix()),
                clientInterface);

    }

    status_t status = apm->initialize();

    return apm;
}

从 xml 装载后构造  AudioPolicyManager 

av/services/audiopolicy/common/managerdefinitions/src/AudioPolicyConfig.cpp  loadFromApmXmlConfigWithFallback

        vendor/etc/audio_policy_configuration.xml

sp<const AudioPolicyConfig> AudioPolicyConfig::loadFromApmXmlConfigWithFallback(
        const std::string& xmlFilePath) {
    const std::string filePath =
            xmlFilePath.empty() ? audio_get_audio_policy_config_file() : xmlFilePath;
    auto config = sp<AudioPolicyConfig>::make();
    if (status_t status = config->loadFromXml(filePath, false /*forVts*/); status == NO_ERROR) {
        return config;
    }
    return createDefault();
}

// av/services/audiopolicy/common/managerdefinitions/include/AudioPolicyConfig.h

class AudioPolicyConfig : public RefBase
{
private:    

    HwModuleCollection mHwModules; /**< Collection of Module, with Profiles, i.e. Mix Ports. */

    DeviceVector mOutputDevices;  // Attached output devices.

    DeviceVector mInputDevices;   // Attached input devices.

    sp<DeviceDescriptor> mDefaultOutputDevice;

};

vendor/etc/audio_policy_configuration.xml

        mHwModules = <modules>

        hwModule = <module name="primary" halVersion="2.0"> </module>

        IOProfile = <mixPort> 输出流就是 OutputProfile 输入流就是 InputProfile

        <profile /> 描述 mixPort 和 devicePort 的关系

        DeviceDescriptor = <devicePort>

        AudioRoute = <routes> 描述是 OutputProfile 和 DeviceDescriptor 的关系

        <attachedDevices> 表示一开机就能用于输入输出的硬件

<audioPolicyConfiguration version="1.0" xmlns:xi="http://www.w3.org/2001/XInclude">

    <modules>

        <!-- Primary Audio HAL -->
        <module name="primary" halVersion="2.0">

            <attachedDevices>
                <item>Speaker</item>
                <item>Built-In Mic</item>
                <item>Built-In Back Mic</item>
            </attachedDevices>

            <defaultOutputDevice>Speaker</defaultOutputDevice>

            <mixPorts>

                <mixPort name="primary output" role="source" flags="AUDIO_OUTPUT_FLAG_FAST|AUDIO_OUTPUT_FLAG_PRIMARY">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </mixPort>

                <mixPort name="raw" role="source"
                        flags="AUDIO_OUTPUT_FLAG_FAST">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </mixPort>

            </mixPorts>

            
            <devicePorts>
                <!-- Output devices declaration, i.e. Sink DEVICE PORT -->

                <devicePort tagName="Speaker" role="sink" type="AUDIO_DEVICE_OUT_SPEAKER" address="">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </devicePort>

                <devicePort tagName="Line" type="AUDIO_DEVICE_OUT_LINE" role="sink">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </devicePort>

            </devicePorts>

<!-- route declaration, i.e. list all available sources for a given sink -->
            <routes>

                <route type="mix" sink="Speaker"
                       sources="primary output,raw,deep_buffer,direct_pcm,compressed_offload,voip_rx,mmap_no_irq_out"/>

                <route type="mix" sink="Line"
                       sources="primary output,raw,deep_buffer,direct_pcm,compressed_offload,dsd_compress_passthrough,voip_rx,mmap_no_irq_out"/>
                
            </routes>

        </module>

    </modules>

</audioPolicyConfiguration>

然后调用 initialize

av/services/audiopolicy/managerdefault/AudioPolicyManager.cpp  构造器 initialize

        mpClientInterface  就是 AudioPolicyClient

        onNewAudioModulesAvailableInt

AudioPolicyManager::AudioPolicyManager(const sp<const AudioPolicyConfig>& config,
                                       EngineInstance&& engine,
                                       AudioPolicyClientInterface *clientInterface)
    :
    mUidCached(AID_AUDIOSERVER), // no need to call getuid(), there's only one of us running.
    mConfig(config),
    mEngine(std::move(engine)),
    mpClientInterface(clientInterface),
    mLimitRingtoneVolume(false), mLastVoiceVolume(-1.0f),
    mA2dpSuspended(false),
    mAudioPortGeneration(1),
    mBeaconMuteRefCount(0),
    mBeaconPlayingRefCount(0),
    mBeaconMuted(false),
    mTtsOutputAvailable(false),
    mMasterMono(false),
    mMusicEffectOutput(AUDIO_IO_HANDLE_NONE)
{
}


status_t AudioPolicyManager::initialize() {

    mEngine->setObserver(this);

    onNewAudioModulesAvailableInt(nullptr /*newDevices*/);

    // make sure default device is reachable
    if (const auto defaultOutputDevice = mConfig->getDefaultOutputDevice();
            defaultOutputDevice == nullptr ||
            !mAvailableOutputDevices.contains(defaultOutputDevice)) {

        status = NO_INIT;
    }


    updateDevicesAndOutputs();
    return status;
}

av/services/audiopolicy/managerdefault/AudioPolicyManager.cpp  onNewAudioModulesAvailableInt

        onNewAudioModulesAvailableInt  遍历 xml 中的 <module>

        mpClientInterface  就是 AudioPolicyClient

        调用 loadHwModule 装载到 mHwModules  打开设备 openDevice

        <mixPort> source 输出流就是 OutputProfile, 输入流 sink 就是 InputProfile

        构造 SwAudioOutputDescriptor

        每个具体的 hwModule 调用 outputDesc->open  打开流 openOutputStream

        将创建的 output hwModule 添加到 mAvailableOutputDevices

        将创建的 input hwModule 添加到 mAvailableInputDevices

        primary flag 的 hwModule 就赋值给 mPrimaryOutput

void AudioPolicyManager::onNewAudioModulesAvailableInt(DeviceVector *newDevices)
{

    for (const auto& hwModule : mConfig->getHwModules()) {

        if (hwModule->getHandle() == AUDIO_MODULE_HANDLE_NONE) {

            audio_module_handle_t handle = mpClientInterface->loadHwModule(hwModule->getName();

            hwModule->setHandle(handle);
        }

        mHwModules.push_back(hwModule);


        for (const auto& outProfile : hwModule->getOutputProfiles()) {

            const DeviceVector &supportedDevices = outProfile->getSupportedDevices();

            DeviceVector availProfileDevices = supportedDevices.filter(mConfig->getOutputDevices());

            sp<DeviceDescriptor> supportedDevice = 0;

            if (supportedDevices.contains(mConfig->getDefaultOutputDevice())) {

                supportedDevice = mConfig->getDefaultOutputDevice();

            }

            sp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,
                                                                            mpClientInterface);

            audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;

            audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE;

            audio_attributes_t attributes = AUDIO_ATTRIBUTES_INITIALIZER;
            
            // 打开流
            status_t status = outputDesc->open(nullptr /* halConfig */, nullptr /* mixerConfig */,
                                               DeviceVector(supportedDevice),
                                               AUDIO_STREAM_DEFAULT,
                                               &flags, &output, attributes);

            for (const auto &device : availProfileDevices) {
                // give a valid ID to an attached device once confirmed it is reachable
                if (!device->isAttached()) {

                    device->attach(hwModule);

                    mAvailableOutputDevices.add(device);

                }
            }

            if (mPrimaryOutput == nullptr &&
                    outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {
                mPrimaryOutput = outputDesc;
                mPrimaryModuleHandle = mPrimaryOutput->getModuleHandle();
            }

            addOutput(output, outputDesc);
            setOutputDevices(__func__, outputDesc,
                             DeviceVector(supportedDevice),
                             true,
                             0,
                             NULL);
        }


        for (const auto& inProfile : hwModule->getInputProfiles()) {
            sp<AudioInputDescriptor> inputDesc = new AudioInputDescriptor(
                    inProfile, mpClientInterface, false /*isPreemptor*/);

            audio_io_handle_t input = AUDIO_IO_HANDLE_NONE;
            status_t status = inputDesc->open(nullptr,
                                              availProfileDevices.itemAt(0),
                                              AUDIO_SOURCE_MIC,
                                              (audio_input_flags_t) inProfile->getFlags(),
                                              &input);
            
            for (const auto &device : availProfileDevices) {
                // give a valid ID to an attached device once confirmed it is reachable
                if (!device->isAttached()) {

                    device->attach(hwModule);

                    mAvailableInputDevices.add(device);
                }
            }

            inputDesc->close();
        }

    }
}

调用 loadHwModule 装载到 mHwModules  打开设备 openDevice

av/services/audiopolicy/service/AudioPolicyClientImpl.cpp  loadHwModule

audio_module_handle_t AudioPolicyService::AudioPolicyClient::loadHwModule(const char *name)
{
    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();

    return af->loadHwModule(name);
}

av/services/audioflinger/AudioFlinger.cpp  loadHwModule

        走到这的话后面的 loadHwModule_ll 流程参考

        https://blog.csdn.net/we1less/article/details/156506593?spm=1001.2014.3001.5502

        主要是注意 name 是 xml 中的 <module name="usb" halVersion="2.0">

audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
{

    AudioHwDevice* module = loadHwModule_ll(name);

    return module != nullptr ? module->handle() : AUDIO_MODULE_HANDLE_NONE;
}

每个具体的 hwModule 调用 outputDesc->open  打开流 openOutputStream

av/services/audiopolicy/common/managerdefinitions/src/AudioOutputDescriptor.cpp  open

        mpClientInterface  就是 AudioPolicyClient

status_t SwAudioOutputDescriptor::open(const audio_config_t *halConfig,
                                       const audio_config_base_t *mixerConfig,
                                       const DeviceVector &devices,
                                       audio_stream_type_t stream,
                                       audio_output_flags_t *flags,
                                       audio_io_handle_t *output,
                                       audio_attributes_t attributes)
{
    mDevices = devices;

    status_t status = mClientInterface->openOutput(mProfile->getModuleHandle(),
                                                   output,
                                                   &lHalConfig,
                                                   &lMixerConfig,
                                                   device,
                                                   &mLatency,
                                                   &mFlags,
                                                   attributes);

    return status;
}

av/services/audiopolicy/service/AudioPolicyClientImpl.cpp  openOutput

status_t AudioPolicyService::AudioPolicyClient::openOutput(audio_module_handle_t module,
                                                           audio_io_handle_t *output,
                                                           audio_config_t *halConfig,
                                                           audio_config_base_t *mixerConfig,
                                                           const sp<DeviceDescriptorBase>& device,
                                                           uint32_t *latencyMs,
                                                           audio_output_flags_t *flags,
                                                           audio_attributes_t attributes)
{
    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();

    status_t status = af->openOutput(request, &response);

    return status;
}

av/services/audioflinger/AudioFlinger.cpp  openOutput

        走到这的话后面的 openOutput_l 流程参考

        https://blog.csdn.net/we1less/article/details/156506593?spm=1001.2014.3001.5502

status_t AudioFlinger::openOutput(const media::OpenOutputRequest& request,
                                media::OpenOutputResponse* response)
{
    const sp<IAfThreadBase> thread = openOutput_l(module, &output, &halConfig,
            &mixerConfig, deviceType, address, &flags, attributes);

    return NO_INIT;
}

av/services/audiopolicy/managerdefault/AudioPolicyManager.cpp  addOutput

void AudioPolicyManager::addOutput(audio_io_handle_t output,
                                   const sp<SwAudioOutputDescriptor>& outputDesc)
{
    mOutputs.add(output, outputDesc);
    applyStreamVolumes(outputDesc, DeviceTypeSet(), 0 /* delayMs */, true /* force */);
    updateMono(output); // update mono status when adding to output list
    selectOutputForMusicEffects();
    nextAudioPortGeneration();
}

we1less
关注
Android AudioFlinger & AudioPolicy启动详解
m0_51231887的博客
05-11 2345
AudioPolicyService和AudioFlinger都是运行在AudioServer进程中的模块，它们的入口是在/frameworks/av/media/audioserver/main_audioserver.cpp文件中的main()函数中，由init进程通过解析audioserver.rc文件启动。main()函数干的事也比较简单，就是创建AudioPolicyService和AudioFlinger对象，并将它们两个作为Binder服务，添加进ServiceManager中。
audiopolicy分析
WAN8180192的博客
02-20 3216
本章节，大体介绍一下AudioPolicyService 手机的Audio输入源很多，例如放电影，放音乐，通话，铃声，提示音等 输出也很多，例如蓝牙，耳机，喇叭，听筒等 那么什么声音输出到什么地方呢？ 这就是AudioPolicyService干的事情了。 首先明确几个概念： 1，Audio interfaces 安卓手机上目前支持三类音频播放设备，这个主要是根据声音播放端和
android 线程级别
07-12 1059
Priority Value Description ANDROID_PRIORITY_LOWEST 19 可以使用最后的 ANDROID_PRIORITY_BACKGROUND 10 用于background task...
Android Binder调用的优先级降级
嘴巴吃糖了
04-20 1934
这是一个来自朋友的疑问，在`sf`调用`hwc`的`binder_f1`的函数中`hwc`调用`sf`的`binder_f2`，会导致线程的优先级从`97`降级为`120`。
Android 13 或更高版本中添加的相机功能只能通过 AIDL 相机 HAL 接口使用 没有HIDL的事情了
shangbolei的博客
02-02 3258
AIDL 和 HIDL 的区别
Android中的setInheritRT
LiuYong_01的博客
03-21 877
在Android开发中，setInheritRT方法的作用于线程调度策略相关。主要用于控制子线程是否继承父线程的实时（Real-time）调度属性。
Android AudioPolicy策略的实现过程分析（二）：CarAudioService和自定义音频焦点策略
u012773843的博客
04-20 4791
摘要： Android系统中与Automotive相关的代码会被编译成一个名为CarService的apk存在于车机中，CarService中包括了众多和Car功能相关的Service，其中就包括CarAudioService。CarAudioService在初始化时会获取系统的音频策略配置参数并试图构造并注册AudioPolicy类，AudioPolicy.java是Java层音频策略的总设计图，其描述了总体音频策略，其中音频焦点策略可以通过setAudioPolicyFocusListener设置 .
Android9.0CarAudio分析之而AUDIO_DEVICE_OUT_BUS
l328873524的博客
11-10 6086
最近这几年一直从事车载相关的开发，国内一般车载项目使用最多的系统目前基本应该就是Andoid了，尤其新兴的一些新能源汽车基本搭载的车载系统都是基于Android深度定制的。其实谷歌也搞了套车载东西，今天我们继续说说与汽车相关的 Android的音频架构。 正题 上一篇分析了CarAudioService的启动过程，今天继续，先分析下CarAudioService的init过程 ...
Android 中设置线程优先级的正确方式（2种方法）
热门推荐
卜大爷的博客
12-03 3万+
Android 中设置线程优先级的正确方式（2种方法） 在 Android 中，有两种常见的设置线程优先级的方式： 第一种，使用 Thread 类实例的 setPriority 方法，来设置线程优先级。 第二种，使用 Process 类的 setThreadPriority 方法，来设置线程优先级。 这两种设置线程的优先级，一种是 Java 原生版本，另一种是 Android API 版本。这两种方式是不同的，Android 更推荐使用第二种方式。 使用 Thread 类的 setPriority 方
Android 线程的优先级
柚子君的博客
04-05 1078
Android可以在当前线程中调用Process.setThreadPriority来设置当前的线程优先级，如下 Thread{ Process.setThreadPriority(Process.THREAD_PRIORITY_AUDIO) }.start() 看一下这个方法的注释 /** * Set the priority of the calling thread, based on Linux priorities. See * {@link #s
【六】Android MediaPlayer整体架构源码分析 -【start请求播放处理流程】【Part 3】【02】
CloverLHao的博客
05-17 1554
承接上一章节分析：【六】Android MediaPlayer整体架构源码分析 -【start请求播放处理流程】【Part 3】【01】 本系列文章分析的安卓源码版本：【Android 10.0 版本】 【此章节小节编号就接着上一章节排列】 10.1.1、new Decoder(notify, mSource, mPID, mUID, mRenderer, mSurface, mCCDecoder)实现分析： 创建新的视频解码器。这几个参数前面章节已分析过。 Decoder类声明：【省略其他代码】 // [
audio_policy_configuration.xml文件解析
jackzhouyu的专栏
12-16 1万+
audio_policy_configuration.xml文件解析 简介 audio音频数据从一个源走到一个目的都是需要根据配置文件来决定，所以理解configuration配置文件中各个标签项转化为c++实体类的及各成员至关重要，本文先直接给出各标签和对应实体类的结果，后再简单分析其解析过程 audio_policy_configuration.xml文件对应C++实体类 configuration文件(audio_policy_configuration的缩写)为音频audio的设备、流以及路由等配
AIDL和HIDL的AudioHal对比
最新发布
叶辞树的博客
08-26 981
HIDL 定义AIDL 定义Types.halFlags.aidlHIDL API 接口AIDL API 接口。
Android 14 Audio模块 音量增益 framework到HAL 层加载流程
qq_41751728的博客
06-05 5180
平时在音频设备或软件中设置的音量（比如1-100的范围）通常是一个相对的量度，用于提供给用户一个直观的方式来控制音频输出的响度。），因此查看AudioPolicyInterfaceImpl.cpp中的实现，由此可以AudioPolicyInterfaceImpl实现了AudioPolicyService.中的一部分函数。在设备开机的过程中，需要设置用户关机前的音量，因此在开机时可获取当前音量值去设置某个端口的音量增益，来达到设备开机后的音量记忆。aps的赋值为AudioPolicyService实例。
Android Binder调用的优先级
LiuYong_01的博客
03-25 1520
在Android系统中，Binder是进程间通信（IPC）的核心机制。Binder调用涉及优先级继承（Priority Inheritance），这是一种解决优先级反转问题的机制。优先级反转是指高优先级任务因为等待低优先级任务持有的资源而被阻塞，而低优先级任务又因为中等优先级任务的抢占而无法释放资源，从而导致高优先级任务长时间无法执行。
Android audio_policy_configuration.xml加载流程
123的专栏
04-21 1683
route是把deviceport和mixport连接起来的路由，数据由一个stream输出到另一个device，或者从一个device输出到另一个stream。mixport内部的Profile标签对应的C++类AudioProfile 如下。devicePort标签可以理解为一个device设备，设备也分output和input，以type中的关键字“IN”和“OUT”进行区分。同MixPort一样，devicePort也会解析内部的profile标签，创建新的AudioProfile。
Android系统音频模块-Native层初始化工作
Nipuream
08-06 2857
Android系统音频模块-Native层初始化工作 在前面一篇的文章中，我们知道了音频模块Java层所做的一些事情，总的来说还是比较简单的，下面我们继续学习和探索Native层中系统做了什么工作，首先先简单介绍下，Native层采用了C/S的架构方式，AudioTrack是属于Client端的，AudioFlinger和AudioPolicyService是属于服务端的，AudioFlinge...
Android音频系统之音量控制详解（Android 5.1）
achina2011jy的博客
12-03 5293
一、引言： Android的音量控制是典型的audiopolicy和audioflinger协作的例子，博文针对音量调节进行详细的解析.音量控制主要分成两大部分，一部分是java层完成的操作，用于响应音量调节，记录音量值，更新UI等操作，另一部分是native层完成，用于计算音量并执行。需要提一句的是，音量控制是设备厂商的适配重点，通常分为软音量和硬件音量，所谓软音量，就是Android原生针对a...
Android中关于cpu/cpuset/schedtune的应用
weixin_33817333的博客
12-27 916
Android中关于cpu/cpuset/schedtune的应用都是基于进程优先级的，根据不同优先级划分进程类型。AMS(ActivityManagerService)和PMS(PackageManagerService)等通过class Process设置进程优先级、调度策略等；android/osProcess JNI通过调用libcutils.so/libutils.so执行getprio...
深入剖析Android音频之AudioPolicyService
深入剖析Android系统
09-23 3万+
AudioPolicyService是策略的制定者，比如什么时候打开音频接口设备、某种Stream类型的音频对应什么设备等等。而AudioFlinger则是策略的执行者，例如具体如何与音频设备通信，如何维护现有系统中的音频设备，以及多个音频流的混音如何处理等等都得由它来完成。AudioPolicyService根据用户配置来指导AudioFlinger加载设备接口，起到路由功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值