Android 11 Audio音频系统配置文件解析

于 2024-05-28 18:43:54 发布
阅读量1k 收藏 12
点赞数 18
分类专栏： Android 音频系统 文章标签： android audio config 配置文件解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littleyards/article/details/139266892
版权

在AudioPolicyService的启动过程中，会去创建AudioPolicyManager对象，进而去解析配置文件

//frameworks/av/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
AudioPolicyManager::AudioPolicyManager(AudioPolicyClientInterface *clientInterface)
        : AudioPolicyManager(clientInterface, false /*forTesting*/)
{
    loadConfig();
}

loadConfig

//frameworks/av/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
void AudioPolicyManager::loadConfig() {
    if (deserializeAudioPolicyXmlConfig(getConfig()) != NO_ERROR) {
        ALOGE("could not load audio policy configuration file, setting defaults");
        getConfig().setDefault();
    }
}

deserializeAudioPolicyXmlConfig

//frameworks/av/services/audiopolicy/managerdefault/AudioPolicyManager.cpp
static status_t deserializeAudioPolicyXmlConfig(AudioPolicyConfig &config) {
    char audioPolicyXmlConfigFile[AUDIO_POLICY_XML_CONFIG_FILE_PATH_MAX_LENGTH];
    std::vector<const char*> fileNames;
    status_t ret;
    //省略
    fileNames.push_back(AUDIO_POLICY_XML_CONFIG_FILE_NAME);//AUDIO_POLICY_XML_CONFIG_FILE_NAME:audio_policy_configuration.xml

    for (const char* fileName : fileNames) {
        for (const auto& path : audio_get_configuration_paths()) {
            snprintf(audioPolicyXmlConfigFile, sizeof(audioPolicyXmlConfigFile),
                     "%s/%s", path.c_str(), fileName);
            ret = deserializeAudioPolicyFile(audioPolicyXmlConfigFile, &config);//1
            if (ret == NO_ERROR) {
                config.setSource(audioPolicyXmlConfigFile);
                return ret;
            }
        }
    }
    return ret;
}

audio_get_configuration_paths返回的路径为“/odm/etc”， “/vendor/etc”，“/system/etc” 。然后遍历这些路径，找到audio_policy_configuration.xml文件，然后调用注释1处的deserializeAudioPolicyFile来解析这个文件

deserializeAudioPolicyFile

//frameworks/av/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
status_t deserializeAudioPolicyFile(const char *fileName, AudioPolicyConfig *config)
{
    PolicySerializer serializer;
    return serializer.deserialize(fileName, config);
}

PolicySerializer::deserialize

//frameworks/av/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
status_t PolicySerializer::deserialize(const char *configFile, AudioPolicyConfig *config)
{
    auto doc = make_xmlUnique(xmlParseFile(configFile));
    
    xmlNodePtr root = xmlDocGetRootElement(doc.get());
   
   	//省略：对文件的合法性进行效验
   	
    // Lets deserialize children
    // Modules
    ModuleTraits::Collection modules;
    status_t status = deserializeCollection<ModuleTraits>(root, &modules, config);//1
    if (status != NO_ERROR) {
        return status;
    }
    //设置mHwModules
    config->setHwModules(modules);

	//省略

    return android::OK;
}

注释1处，开始解析配置文件中的modules标签。注意modules类型为 ModuleTraits::Collection

//frameworks/av/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
template <class Trait>
status_t deserializeCollection(const xmlNode *cur,
        typename Trait::Collection *collection,
        typename Trait::PtrSerializingCtx serializingContext)
{
    for (cur = cur->xmlChildrenNode; cur != NULL; cur = cur->next) {
        const xmlNode *child = NULL;
        if (!xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(Trait::collectionTag))) {
            child = cur->xmlChildrenNode;
        } else if (!xmlStrcmp(cur->name, reinterpret_cast<const xmlChar*>(Trait::tag))) {
            child = cur;
        }
        for (; child != NULL; child = child->next) {
            if (!xmlStrcmp(child->name, reinterpret_cast<const xmlChar*>(Trait::tag))) {
                auto element = Trait::deserialize(child, serializingContext);//1
                if (element.isOk()) {
                    status_t status = Trait::addElementToCollection(element, collection);//添加元素
                } else {
                    return BAD_VALUE;
                }
            }
        }
    }
    return NO_ERROR;
}

注释1处，针对不同的Trait类型，就调用不同的子类的deserialize处理。对于modules标签，调用ModuleTraits的deserialize处理。

ModuleTraits::deserialize

//frameworks/av/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
Return<ModuleTraits::Element> ModuleTraits::deserialize(const xmlNode *cur, PtrSerializingCtx ctx)
{
	std::string name = getXmlAttribute(cur, Attributes::name);//得到名字,如：primary

	Element module = new HwModule(name.c_str(), versionMajor, versionMinor);//创建HwModule对象
	
	//开始解析mixPorts标签
	MixPortTraits::Collection mixPorts;
    status_t status = deserializeCollection<MixPortTraits>(cur, &mixPorts, NULL);
    module->setProfiles(mixPorts);
    //开始解析devicePorts标签
    DevicePortTraits::Collection devicePorts;
    status = deserializeCollection<DevicePortTraits>(cur, &devicePorts, NULL);
    module->setDeclaredDevices(devicePorts);
    //开始解析routes标签
    RouteTraits::Collection routes;
    status = deserializeCollection<RouteTraits>(cur, &routes, module.get());
    module->setRoutes(routes);
    //开始解析attachedDevices标签
    for (const xmlNode *children = cur->xmlChildrenNode; children != NULL;
         children = children->next) {
        if (!xmlStrcmp(children->name, reinterpret_cast<const xmlChar*>(childAttachedDevicesTag))) {
            for (const xmlNode *child = children->xmlChildrenNode; child != NULL;
                 child = child->next) {
                if (!xmlStrcmp(child->name, reinterpret_cast<const xmlChar*>(childAttachedDeviceTag))) {
                    auto attachedDevice = make_xmlUnique(xmlNodeListGetString(
                                    child->doc, child->xmlChildrenNode, 1));
                    if (attachedDevice != nullptr) {
                        sp<DeviceDescriptor> device = module->getDeclaredDevices().
                                getDeviceFromTagName(std::string(reinterpret_cast<const char*>(
                                                        attachedDevice.get())));
                        ctx->addDevice(device);
                    }
                }
            }
        }
	//开始解析defaultOutputDevice标签
	if (!xmlStrcmp(children->name,reinterpret_cast<const xmlChar*>(childDefaultOutputDeviceTag))) {
            auto defaultOutputDevice = make_xmlUnique(xmlNodeListGetString(
                            children->doc, children->xmlChildrenNode, 1));
            if (defaultOutputDevice != nullptr) {
                sp<DeviceDescriptor> device = module->getDeclaredDevices().getDeviceFromTagName(
                        std::string(reinterpret_cast<const char*>(defaultOutputDevice.get())));
                if (device != 0 && ctx->getDefaultOutputDevice() == 0) {
                    ctx->setDefaultOutputDevice(device);
                }
            }
        }
}

解析mixPorts标签

//vendor/etc/audio_policy_configuration.xml
<mixPorts>
                <mixPort name="primary output" role="source" flags="AUDIO_OUTPUT_FLAG_PRIMARY">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="44100,48000" channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </mixPort>
                <mixPort name="spdif_passthrough" role="source" flags="AUDIO_OUTPUT_FLAG_DIRECT">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="32000,44100,48000"
                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                    <profile name="" format="AUDIO_FORMAT_IEC61937"
                             samplingRates="32000,44100,48000"
                             channelMasks="AUDIO_CHANNEL_OUT_STEREO"/>
                </mixPort>
                <mixPort name="hdmi" role="source" flags="AUDIO_OUTPUT_FLAG_DIRECT">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="32000,44100,48000,96000,176400,192000"
                             channelMasks="AUDIO_CHANNEL_OUT_STEREO,AUDIO_CHANNEL_OUT_QUAD,AUDIO_CHANNEL_OUT_5POINT1,AUDIO_CHANNEL_OUT_7POINT1"/>
                    <profile name="" format="AUDIO_FORMAT_IEC61937"
                             samplingRates="32000,44100,48000,96000,176400,192000"
                             channelMasks="AUDIO_CHANNEL_OUT_STEREO,AUDIO_CHANNEL_OUT_QUAD,AUDIO_CHANNEL_OUT_5POINT1,AUDIO_CHANNEL_OUT_7POINT1"/>
                    <profile name=""/>
                </mixPort>
                <mixPort name="primary input" role="sink">
                    <profile name="" format="AUDIO_FORMAT_PCM_16_BIT"
                             samplingRates="8000,11025,12000,16000,22050,24000,32000,44100,48000"
                             channelMasks="AUDIO_CHANNEL_IN_MONO,AUDIO_CHANNEL_IN_STEREO"/>
                </mixPort>
            </mixPorts>

对于mixPorts标签，会循环调用MixPortTraits的deserialize方法解析其子标签，也就是mixPort

//frameworks/av/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
Return<MixPortTraits::Element> MixPortTraits::deserialize(const xmlNode *child,
        PtrSerializingCtx /*serializingContext*/)
{
    std::string name = getXmlAttribute(child, Attributes::name);//得到名字：primary output，spdif_passthrough，hdmi,primary input
    
    std::string role = getXmlAttribute(child, Attributes::role);//sink或者source
  
    audio_port_role_t portRole = (role == Attributes::roleSource) ?
            AUDIO_PORT_ROLE_SOURCE : AUDIO_PORT_ROLE_SINK;

    Element mixPort = new IOProfile(name, portRole);//创建IOProfile对象

    AudioProfileTraits::Collection profiles;
    status_t status = deserializeCollection<AudioProfileTraits>(child, &profiles, NULL);//解析mixPort标签下的profile

    // The audio profiles are in order of listed in audio policy configuration file.
    // Sort audio profiles accroding to the format.
    sortAudioProfiles(profiles);
    mixPort->setAudioProfiles(profiles);//添加到mProfiles链表中

    //省略

根据解析mixPort得到的name和role 创建IOProfile对象，然后开始解析mixPort标签下的profile ，最后将解析结果添加到mProfiles链表中。来看一下profile 的解析

//frameworks/av/services/audiopolicy/common/managerdefinitions/src/Serializer.cpp
Return<AudioProfileTraits::Element> AudioProfileTraits::deserialize(const xmlNode *cur,
        PtrSerializingCtx /*serializingContext*/)
{
    std::string samplingRates = getXmlAttribute(cur, Attributes::samplingRates);//采样率
    std::string format = getXmlAttribute(cur, Attributes::format);//采样位数
    std::string channels = getXmlAttribute(cur, Attributes::channelMasks);//通道

    Element profile = new AudioProfile(formatFromString(format, gDynamicFormat),
            channelMasksFromString(channels, ","),
            samplingRatesFromString(samplingRates, ","));//创建AudioProfile对象

    profile->setDynamicFormat(profile->getFormat() == gDynamicFormat);
    profile->setDynamicChannels(profile->getChannels().empty());
    profile->setDynamicRate(profile->getSampleRates().empty());

    return profile;
}

该部分解析完成后，可得到以下结果：每个mixPort标签都会转化成IOProfile对象，mixPort标签下的profile，都会转化成AudioProfile对象，并将该对象添加到对应IOProfile的mProfiles链表。
回到modules的解析方法中，mixPorts标签解析完成后，调用HwModule的setProfiles保存解析的结果

//frameworks/av/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
void HwModule::setProfiles(const IOProfileCollection &profiles)
{
    for (size_t i = 0; i < profiles.size(); i++) {//遍历得到的IOProfile
        addProfile(profiles[i]);
    }
}

status_t HwModule::addProfile(const sp<IOProfile> &profile)
{
    switch (profile->getRole()) {
    case AUDIO_PORT_ROLE_SOURCE:
        return addOutputProfile(profile);
    case AUDIO_PORT_ROLE_SINK:
        return addInputProfile(profile);
    case AUDIO_PORT_ROLE_NONE:
        return BAD_VALUE;
    }
    return BAD_VALUE;
}

可以看出，对于role为sink的IOProfile，则添加到HwModule的mInputProfiles中，比如上面场景的primary input。对于role为source的IOProfile，则是添加到mOutputProfiles中，比如上面场景的primary output，hdmi等。比如针对上面的场景，经过解析之后可以得到以下信息
在这里插入图片描述
解析devicePorts标签

<devicePorts>
                <devicePort tagName="Speaker" type="AUDIO_DEVICE_OUT_SPEAKER" role="sink">
                </devicePort>
                <devicePort tagName="Wired Headset" type="AUDIO_DEVICE_OUT_WIRED_HEADSET" role="sink">
                </devicePort>
                <devicePort tagName="Wired Headphones" type="AUDIO_DEVICE_OUT_WIRED_HEADPHONE" role="sink">
                </devicePort>
                <devicePort tagName="BT SCO" type="AUDIO_DEVICE_OUT_BLUETOOTH_SCO" role="sink">
                </devicePort>
                <devicePort tagName="BT SCO Headset" type="AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET" role="sink">
                </devicePort>
                <devicePort tagName="BT SCO Car Kit" type="AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT" role="sink">
                </devicePort>
                <devicePort tagName="HDMI Out" type="AUDIO_DEVICE_OUT_AUX_DIGITAL" role="sink">
                </devicePort>
                <devicePort tagName="SPDIF Out" type="AUDIO_DEVICE_OUT_SPDIF" role="sink">
                </devicePort>

                <devicePort tagName="Built-In Mic" type="AUDIO_DEVICE_IN_BUILTIN_MIC" role="source">
                </devicePort>
                <devicePort tagName="Wired Headset Mic" type="AUDIO_DEVICE_IN_WIRED_HEADSET" role="source">
                </devicePort>
                <devicePort tagName="BT SCO Headset Mic" type="AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET" role="source">
                </devicePort>
                <devicePort tagName="HDMIIn" type="AUDIO_DEVICE_IN_HDMI" role="source">
                </devicePort>
            </devicePorts>

对于devicePorts标签，循环调用DevicePortTraits的deserialize来解析其子标签

Return<DevicePortTraits::Element> DevicePortTraits::deserialize(const xmlNode *cur,
        PtrSerializingCtx /*serializingContext*/)
{
    std::string name = getXmlAttribute(cur, Attributes::tagName);//得到名字：Speaker，Wired Headset等
   
    std::string typeName = getXmlAttribute(cur, Attributes::type);//得到类型
   
    std::string role = getXmlAttribute(cur, Attributes::role);//sink或者source
    
    audio_port_role_t portRole = (role == Attributes::roleSource) ?
                AUDIO_PORT_ROLE_SOURCE : AUDIO_PORT_ROLE_SINK;

    //省略
    
    Element deviceDesc = new DeviceDescriptor(type, name, address, encodedFormats);//创建DeviceDescriptor对象

    AudioProfileTraits::Collection profiles;
    status_t status = deserializeCollection<AudioProfileTraits>(cur, &profiles, NULL);//解析devicePort标签下的profile标签
  
    // The audio profiles are in order of listed in audio policy configuration file.
    // Sort audio profiles accroding to the format.
    sortAudioProfiles(profiles);
    deviceDesc->setAudioProfiles(profiles);
    //省略

首先解析得到name和type，然后创建DeviceDescriptor对象，最后也是解析profile标签并将得到的AudioProfile添加到对应的DeviceDescriptor对象的mProfiles链表中。解析完成后，回到ModuleTraits::deserialize函数中，调用HwModule的setDeclaredDevices保存解析的结果

//frameworks/av/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
void HwModule::setDeclaredDevices(const DeviceVector &devices)
{
    mDeclaredDevices = devices;//保存到mDeclaredDevices中
    for (size_t i = 0; i < devices.size(); i++) {
        mPorts.add(devices[i]);//保存到mPorts中
    }
}

最后将结果保存在HwModule的mDeclaredDevices和mPorts中。针对上面的场景，可以得到以下解析结果
在这里插入图片描述
解析routes标签

<routes>
                <route type="mix" sink="Speaker"
                       sources="primary output"/>
                <route type="mix" sink="Wired Headset"
                       sources="primary output"/>
                <route type="mix" sink="Wired Headphones"
                       sources="primary output"/>
                <route type="mix" sink="BT SCO"
                       sources="primary output"/>
                <route type="mix" sink="BT SCO Headset"
                       sources="primary output"/>
                <route type="mix" sink="BT SCO Car Kit"
                       sources="primary output"/>
                <route type="mix" sink="HDMI Out"
                       sources="primary output,hdmi"/>
                <route type="mix" sink="SPDIF Out"
                       sources="primary output,spdif_passthrough"/>

                <route type="mix" sink="primary input"
                       sources="Built-In Mic,Wired Headset Mic,BT SCO Headset Mic,HDMIIn"/>
            </routes>

对于routes下的子标签，调用RouteTraits的deserialize解析处理

Return<RouteTraits::Element> RouteTraits::deserialize(const xmlNode *cur, PtrSerializingCtx ctx)
{
    std::string type = getXmlAttribute(cur, Attributes::type);//解析type
   
    audio_route_type_t routeType = (type == Attributes::typeMix) ?
                AUDIO_ROUTE_MIX : AUDIO_ROUTE_MUX;

    Element route = new AudioRoute(routeType);//创建AudioRoute对象

    std::string sinkAttr = getXmlAttribute(cur, Attributes::sink);//解析sink
   
    sp<PolicyAudioPort> sink = ctx->findPortByTagName(sinkAttr);//根据解析得到的sink的名字，从ports链表中找到DeviceDescriptor
  
    route->setSink(sink);//将找到的DeviceDescriptor添加到AudioRoute的mSink中

    std::string sourcesAttr = getXmlAttribute(cur, Attributes::sources);//解析sources
    
    PolicyAudioPortVector sources;
    std::unique_ptr<char[]> sourcesLiteral{strndup(
                sourcesAttr.c_str(), strlen(sourcesAttr.c_str()))};
    char *devTag = strtok(sourcesLiteral.get(), ",");
    while (devTag != NULL) {
        if (strlen(devTag) != 0) {
            sp<PolicyAudioPort> source = ctx->findPortByTagName(devTag);//根据source，可以找到对应的IOProfile
           
            sources.add(source);
        }
        devTag = strtok(NULL, ",");
    }

   sink->addRoute(route);//将该route添加到sink的mRoutes链表中
    for (size_t i = 0; i < sources.size(); i++) {
        sp<PolicyAudioPort> source = sources.itemAt(i);
        source->addRoute(route);//将该route添加到source的mRoutes链表中
    }
    route->setSources(sources);//将source添加到AudioRoute的mSources中
    return route;
 }

该方法主要是解析sink和source，然后根据其名字，分别找到对应的PolicyAudioPort，设置AudioRoute的mSink和mSources。回到ModuleTraits::deserialize函数中，调用HwModule的setRoutes保存解析的结果

//frameworks/av/services/audiopolicy/common/managerdefinitions/src/HwModule.cpp
void HwModule::setRoutes(const AudioRouteVector &routes)
{
    mRoutes = routes;//将结果保存在mRoutes 中
    // Now updating the streams (aka IOProfile until now) supported devices
    refreshSupportedDevices();
}

主要是将解析的结果，保存在HwModule的mRoutes 中。针对以上场景，可以得到如下结果
在这里插入图片描述
解析attachedDevices标签

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

attachedDevices标签的解析，就在ModuleTraits::deserialize函数中

for (const xmlNode *children = cur->xmlChildrenNode; children != NULL;
         children = children->next) {
        if (!xmlStrcmp(children->name, reinterpret_cast<const xmlChar*>(childAttachedDevicesTag))) {
            ALOGV("%s: %s %s found", __func__, tag, childAttachedDevicesTag);
            for (const xmlNode *child = children->xmlChildrenNode; child != NULL;
                 child = child->next) {
                if (!xmlStrcmp(child->name,
                                reinterpret_cast<const xmlChar*>(childAttachedDeviceTag))) {
                    auto attachedDevice = make_xmlUnique(xmlNodeListGetString(
                                    child->doc, child->xmlChildrenNode, 1));
                    if (attachedDevice != nullptr) {
                        sp<DeviceDescriptor> device = module->getDeclaredDevices().
                                getDeviceFromTagName(std::string(reinterpret_cast<const char*>(
                                                        attachedDevice.get())));//从mDeclaredDevices 链表中根据名字找到DeviceDescriptor
                        ctx->addDevice(device);//更加type类型，分别添加到AudioPolicyConfig的mOutputDevices和mInputDevices中
                    }
                }
            }
        }

来看一下addDevice方法

///frameworks/av/services/audiopolicy/common/managerdefinitions/include/AudioPolicyConfig.h
  void addDevice(const sp<DeviceDescriptor> &device)
    {
        if (audio_is_output_device(device->type())) {
            mOutputDevices.add(device);
        } else if (audio_is_input_device(device->type())) {
            mInputDevices.add(device);
        }
    }

解析defaultOutputDevice标签

<defaultOutputDevice>Speaker</defaultOutputDevice>

对于该标签的解析比较简单，主要从mDeclaredDevices 链表中根据名字找到对应的DeviceDescriptor，然后将其赋值给AudioPolicyConfig的mDefaultOutputDevice成员

回到PolicySerializer::deserialize方法，当moudles解析完成后，会将解析得到的HwModule保存在AudioPolicyConfig的mHwModules中

//frameworks/av/services/audiopolicy/common/managerdefinitions/include/AudioPolicyConfig.h
 void setHwModules(const HwModuleCollection &hwModules)
    {
        mHwModules = hwModules;
    }

总结

  1. 解析mixPorts标签，每个mixPort子项，都会构建一个IOProfile对象，对于mixPort标签下的每个profile项，都会构建一个AudioProfile对象，并将AudioProfile对象放到对应IOProfile对象的mProfiles中。最后这些IOProfile对象，根据type类型，分别添加到HwModule的mOutputProfiles和mInputProfiles中。并且这些IOProfile也会添加到HwModule的mPorts中
  2. 解析devicePorts标签，每个devicePort都会创建DeviceDescriptor对象，最后这些DeviceDescriptor都会添加到HwModule的mDeclaredDevices和mPorts中
  3. 解析routes标签，对每个route，都会创建AudioRoute对象。分别根据sink和source的名字，从前面得到的mPorts中找到对应项，设置AudioRoute的mSink和mSource，最后将这些AudioRoute添加到HwModule的mRoutes中
  4. AudioPolicyConfig 有几个成员
HwModuleCollection &mHwModules; /**< Collection of Module, with Profiles, i.e. Mix Ports. */
DeviceVector &mOutputDevices;
DeviceVector &mInputDevices;
sp<DeviceDescriptor> &mDefaultOutputDevice;

其中mHwModules保存的是modules标签下的每个HwModule，解析attachedDevices标签时，会根据其名字找到对应的DeviceDescriptor，然后根据这些DeviceDescriptor的type，分别放入mOutputDevices和mInputDevices中。解析defaultOutputDevice标签时，根据名字找到对应的DeviceDescriptor，然后保存在mDefaultOutputDevice中

Kbattery
关注
  • 18
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android audio篇章（1）------Audio架构
DADWAWFMA的博客
08-20 6297
在弄清楚了Audio的软件架构之后，对后面的分层次的理解、学习是不可或缺的，但是呢，前提可能看不大明白，大致有个印象就可以了，等后面在接触一段时间，回过头来在看一下，就会发现软件框架的更多巧妙之处。
Android中Audio框架
w512的专栏
11-06 2047
Android中的音频硬件抽象层（HAL）连接android.media中高层的，特定音频框架API到底层的音频驱动和硬件 下列图表描述了音频功能是如何实现的，以及相关实现的相关源代码。 应用框架(Application framework) 在应用框架层的是App代码，它利用android.media的API来和audio硬件交互，内部该代码调用相应的JNI
Android音频系统简介
yx811421582的专栏
04-21 2275
音频系统使用该属性进行音频焦点控制、音频通道路由及音量控制等，一般在应用开发中常用。
08.音频系统:第004课_Android音频系统详解:第007节_AudioPolicyManager堪误与回顾
江南才尽江南山，年少无知年少狂！
04-24 4202
上小节我们对AudioTrack创建作了一些概述，知道其大概会做如下事情： 1 使用AudioTrack的属性, 根据AudioPolicy找到对应的output、playbackThread 2 在playbackThread中创建对应的track 3 APP的AudioTrack 和 playbackThread的mTracks中的track之间建立共享内存 第一点 我们先来讲解第一点，应用程......
分析Android O的AudioPolicyService服务（一）
小伍的专栏
08-09 874
AudioPolicyManager.cpp:音频策略的管理类，也可以说是服务端； 分析createAudioPolicyManager函数的初始化； void AudioPolicyService::onFirstRef() { ....... mAudioPolicyManager = createAudioPolicyManager(mAudioPolicyClient); ........
安卓系统中音频模块的配置文件汇总
海豚的成长日记
12-17 3654
整个安卓设备的配置文件在system/etc/目录下，音频作为其中的一个子模块当然也包含在内，通过shell命令可以看到和下面类似的文件列表 msm8953_64:/system/etc $ ls IPACM_cfg.xml data init.qcom.bt.sh mixer_paths_mtp.xml ...
Audio解析strategy配置文件
xiaowang_lj的博客
08-28 297
audio_policy_configuration配置文件配置了音频Audio的设备、数据流信息，而strategy相关配置文件则配置某种streamType的音频使用哪种音量曲线，如voice_call和music他们的音量曲线是不一样，后者这种关系叫做strategy策略.奇怪，查看自己的手机Android11，发现没找到audio_policy_engine_configuration这个文件，难道阉割了吗？
Android 12 AudioFlinger 分析（RK3588）
03-12
在Android操作系统中，AudioFlinger是音频服务的核心组件，它负责处理音频的混合、路由、硬件交互以及与其他音频服务的协作。本分析将专注于在Android 12版本中，AudioFlinger在Rockchip RK3588处理器上的实现和优化...
Android-audio系统第一季
09-05
本文将基于“Android-audio系统第一季”的核心内容，详细解析Android音频系统中的关键组件——AudioManager、AudioTrack、AudioRecord以及AudioPolicyManager，探讨它们的功能、工作原理及相互之间的协同作用。...
android ffmpeg3.4.2 音频解码+opensles播放
03-22
FFmpeg是一个强大的开源多媒体处理框架，它提供了丰富的音频和视频编解码器，而OpenSL ES是Android系统中的低级音频API，用于高效、高质量的音频播放。 首先，让我们深入了解FFmpeg。FFmpeg库包含了一系列的工具和...
android audio system
11-29
最后，日志中提到了`audio_policy.conf`文件的重要性，这个文件用于描述音频系统的输入和输出设备，如果缺失或配置不正确，可能导致音频系统工作异常。 ### 总结 综上所述，Android音频系统是一个复杂但功能强大的...
安卓Android源码——AudioRecord.zip
10-11
这部分源码对于深入理解Android音频系统的工作流程至关重要。 总结来说，Android AudioRecord源码的学习涵盖音频录制的基本原理、参数配置、数据读取以及与硬件层的交互等多个方面。理解并掌握这部分知识，对于开发...
安卓系统文件夹详细结构及其文件解析
09-18
在这个文件夹中，我们可以找到许多系统配置文件，如 apns-conf.xml、hosts 等。这些文件都是 Android 操作系统的核心组件，它们提供了系统的配置信息。 4. \system\fonts 字体文件夹：除了标准字体和粗体、斜体外...
安卓系统文件夹结构及其文件解析(详细)
09-11
3. \system\etc：这个文件夹包含系统配置文件，如网络设置（APN）、Wi-Fi配置等。修改这里的文件可能会影响到系统功能，所以一般情况下不建议直接操作。 4. \system\fonts：系统字体文件夹，存放着设备使用的各种...
audio_policy_configuration.xml文件解析
jackzhouyu的专栏
12-16 9331
audio_policy_configuration.xml文件解析 简介 audio音频数据从一个源走到一个目的都是需要根据配置文件来决定，所以理解configuration配置文件中各个标签项转化为c++实体类的及各成员至关重要，本文先直接给出各标签和对应实体类的结果，后再简单分析其解析过程 audio_policy_configuration.xml文件对应C++实体类 configuration文件(audio_policy_configuration的缩写)为音频audio的设备、流以及路由等配
【Android Audio】4、音频设备管理 【基于Android Q 】
...
12-03 2298
4、音频设备管理 【基于Android Q 】 ​ audio policy xml里面有2种角色：source和sink，每种角色又分为devicePorts和mixPorts。 type为AUDIO_PORT_TYPE_DEVICE devicePorts(source)：为实际的硬件输入设备，对应安卓的role为AUDIO_PORT_ROLE_SOURCE ； devicePorts(sink)：为实际的硬件输出设备，对应安卓的role为AUDIO_PORT_ROLE_SINK ； type为AUDI
【Android Audio】Framework Audio 调试替换文件
...
08-04 691
编译：frameworks/base/services目录下mm -j替换：/system/framework/services.jar。
Android+studio音频文件解析完成的回调方法
最新发布
12-21
根据提供的引用内容，我无法找到关于Android Studio音频文件解析完成的回调方法的具体信息。但是，可以为您提供一些关于Android音频文件解析的基本知识和一般的解析方法。 在Android中，您可以使用MediaPlayer类来解析和播放音频文件。要监听音频文件解析完成的回调方法，您可以使用MediaPlayer的setOnCompletionListener()方法。这个方法允许您注册一个监听器，在音频文件解析完成时触发相应的回调方法。 以下是一个示例代码，演示了如何使用MediaPlayer和setOnCompletionListener()方法来监听音频文件解析完成的回调方法： ```java MediaPlayer mediaPlayer = new MediaPlayer(); mediaPlayer.setDataSource("path/to/your/audio/file.mp3"); mediaPlayer.prepareAsync(); mediaPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() { @Override public void onCompletion(MediaPlayer mp) { // 音频文件解析完成后的回调方法 // 在这里可以执行您想要的操作，例如播放下一个音频文件或显示一个提示消息等 } }); // 开始解析和播放音频文件 mediaPlayer.start(); ``` 请注意，上述代码中的"path/to/your/audio/file.mp3"应替换为您实际的音频文件路径。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值