AudioFlinger与AudioPoliceManager初始化流程

AF/APF启动流程

在启动AudioSeriver服务的过程中会对启动AF/APF。main_audioserver.cpp有如下代码：

    AudioFlinger::instantiate();AudioPolicyService::instantiate();

AF初始化流程

1.AudioFlinger::instantiate()

1.1 AudioFlinger构造函数

void AudioFlinger::instantiate() {sp<IServiceManager> sm(defaultServiceManager());sm->addService(String16(IAudioFlinger::DEFAULT_SERVICE_NAME),new AudioFlingerServerAdapter(new AudioFlinger()), false,IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT);
}

创建AudioFlingerServerAdapter对象，然后将AudioFlinger对象传入在AudioFlingerr中会调用onFirstRef()函数。

AudioFlinger::AudioFlinger() {mDevicesFactoryHal = DevicesFactoryHalInterface::create();mEffectsFactoryHal = EffectsFactoryHalInterface::create();
}

在AudioFlinger的构造函数中会创建DevicesFactoryHalInterface和EffectsFactoryHalInterface对象，DevicesFactoryHalInterface对象会调用HIDL的getDevicesFactory()函数，EffectsFactoryHalInterface对象会调用HIDL的getEffectsFactory()函数。
DevicesFactoryHalInterface.h：

sp<DevicesFactoryHalInterface> DevicesFactoryHalInterface::create() {return createPreferredImpl<DevicesFactoryHalInterface>("android.hardware.audio", "IDevicesFactory");
}

FactoryHalHidl.h

template <class Interface>
static sp<Interface> createPreferredImpl(const std::string& package, const std::string& interface) {return sp<Interface>{static_cast<Interface*>(detail::createPreferredImpl(package, interface))};
}
void* createPreferredImpl(const std::string& package, const std::string& interface) {for (auto version = detail::sAudioHALVersions; version != nullptr; ++version) {void* rawInterface = nullptr;if (hasHalService(package, *version, interface)&& createHalService(*version, interface, &rawInterface)) {return rawInterface;}}return nullptr;
}
const char* sAudioHALVersions[] = {"7.0","6.0","5.0","4.0",nullptr
};

函数hasHalService功能为将"android.hardware.audio"与sAudioHALVersions拼接从7.0开始循环，从serviceManager中查找是否存在当前的服务比如android.hardware.audio@7.0::IDevicesFactory当查到有相关的hidl接口那么就调用函数createHalService
createHalService功能如下：
1.拼接libName =“libaudiohal@”+7.0+“.so” factoryFunctionName = “create”+IDevicesFactory
2.dlopen打开库[e-mail]"
3.dlsym获取函数createIDevicesFactory
4.调用函数createIDevicesFactory
5.返回rawInterface
6.将rawInterface强转成IDevicesFactory类型
DevicesFactoryHalHybrid.cpp

extern "C" __attribute__((visibility("default"))) void* createIDevicesFactory() {auto service = hardware::audio::CPP_VERSION::IDevicesFactory::getService();return service ? new CPP_VERSION::DevicesFactoryHalHybrid(service) : nullptr;
}
DevicesFactoryHalHybrid::DevicesFactoryHalHybrid(sp<IDevicesFactory> hidlFactory): mLocalFactory(new DevicesFactoryHalLocal()),mHidlFactory(new DevicesFactoryHalHidl(hidlFactory)) {
}

函数DevicesFactoryHalHybrid功能如下：
1.创建DevicesFactoryHalLocal对象
2.创建DevicesFactoryHalHidl对象
3.将DevicesFactoryHalHidl对象传入DevicesFactoryHalLocal对象

1.2 AudioFlinger::onFirstRef解析

void AudioFlinger::onFirstRef()
{mMode = AUDIO_MODE_NORMAL;gAudioFlinger = this;  // we are already refcounted, store into atomic pointer.mDevicesFactoryHalCallback = new DevicesFactoryHalCallbackImpl;mDevicesFactoryHal->setCallbackOnce(mDevicesFactoryHalCallback);
}

1.3总结

• 启动入口：
  在AudioServer启动时，通过AudioFlinger::instantiate()和AudioPolicyService::instantiate()初始化AF和APF
  AudioFlinger初始化流程：

• 创建AudioFlingerServerAdapter，并传入AudioFlinger对象
  在AudioFlinger构造函数中创建两个关键对象：
  DevicesFactoryHalInterface：用于设备工厂
  EffectsFactoryHalInterface：用于音效工厂

• HAL层交互：
  通过createPreferredImpl函数查找合适的HAL版本（从7.0到4.0）[e-mail]
  使用hasHalService检查服务是否存在
  通过createHalService加载对应的.so库并获取工厂函数

• 设备工厂创建：
  最终创建DevicesFactoryHalHybrid对象
  该对象包含两个子工厂：
  DevicesFactoryHalLocal：本地工厂
  DevicesFactoryHalHidl：HIDL接口工厂

APM初始化流程

1.AudioPolicyService::instantiate()

AudioPolicyService::AudioPolicyService(): BnAudioPolicyService(),mAudioPolicyManager(NULL),mAudioPolicyClient(NULL),mPhoneState(AUDIO_MODE_INVALID),mCaptureStateNotifier(false),mCreateAudioPolicyManager(createAudioPolicyManager),mDestroyAudioPolicyManager(destroyAudioPolicyManager) {
}
void AudioPolicyService::onFirstRef()
{{Mutex::Autolock _l(mLock);// start audio commands threadmAudioCommandThread = new AudioCommandThread(String8("ApmAudio"), this);// start output activity command threadmOutputCommandThread = new AudioCommandThread(String8("ApmOutput"), this);mAudioPolicyClient = new AudioPolicyClient(this);loadAudioPolicyManager();mAudioPolicyManager = mCreateAudioPolicyManager(mAudioPolicyClient);}// load audio processing modulessp<AudioPolicyEffects> audioPolicyEffects = new AudioPolicyEffects();sp<UidPolicy> uidPolicy = new UidPolicy(this);sp<SensorPrivacyPolicy> sensorPrivacyPolicy = new SensorPrivacyPolicy(this);{Mutex::Autolock _l(mLock);mAudioPolicyEffects = audioPolicyEffects;mUidPolicy = uidPolicy;mSensorPrivacyPolicy = sensorPrivacyPolicy;}
#ifdef ESWIN_AOSP_ENHANCEMENTstd::thread notifier([=]() {ALOGI("onFirstRef registerSelf start.");uidPolicy->registerSelf();sensorPrivacyPolicy->registerSelf();ALOGI("onFirstRef registerSelf end.");});notifier.detach();
#endif /* ESWIN_AOSP_ENHANCEMENT */
}

1.1 createAudioPolicyManager

static AudioPolicyInterface* createAudioPolicyManager(AudioPolicyClientInterface *clientInterface)
{AudioPolicyManager *apm = new AudioPolicyManager(clientInterface);status_t status = apm->initialize();if (status != NO_ERROR) {delete apm;apm = nullptr;}return apm;
}

在函数createAudioPolicyManager中首先会调用AudioPolicyManager的构造函数，在构造函数中调用loadConfig这个函数的作用是解析audio_policy_configuration.xml。我们之后在分析,只需要知道之后时候xml解析结束。 然后调用initialize

1.1.1 AudioPolicyManager::initialize()

status_t AudioPolicyManager::initialize() {···onNewAudioModulesAvailableInt(nullptr /*newDevices*/);updateDevicesAndOutputs();···return status;
}

1.1.2 AudioPolicyManager::onNewAudioModulesAvailableInt()

这个函数很重要 做了很多工作

void AudioPolicyManager::onNewAudioModulesAvailableInt(DeviceVector *newDevices)
{//mHwModulesAll是xml文件中所有的mudule,mHwModules是已经加载的modulefor (const auto& hwModule : mHwModulesAll) {if (std::find(mHwModules.begin(), mHwModules.end(), hwModule) != mHwModules.end()) {continue;}//加载modulehwModule->setHandle(mpClientInterface->loadHwModule(hwModule->getName()));if (hwModule->getHandle() == AUDIO_MODULE_HANDLE_NONE) {ALOGW("could not open HW module %s", hwModule->getName());continue;}mHwModules.push_back(hwModule);// open all output streams needed to access attached devices// except for direct output streams that are only opened when they are actually// required by an app.// This also validates mAvailableOutputDevices listfor (const auto& outProfile : hwModule->getOutputProfiles()) {if (!outProfile->canOpenNewIo()) {ALOGE("Invalid Output profile max open count %u for profile %s",outProfile->maxOpenCount, outProfile->getTagName().c_str());continue;}else {ALOGE("valid Output profile max open count %u for profile %s",outProfile->maxOpenCount, outProfile->getTagName().c_str());}//hasSupportedDevices 都是 xml文件中可以根据route将device跟mixport配对上的if (!outProfile->hasSupportedDevices()) {ALOGW("Output profile contains no device on module %s", hwModule->getName());continue;}if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_TTS) != 0) {mTtsOutputAvailable = true;}const DeviceVector &supportedDevices = outProfile->getSupportedDevices();DeviceVector availProfileDevices = supportedDevices.filter(mOutputDevicesAll);sp<DeviceDescriptor> supportedDevice = 0;// 保存defaultOutputDevice标签内名字和devicePort标签的tagName相同，如Speakerif (supportedDevices.contains(mDefaultOutputDevice)) {supportedDevice = mDefaultOutputDevice;} else {// choose first device present in profile's SupportedDevices also part of// mAvailableOutputDevices.if (availProfileDevices.isEmpty()) {continue;}supportedDevice = availProfileDevices.itemAt(0);}//mOutputDevicesAll对应xml中的attachedDevicesif (!mOutputDevicesAll.contains(supportedDevice)) {continue;}//经过重重过滤其实只剩下speakersp<SwAudioOutputDescriptor> outputDesc = new SwAudioOutputDescriptor(outProfile,mpClientInterface);audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;//打开通路status_t status = outputDesc->open(nullptr, DeviceVector(supportedDevice),AUDIO_STREAM_DEFAULT,AUDIO_OUTPUT_FLAG_NONE, &output);if (status != NO_ERROR) {ALOGW("Cannot open output stream for devices %s on hw module %s",supportedDevice->toString().c_str(), hwModule->getName());continue;} else{ALOGE(" open output stream for devices %s on hw module %s",supportedDevice->toString().c_str(), hwModule->getName());}for (const auto &device : availProfileDevices) {// give a valid ID to an attached device once confirmed it is reachableif (!device->isAttached()) {device->attach(hwModule);mAvailableOutputDevices.add(device);device->setEncapsulationInfoFromHal(mpClientInterface);if (newDevices) newDevices->add(device);setEngineDeviceConnectionState(device, AUDIO_POLICY_DEVICE_STATE_AVAILABLE);}}if (mPrimaryOutput == nullptr &&outProfile->getFlags() & AUDIO_OUTPUT_FLAG_PRIMARY) {mPrimaryOutput = outputDesc;}if ((outProfile->getFlags() & AUDIO_OUTPUT_FLAG_DIRECT) != 0) {outputDesc->close();} else {addOutput(output, outputDesc);setOutputDevices(outputDesc,DeviceVector(supportedDevice),true,0,NULL);}}// open input streams needed to access attached devices to validate// mAvailableInputDevices list···}
}

我们来总结一下onNewAudioModulesAvailableInt的功能：

1. 遍历所有硬件模块（mHwModulesAll），检查是否已加载。
2. 从hwmodel中找到符合要求的outProfile，这一过程涉及四个变量
   • outProfile 这个变量是mixport
   • supportedDevice xml文件中可以根据route将device跟mixport配对上的
   • defaultOutputDevice xml中defaultOutputDevice对应的device
   • mOutputDevicesAll 对应xml中的attachedDevices
3. 遍历所有module下面的所有的outProfile，根据OutProfile找到支持的device，返回一个supportDevices ；
4. 通过mOutputDevicesAll（xml文件中的attrachDevices）过滤出有效的availProfileDevices；
5. 判断包不包含默认设备mDefaultOutputDevice(xml文件中的defaultOutputDevice)，如果包含，设置为默认设备；如果不包含，就设置为第一个设备。
6. 只设置支持当前输出设备的stream
   接下来我们分别loadHwModule、open

1.1.3 AudioPolicyManager::loadHwModule

loadHwModule会调用到AudioFlinger中的loadHwModule

audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
{Mutex::Autolock _l(mLock);AutoMutex lock(mHardwareLock);return loadHwModule_l(name);
}
audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name)
{for (size_t i = 0; i < mAudioHwDevs.size(); i++) {if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) {ALOGW("loadHwModule() module %s already loaded", name);return mAudioHwDevs.keyAt(i);}}sp<DeviceHalInterface> dev;int rc = mDevicesFactoryHal->openDevice(name, &dev);····AudioHwDevice *audioDevice = new AudioHwDevice(handle, name, dev, flags);if (strcmp(name, AUDIO_HARDWARE_MODULE_ID_PRIMARY) == 0) {mPrimaryHardwareDev = audioDevice;mHardwareStatus = AUDIO_HW_SET_MODE;mPrimaryHardwareDev->hwDevice()->setMode(mMode);mHardwareStatus = AUDIO_HW_IDLE;}mAudioHwDevs.add(handle, audioDevice);}

DevicesFactoryHalHybrid::openDevice

status_t DevicesFactoryHalHybrid::openDevice(const char *name, sp<DeviceHalInterface> *device) {if (mHidlFactory != 0 && strcmp(AUDIO_HARDWARE_MODULE_ID_A2DP, name) != 0 &&strcmp(AUDIO_HARDWARE_MODULE_ID_HEARING_AID, name) != 0) {return mHidlFactory->openDevice(name, device);}return mLocalFactory->openDevice(name, device);
}

这里要注意如果是A2DP就走本地的，如果不是走HIDL的。这里我们是speaker所以走mHidlFactory

status_t DevicesFactoryHalHidl::openDevice(const char *name, sp<DeviceHalInterface> *device) {auto factories = copyDeviceFactories();if (factories.empty()) return NO_INIT;status_t status;auto hidlId = idFromHal(name, &status);if (status != OK) return status;Result retval = Result::NOT_INITIALIZED;for (const auto& factory : factories) {Return<void> ret = factory->openDevice(hidlId,[&](Result r, const sp<IDevice>& result) {retval = r;if (retval == Result::OK) {*device = new DeviceHalHidl(result);}});}return BAD_VALUE;
}

DevicesFactory::openDevice

Return<void> DevicesFactory::openDevice(const hidl_string& moduleName, openDevice_cb _hidl_cb) {if (moduleName == AUDIO_HARDWARE_MODULE_ID_PRIMARY) {return openDevice<PrimaryDevice>(moduleName.c_str(), _hidl_cb);}return openDevice(moduleName.c_str(), _hidl_cb);
}

解析来的流程如图所示

1.1.4 AudioFlinger::loadHwModule总结

通过传参hwModule->getName()，如primary,通过拼接查询找到合适的audio.primary.xxx.so。，通过dlopen加载so，dlsym获取对应的对象，通过回调将对象返回。最后为AudioFlinger::loadHwModule_l中 sp dev赋值

1.2.1 SwAudioOutputDescriptor::open

status_t SwAudioOutputDescriptor::open(const audio_config_t *config,const DeviceVector &devices,audio_stream_type_t stream,audio_output_flags_t flags,audio_io_handle_t *output)
{···status_t status = mClientInterface->openOutput(mProfile->getModuleHandle(),output,&lConfig,device,&mLatency,mFlags);····
}status_t AudioFlinger::openOutput(const media::OpenOutputRequest& request,media::OpenOutputResponse* response)
{audio_io_handle_t output;···sp<ThreadBase> thread = openOutput_l(module, &output, &config, deviceType, address, flags);if (thread != 0) {if ((flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) == 0) {PlaybackThread *playbackThread = (PlaybackThread *)thread.get();latencyMs = playbackThread->latency();// notify client processes of the new output creationplaybackThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);// the first primary output opened designates the primary hw device if no HW module// named "primary" was already loaded.AutoMutex lock(mHardwareLock);if ((mPrimaryHardwareDev == nullptr) && (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {ALOGI("Using module %d as the primary audio interface", module);.mPrimaryHardwareDev = playbackThread->getOutput()->audioHwDev;mHardwareStatus = AUDIO_HW_SET_MODE;mPrimaryHardwareDev->hwDevice()->setMode(mMode);mHardwareStatus = AUDIO_HW_IDLE;}} else {MmapThread *mmapThread = (MmapThread *)thread.get();mmapThread->ioConfigChanged(AUDIO_OUTPUT_OPENED);}response->output = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));response->config = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_config_t_AudioConfig(config));response->latencyMs = VALUE_OR_RETURN_STATUS(convertIntegral<int32_t>(latencyMs));response->flags = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_output_flags_t_int32_t_mask(flags));return NO_ERROR;}}sp<AudioFlinger::ThreadBase> AudioFlinger::openOutput_l(audio_module_handle_t module,audio_io_handle_t *output,audio_config_t *config,audio_devices_t deviceType,const String8& address,audio_output_flags_t flags)
{//获取合适的AudioHwDevice,这个AudioHwDevice是在loadHwModule_l中创建的AudioHwDevice *outHwDev = findSuitableHwDev_l(module, deviceType);if (outHwDev == NULL) {return 0;}if (*output == AUDIO_IO_HANDLE_NONE) {*output = nextUniqueId(AUDIO_UNIQUE_ID_USE_OUTPUT);} else {// Audio Policy does not currently request a specific output handle.// If this is ever needed, see openInput_l() for example code.ALOGE("openOutput_l requested output handle %d is not AUDIO_IO_HANDLE_NONE", *output);return 0;}mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;···AudioStreamOut *outputStream = NULL;status_t status = outHwDev->openOutputStream(&outputStream,*output,deviceType,flags,config,address.string());mHardwareStatus = AUDIO_HW_IDLE;if (status == NO_ERROR) {if (flags & AUDIO_OUTPUT_FLAG_MMAP_NOIRQ) {sp<MmapPlaybackThread> thread =new MmapPlaybackThread(this, *output, outHwDev, outputStream, mSystemReady);mMmapThreads.add(*output, thread);ALOGD("openOutput_l() created mmap playback thread: ID %d thread %p",*output, thread.get());return thread;} else {sp<PlaybackThread> thread;if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {thread = new OffloadThread(this, outputStream, *output, mSystemReady);ALOGD("openOutput_l() created offload output: ID %d thread %p",*output, thread.get());} else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)|| !isValidPcmSinkFormat(config->format)|| !isValidPcmSinkChannelMask(config->channel_mask)) {thread = new DirectOutputThread(this, outputStream, *output, mSystemReady);ALOGD("openOutput_l() created direct output: ID %d thread %p",*output, thread.get());} else {//创建线程并且key是outputthread = new MixerThread(this, outputStream, *output, mSystemReady);ALOGD("openOutput_l() created mixer output: ID %d thread %p",*output, thread.get());}mPlaybackThreads.add(*output, thread);struct audio_patch patch;mPatchPanel.notifyStreamOpened(outHwDev, *output, &patch);if (thread->isMsdDevice()) {thread->setDownStreamPatch(&patch);}return thread;}}return 0;
}

1.2.2 openOutputStream解析

status_t AudioHwDevice::openOutputStream(AudioStreamOut **ppStreamOut,audio_io_handle_t handle,audio_devices_t deviceType,audio_output_flags_t flags,struct audio_config *config,const char *address)
{struct audio_config originalConfig = *config;AudioStreamOut *outputStream = new AudioStreamOut(this, flags);status_t status = outputStream->open(handle, deviceType, config, address);···*ppStreamOut = outputStream;return status;
}status_t AudioStreamOut::open(audio_io_handle_t handle,audio_devices_t deviceType,struct audio_config *config,const char *address)
{sp<StreamOutHalInterface> outStream;audio_output_flags_t customFlags = (config->format == AUDIO_FORMAT_IEC61937)? (audio_output_flags_t)(flags | AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO): flags;int status = hwDev()->openOutputStream(handle,deviceType,customFlags,config,address,&outStream);if (status == NO_ERROR) {stream = outStream;mHalFormatHasProportionalFrames = audio_has_proportional_frames(config->format);status = stream->getFrameSize(&mHalFrameSize);LOG_ALWAYS_FATAL_IF(status != OK, "Error retrieving frame size from HAL: %d", status);LOG_ALWAYS_FATAL_IF(mHalFrameSize <= 0, "Error frame size was %zu but must be greater than"" zero", mHalFrameSize);}return status;
}status_t DeviceHalHidl::openOutputStream(audio_io_handle_t handle,audio_devices_t deviceType,audio_output_flags_t flags,struct audio_config *config,const char *address,sp<StreamOutHalInterface> *outStream) {Return<void> ret = mDevice->openOutputStream(handle, hidlDevice, hidlConfig, hidlFlags,
#if MAJOR_VERSION >= 4{} /* metadata */,
#endif[&](Result r, const sp<IStreamOut>& result, const AudioConfig& suggestedConfig) {retval = r;if (retval == Result::OK) {*outStream = new StreamOutHalHidl(result);}HidlUtils::audioConfigToHal(suggestedConfig, config);});return processReturn("openOutputStream", ret, retval);
}

最终会调用到audio_hw.c中的函数adev_open_output_stream

static int adev_open_output_stream(struct audio_hw_device *dev,audio_io_handle_t handle,audio_devices_t devices,audio_output_flags_t flags,struct audio_config *config,struct audio_stream_out **stream_out,const char *address __unused) {*stream_out = NULL;struct esw_stream_out *out= (struct esw_stream_out *)calloc(1, sizeof(struct esw_stream_out));if (!out) {return -ENOMEM;}out->stream.common.get_sample_rate = out_get_sample_rate;out->stream.common.set_sample_rate = out_set_sample_rate;out->stream.common.get_buffer_size = out_get_buffer_size;out->stream.common.get_channels = out_get_channels;out->stream.common.get_format = out_get_format;out->stream.common.set_format = out_set_format;out->stream.common.standby = out_standby;out->stream.common.dump = out_dump;out->stream.common.set_parameters = out_set_parameters;out->stream.common.get_parameters = out_get_parameters;out->stream.common.add_audio_effect = out_add_audio_effect;out->stream.common.remove_audio_effect = out_remove_audio_effect;out->stream.get_latency = out_get_latency;out->stream.set_volume = out_set_volume;out->stream.write = out_write;out->stream.get_render_position = out_get_render_position;out->stream.pause = out_pause;out->stream.resume = out_resume;out->stream.drain = out_drain;out->stream.flush = out_flush;out->stream.get_next_write_timestamp = out_get_next_write_timestamp;out->sample_rate = config->sample_rate;out->paused = false;
···
}

到此我们已经已经打开了一个输出通道，音频数据流从这个通道流向某个设备，这个通道支持的sample_rate、format、channel是从xml解析出来的。
在AudioOutputDescriptor构造函数中调用PolicyAudioPort::pickChannelMask解析上述参数规则如下：
对于采样格式，精度越高优先级越高；对于通道掩码（通道数），如果是直接输出 (Direct Output)，则通道数越小优先级越高，否则，通道数越大优先级越高；对于采样率，如果是直接输出 (Direct Output)，则采样率越小优先级越高，否则，采样率越大优先级越高。

1.2.3 open流程总结

• 设备打开流程：
  从 SwAudioOutputDescriptor 发起请求，最终由 AudioFlinger 处理。
  通过 AudioHwDevice 打开硬件输出流。
  根据需求创建不同类型的音频线程。
• 线程类型：
  MixerThread：默认混音线程。
  DirectOutputThread：直接输出线程。
  OffloadThread：压缩音频输出线程。
  MmapPlaybackThread：低延迟 MMAP 线程。
• 主设备设置：
  如果打开的是主输出设备，会将其设置为主硬件设备，并更新硬件状态。
• 延迟与通知：
  计算并返回输出设备的延迟时间。
  通知客户端输出设备已打开。

参考文章

https://blog.csdn.net/qq_42364999/article/details/146414847?spm=1001.2014.3001.5501