blob: e976a8fe65d70772bbcf9aa127f59a41beb07793 [file] [log] [blame]
Shunkai Yaodca65ce2022-12-02 05:35:41 +00001/*
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Shunkai Yao51202502022-12-12 06:11:46 +000017#include <algorithm>
Shunkai Yao5c718342023-02-23 23:49:51 +000018#include <cstddef>
Shunkai Yao51202502022-12-12 06:11:46 +000019#include <cstdint>
Shunkai Yao5c718342023-02-23 23:49:51 +000020#include <iterator>
Shunkai Yao51202502022-12-12 06:11:46 +000021#include <memory>
Shunkai Yaodca65ce2022-12-02 05:35:41 +000022#define LOG_TAG "EffectsFactoryHalAidl"
23//#define LOG_NDEBUG 0
24
Shunkai Yao284bb0d2023-01-10 00:42:36 +000025#include <error/expected_utils.h>
Shunkai Yao8f6ad0f2023-04-18 23:14:25 +000026#include <aidl/android/media/audio/common/AudioStreamType.h>
Shunkai Yaodca65ce2022-12-02 05:35:41 +000027#include <android/binder_manager.h>
Shunkai Yao51202502022-12-12 06:11:46 +000028#include <media/AidlConversionCppNdk.h>
Shunkai Yaoa03533e2023-01-25 06:38:10 +000029#include <media/AidlConversionEffect.h>
Shunkai Yao284bb0d2023-01-10 00:42:36 +000030#include <system/audio.h>
Shunkai Yao007caf02023-05-17 00:52:54 +000031#include <system/audio_aidl_utils.h>
Shunkai Yaodca65ce2022-12-02 05:35:41 +000032#include <utils/Log.h>
33
Mikhail Naganovd8f24412024-03-20 18:15:42 -070034#include "AidlUtils.h"
Shunkai Yao51202502022-12-12 06:11:46 +000035#include "EffectBufferHalAidl.h"
36#include "EffectHalAidl.h"
Shunkai Yao5c718342023-02-23 23:49:51 +000037#include "EffectProxy.h"
Shunkai Yaodca65ce2022-12-02 05:35:41 +000038#include "EffectsFactoryHalAidl.h"
39
Shunkai Yao284bb0d2023-01-10 00:42:36 +000040using ::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid;
Shunkai Yao8f6ad0f2023-04-18 23:14:25 +000041using ::aidl::android::aidl_utils::statusTFromBinderStatus;
42using ::aidl::android::hardware::audio::effect::Descriptor;
43using ::aidl::android::hardware::audio::effect::IFactory;
44using ::aidl::android::hardware::audio::effect::Processing;
Shunkai Yao0a51cf92023-05-10 22:42:56 +000045using ::aidl::android::media::audio::common::AudioSource;
46using ::aidl::android::media::audio::common::AudioStreamType;
Shunkai Yao8f6ad0f2023-04-18 23:14:25 +000047using ::aidl::android::media::audio::common::AudioUuid;
Shunkai Yao007caf02023-05-17 00:52:54 +000048using ::android::audio::utils::toString;
Shunkai Yao8f6ad0f2023-04-18 23:14:25 +000049using ::android::base::unexpected;
50using ::android::detail::AudioHalVersionInfo;
Shunkai Yaodca65ce2022-12-02 05:35:41 +000051
52namespace android {
53namespace effect {
54
Shunkai Yao51202502022-12-12 06:11:46 +000055EffectsFactoryHalAidl::EffectsFactoryHalAidl(std::shared_ptr<IFactory> effectsFactory)
56 : mFactory(effectsFactory),
Shunkai Yao5c718342023-02-23 23:49:51 +000057 mHalVersion(AudioHalVersionInfo(
58 AudioHalVersionInfo::Type::AIDL,
59 [this]() {
60 int32_t majorVersion = 0;
61 return (mFactory && mFactory->getInterfaceVersion(&majorVersion).isOk())
62 ? majorVersion
63 : 0;
64 }())),
65 mHalDescList([this]() {
66 std::vector<Descriptor> list;
67 if (mFactory) {
68 mFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &list).isOk();
69 }
70 return list;
71 }()),
Shunkai Yao79f98742023-05-03 23:54:43 +000072 mProxyUuidDescriptorMap([this]() {
73 std::map<AudioUuid, std::vector<Descriptor>> proxyUuidMap;
Shunkai Yao5c718342023-02-23 23:49:51 +000074 for (const auto& desc : mHalDescList) {
Shunkai Yao5c718342023-02-23 23:49:51 +000075 if (desc.common.id.proxy.has_value()) {
76 const auto& uuid = desc.common.id.proxy.value();
Shunkai Yao79f98742023-05-03 23:54:43 +000077 if (proxyUuidMap.count(uuid) == 0) {
78 proxyUuidMap.insert({uuid, {desc}});
79 } else {
80 proxyUuidMap[uuid].emplace_back(desc);
Shunkai Yao5c718342023-02-23 23:49:51 +000081 }
Shunkai Yao5c718342023-02-23 23:49:51 +000082 }
83 }
Shunkai Yao79f98742023-05-03 23:54:43 +000084 return proxyUuidMap;
Shunkai Yao5c718342023-02-23 23:49:51 +000085 }()),
86 mProxyDescList([this]() {
87 std::vector<Descriptor> list;
Shunkai Yao79f98742023-05-03 23:54:43 +000088 for (const auto& proxy : mProxyUuidDescriptorMap) {
89 if (Descriptor desc;
90 EffectProxy::buildDescriptor(proxy.first /* uuid */,
91 proxy.second /* sub-effect descriptor list */,
92 &desc /* proxy descriptor */)
93 .isOk()) {
Shunkai Yao5c718342023-02-23 23:49:51 +000094 list.emplace_back(std::move(desc));
95 }
96 }
97 return list;
98 }()),
99 mNonProxyDescList([this]() {
100 std::vector<Descriptor> list;
101 std::copy_if(mHalDescList.begin(), mHalDescList.end(), std::back_inserter(list),
102 [](const Descriptor& desc) { return !desc.common.id.proxy.has_value(); });
103 return list;
104 }()),
Shunkai Yao8f6ad0f2023-04-18 23:14:25 +0000105 mEffectCount(mNonProxyDescList.size() + mProxyDescList.size()),
Shunkai Yao0a51cf92023-05-10 22:42:56 +0000106 mAidlProcessings([this]() -> std::vector<Processing> {
107 std::vector<Processing> processings;
108 if (!mFactory || !mFactory->queryProcessing(std::nullopt, &processings).isOk()) {
109 ALOGE("%s queryProcessing failed", __func__);
110 }
111 return processings;
112 }()) {
Shunkai Yao5c718342023-02-23 23:49:51 +0000113 ALOG_ASSERT(mFactory != nullptr, "Provided IEffectsFactory service is NULL");
114 ALOGI("%s with %zu nonProxyEffects and %zu proxyEffects", __func__, mNonProxyDescList.size(),
115 mProxyDescList.size());
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000116}
117
118status_t EffectsFactoryHalAidl::queryNumberEffects(uint32_t *pNumEffects) {
119 if (pNumEffects == nullptr) {
120 return BAD_VALUE;
121 }
Shunkai Yao51202502022-12-12 06:11:46 +0000122
Shunkai Yao5c718342023-02-23 23:49:51 +0000123 *pNumEffects = mEffectCount;
Shunkai Yao79f98742023-05-03 23:54:43 +0000124 ALOGD("%s %u non %zu proxyMap %zu proxyDesc %zu", __func__, *pNumEffects,
125 mNonProxyDescList.size(), mProxyUuidDescriptorMap.size(), mProxyDescList.size());
Shunkai Yao51202502022-12-12 06:11:46 +0000126 return OK;
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000127}
128
129status_t EffectsFactoryHalAidl::getDescriptor(uint32_t index, effect_descriptor_t* pDescriptor) {
Shunkai Yao51202502022-12-12 06:11:46 +0000130 if (pDescriptor == nullptr) {
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000131 return BAD_VALUE;
132 }
Shunkai Yao51202502022-12-12 06:11:46 +0000133
Shunkai Yao5c718342023-02-23 23:49:51 +0000134 if (index >= mEffectCount) {
135 ALOGE("%s index %d exceed max number %zu", __func__, index, mEffectCount);
Shunkai Yao51202502022-12-12 06:11:46 +0000136 return INVALID_OPERATION;
137 }
138
Shunkai Yao5c718342023-02-23 23:49:51 +0000139 if (index >= mNonProxyDescList.size()) {
140 *pDescriptor =
141 VALUE_OR_RETURN_STATUS(::aidl::android::aidl2legacy_Descriptor_effect_descriptor(
142 mProxyDescList.at(index - mNonProxyDescList.size())));
143 } else {
144 *pDescriptor =
145 VALUE_OR_RETURN_STATUS(::aidl::android::aidl2legacy_Descriptor_effect_descriptor(
146 mNonProxyDescList.at(index)));
147 }
Shunkai Yao51202502022-12-12 06:11:46 +0000148 return OK;
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000149}
150
Shunkai Yao51202502022-12-12 06:11:46 +0000151status_t EffectsFactoryHalAidl::getDescriptor(const effect_uuid_t* halUuid,
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000152 effect_descriptor_t* pDescriptor) {
Shunkai Yao5c718342023-02-23 23:49:51 +0000153 if (halUuid == nullptr) {
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000154 return BAD_VALUE;
155 }
Shunkai Yao51202502022-12-12 06:11:46 +0000156
Shunkai Yao5c718342023-02-23 23:49:51 +0000157 AudioUuid uuid =
158 VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid(*halUuid));
159 return getHalDescriptorWithImplUuid(uuid, pDescriptor);
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000160}
161
Shunkai Yao51202502022-12-12 06:11:46 +0000162status_t EffectsFactoryHalAidl::getDescriptors(const effect_uuid_t* halType,
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000163 std::vector<effect_descriptor_t>* descriptors) {
Shunkai Yao5c718342023-02-23 23:49:51 +0000164 if (halType == nullptr) {
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000165 return BAD_VALUE;
166 }
Shunkai Yao51202502022-12-12 06:11:46 +0000167
Shunkai Yao5c718342023-02-23 23:49:51 +0000168 AudioUuid type =
169 VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid(*halType));
170 return getHalDescriptorWithTypeUuid(type, descriptors);
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000171}
172
Shunkai Yao51202502022-12-12 06:11:46 +0000173status_t EffectsFactoryHalAidl::createEffect(const effect_uuid_t* uuid, int32_t sessionId,
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000174 int32_t ioId, int32_t deviceId __unused,
175 sp<EffectHalInterface>* effect) {
Shunkai Yao51202502022-12-12 06:11:46 +0000176 if (uuid == nullptr || effect == nullptr) {
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000177 return BAD_VALUE;
178 }
Shunkai Yao284bb0d2023-01-10 00:42:36 +0000179 if (sessionId == AUDIO_SESSION_DEVICE && ioId == AUDIO_IO_HANDLE_NONE) {
Shunkai Yao51202502022-12-12 06:11:46 +0000180 return INVALID_OPERATION;
181 }
Shunkai Yao284bb0d2023-01-10 00:42:36 +0000182 ALOGI("%s session %d ioId %d", __func__, sessionId, ioId);
183
Shunkai Yao5c718342023-02-23 23:49:51 +0000184 AudioUuid aidlUuid =
185 VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid(*uuid));
Shunkai Yao284bb0d2023-01-10 00:42:36 +0000186 std::shared_ptr<IEffect> aidlEffect;
Shunkai Yao5c718342023-02-23 23:49:51 +0000187 // Use EffectProxy interface instead of IFactory to create
188 const bool isProxy = isProxyEffect(aidlUuid);
189 if (isProxy) {
Shunkai Yao79f98742023-05-03 23:54:43 +0000190 aidlEffect = ndk::SharedRefBase::make<EffectProxy>(
191 aidlUuid, mProxyUuidDescriptorMap.at(aidlUuid) /* sub-effect descriptor list */,
192 mFactory);
193 mProxyList.emplace_back(std::static_pointer_cast<EffectProxy>(aidlEffect));
Shunkai Yao5c718342023-02-23 23:49:51 +0000194 } else {
195 RETURN_STATUS_IF_ERROR(
196 statusTFromBinderStatus(mFactory->createEffect(aidlUuid, &aidlEffect)));
197 }
Shunkai Yao284bb0d2023-01-10 00:42:36 +0000198 if (aidlEffect == nullptr) {
Shunkai Yao007caf02023-05-17 00:52:54 +0000199 ALOGE("%s failed to create effect with UUID: %s", __func__, toString(aidlUuid).c_str());
Shunkai Yao284bb0d2023-01-10 00:42:36 +0000200 return NAME_NOT_FOUND;
201 }
Shunkai Yao5c718342023-02-23 23:49:51 +0000202 Descriptor desc;
Shunkai Yao284bb0d2023-01-10 00:42:36 +0000203 RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aidlEffect->getDescriptor(&desc)));
204
Mikhail Naganov89c22e42023-06-14 15:49:59 -0700205 *effect = sp<EffectHalAidl>::make(mFactory, aidlEffect, sessionId, ioId, desc, isProxy);
Shunkai Yao51202502022-12-12 06:11:46 +0000206 return OK;
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000207}
208
209status_t EffectsFactoryHalAidl::dumpEffects(int fd) {
Shunkai Yao5c718342023-02-23 23:49:51 +0000210 status_t ret = OK;
211 // record the error ret and continue dump as many effects as possible
Shunkai Yao79f98742023-05-03 23:54:43 +0000212 for (const auto& proxy : mProxyList) {
213 if (status_t temp = BAD_VALUE; proxy && (temp = proxy->dump(fd, nullptr, 0)) != OK) {
214 ret = temp;
Shunkai Yao5c718342023-02-23 23:49:51 +0000215 }
216 }
217 RETURN_STATUS_IF_ERROR(mFactory->dump(fd, nullptr, 0));
218 return ret;
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000219}
220
221status_t EffectsFactoryHalAidl::allocateBuffer(size_t size, sp<EffectBufferHalInterface>* buffer) {
Shunkai Yao51202502022-12-12 06:11:46 +0000222 ALOGI("%s size %zu buffer %p", __func__, size, buffer);
Shunkai Yao51202502022-12-12 06:11:46 +0000223 return EffectBufferHalAidl::allocate(size, buffer);
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000224}
225
226status_t EffectsFactoryHalAidl::mirrorBuffer(void* external, size_t size,
227 sp<EffectBufferHalInterface>* buffer) {
Shunkai Yao51202502022-12-12 06:11:46 +0000228 ALOGI("%s extern %p size %zu buffer %p", __func__, external, size, buffer);
Shunkai Yao51202502022-12-12 06:11:46 +0000229 return EffectBufferHalAidl::mirror(external, size, buffer);
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000230}
231
232AudioHalVersionInfo EffectsFactoryHalAidl::getHalVersion() const {
Shunkai Yao51202502022-12-12 06:11:46 +0000233 return mHalVersion;
234}
235
Shunkai Yao5c718342023-02-23 23:49:51 +0000236status_t EffectsFactoryHalAidl::getHalDescriptorWithImplUuid(const AudioUuid& uuid,
237 effect_descriptor_t* pDescriptor) {
Shunkai Yao51202502022-12-12 06:11:46 +0000238 if (pDescriptor == nullptr) {
239 return BAD_VALUE;
240 }
Shunkai Yao51202502022-12-12 06:11:46 +0000241
Shunkai Yao5c718342023-02-23 23:49:51 +0000242 const auto& list = isProxyEffect(uuid) ? mProxyDescList : mNonProxyDescList;
243 auto matchIt = std::find_if(list.begin(), list.end(),
244 [&](const auto& desc) { return desc.common.id.uuid == uuid; });
245 if (matchIt == list.end()) {
Shunkai Yao007caf02023-05-17 00:52:54 +0000246 ALOGE("%s UUID not found in HAL and proxy list %s", __func__, toString(uuid).c_str());
Shunkai Yao849c56c2023-11-01 02:43:09 +0000247 return NAME_NOT_FOUND;
Shunkai Yao51202502022-12-12 06:11:46 +0000248 }
Shunkai Yao007caf02023-05-17 00:52:54 +0000249 ALOGI("%s UUID impl found %s", __func__, toString(uuid).c_str());
Shunkai Yao51202502022-12-12 06:11:46 +0000250
251 *pDescriptor = VALUE_OR_RETURN_STATUS(
252 ::aidl::android::aidl2legacy_Descriptor_effect_descriptor(*matchIt));
253 return OK;
254}
255
Shunkai Yao5c718342023-02-23 23:49:51 +0000256status_t EffectsFactoryHalAidl::getHalDescriptorWithTypeUuid(
Shunkai Yao51202502022-12-12 06:11:46 +0000257 const AudioUuid& type, std::vector<effect_descriptor_t>* descriptors) {
258 if (descriptors == nullptr) {
259 return BAD_VALUE;
260 }
Shunkai Yao5c718342023-02-23 23:49:51 +0000261
Shunkai Yao51202502022-12-12 06:11:46 +0000262 std::vector<Descriptor> result;
Shunkai Yao5c718342023-02-23 23:49:51 +0000263 std::copy_if(mNonProxyDescList.begin(), mNonProxyDescList.end(), std::back_inserter(result),
Shunkai Yao51202502022-12-12 06:11:46 +0000264 [&](auto& desc) { return desc.common.id.type == type; });
Shunkai Yao5c718342023-02-23 23:49:51 +0000265 std::copy_if(mProxyDescList.begin(), mProxyDescList.end(), std::back_inserter(result),
266 [&](auto& desc) { return desc.common.id.type == type; });
267 if (result.empty()) {
Shunkai Yao007caf02023-05-17 00:52:54 +0000268 ALOGW("%s UUID type not found in HAL and proxy list %s", __func__, toString(type).c_str());
Shunkai Yao51202502022-12-12 06:11:46 +0000269 return BAD_VALUE;
270 }
Shunkai Yao007caf02023-05-17 00:52:54 +0000271 ALOGI("%s UUID type found %zu \n %s", __func__, result.size(), toString(type).c_str());
Shunkai Yao51202502022-12-12 06:11:46 +0000272
273 *descriptors = VALUE_OR_RETURN_STATUS(
274 aidl::android::convertContainer<std::vector<effect_descriptor_t>>(
275 result, ::aidl::android::aidl2legacy_Descriptor_effect_descriptor));
276 return OK;
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000277}
278
Shunkai Yao5c718342023-02-23 23:49:51 +0000279bool EffectsFactoryHalAidl::isProxyEffect(const AudioUuid& uuid) const {
Shunkai Yao79f98742023-05-03 23:54:43 +0000280 return 0 != mProxyUuidDescriptorMap.count(uuid);
Shunkai Yao5c718342023-02-23 23:49:51 +0000281}
282
Shunkai Yao8f6ad0f2023-04-18 23:14:25 +0000283std::shared_ptr<const effectsConfig::Processings> EffectsFactoryHalAidl::getProcessings() const {
Shunkai Yao0a51cf92023-05-10 22:42:56 +0000284
285 auto getConfigEffectWithDescriptor =
286 [](const auto& desc) -> std::shared_ptr<const effectsConfig::Effect> {
287 effectsConfig::Effect effect = {.name = desc.common.name, .isProxy = false};
288 if (const auto uuid =
289 ::aidl::android::aidl2legacy_AudioUuid_audio_uuid_t(desc.common.id.uuid);
290 uuid.ok()) {
Shunkai Yaoe708d972023-06-29 01:39:54 +0000291 static_cast<effectsConfig::EffectImpl&>(effect).uuid = uuid.value();
Shunkai Yao0a51cf92023-05-10 22:42:56 +0000292 return std::make_shared<const effectsConfig::Effect>(effect);
293 } else {
294 return nullptr;
295 }
296 };
297
298 auto getConfigProcessingWithAidlProcessing =
299 [&](const auto& aidlProcess, std::vector<effectsConfig::InputStream>& preprocess,
300 std::vector<effectsConfig::OutputStream>& postprocess) {
301 if (aidlProcess.type.getTag() == Processing::Type::streamType) {
302 AudioStreamType aidlType =
303 aidlProcess.type.template get<Processing::Type::streamType>();
304 const auto type =
305 ::aidl::android::aidl2legacy_AudioStreamType_audio_stream_type_t(
306 aidlType);
307 if (!type.ok()) {
308 return;
309 }
310
311 std::vector<std::shared_ptr<const effectsConfig::Effect>> effects;
312 std::transform(aidlProcess.ids.begin(), aidlProcess.ids.end(),
313 std::back_inserter(effects), getConfigEffectWithDescriptor);
314 effectsConfig::OutputStream stream = {.type = type.value(),
315 .effects = std::move(effects)};
316 postprocess.emplace_back(stream);
317 } else if (aidlProcess.type.getTag() == Processing::Type::source) {
318 AudioSource aidlType =
319 aidlProcess.type.template get<Processing::Type::source>();
320 const auto type =
321 ::aidl::android::aidl2legacy_AudioSource_audio_source_t(aidlType);
322 if (!type.ok()) {
323 return;
324 }
325
326 std::vector<std::shared_ptr<const effectsConfig::Effect>> effects;
327 std::transform(aidlProcess.ids.begin(), aidlProcess.ids.end(),
328 std::back_inserter(effects), getConfigEffectWithDescriptor);
329 effectsConfig::InputStream stream = {.type = type.value(),
330 .effects = std::move(effects)};
331 preprocess.emplace_back(stream);
332 }
333 };
334
335 static std::shared_ptr<const effectsConfig::Processings> processings(
336 [&]() -> std::shared_ptr<const effectsConfig::Processings> {
337 std::vector<effectsConfig::InputStream> preprocess;
338 std::vector<effectsConfig::OutputStream> postprocess;
339 for (const auto& processing : mAidlProcessings) {
340 getConfigProcessingWithAidlProcessing(processing, preprocess, postprocess);
341 }
342
343 if (0 == preprocess.size() && 0 == postprocess.size()) {
344 return nullptr;
345 }
346
347 return std::make_shared<const effectsConfig::Processings>(
348 effectsConfig::Processings({.preprocess = std::move(preprocess),
349 .postprocess = std::move(postprocess)}));
350 }());
351
352 return processings;
Shunkai Yao8f6ad0f2023-04-18 23:14:25 +0000353}
354
Shunkai Yao0a51cf92023-05-10 22:42:56 +0000355// Return 0 for AIDL, as the AIDL interface is not aware of the configuration file.
Shunkai Yao8f6ad0f2023-04-18 23:14:25 +0000356::android::error::Result<size_t> EffectsFactoryHalAidl::getSkippedElements() const {
Shunkai Yao8f6ad0f2023-04-18 23:14:25 +0000357 return 0;
358}
359
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000360} // namespace effect
361
362// When a shared library is built from a static library, even explicit
363// exports from a static library are optimized out unless actually used by
364// the shared library. See EffectsFactoryHalEntry.cpp.
365extern "C" void* createIEffectsFactoryImpl() {
Mikhail Naganovd8f24412024-03-20 18:15:42 -0700366 return new effect::EffectsFactoryHalAidl(getServiceInstance<IFactory>("default"));
Shunkai Yaodca65ce2022-12-02 05:35:41 +0000367}
368
369} // namespace android