• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  /*
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  
17  #include <algorithm>
18  #include <set>
19  
20  #define LOG_TAG "AHAL_Module"
21  #include <aidl/android/media/audio/common/AudioInputFlags.h>
22  #include <aidl/android/media/audio/common/AudioOutputFlags.h>
23  #include <android-base/logging.h>
24  #include <android/binder_ibinder_platform.h>
25  #include <error/expected_utils.h>
26  
27  #include "core-impl/Configuration.h"
28  #include "core-impl/Module.h"
29  #include "core-impl/ModuleBluetooth.h"
30  #include "core-impl/ModulePrimary.h"
31  #include "core-impl/ModuleRemoteSubmix.h"
32  #include "core-impl/ModuleStub.h"
33  #include "core-impl/ModuleUsb.h"
34  #include "core-impl/SoundDose.h"
35  #include "core-impl/utils.h"
36  
37  using aidl::android::hardware::audio::common::frameCountFromDurationMs;
38  using aidl::android::hardware::audio::common::getFrameSizeInBytes;
39  using aidl::android::hardware::audio::common::isBitPositionFlagSet;
40  using aidl::android::hardware::audio::common::isValidAudioMode;
41  using aidl::android::hardware::audio::common::SinkMetadata;
42  using aidl::android::hardware::audio::common::SourceMetadata;
43  using aidl::android::hardware::audio::core::sounddose::ISoundDose;
44  using aidl::android::media::audio::common::AudioChannelLayout;
45  using aidl::android::media::audio::common::AudioDevice;
46  using aidl::android::media::audio::common::AudioDeviceType;
47  using aidl::android::media::audio::common::AudioFormatDescription;
48  using aidl::android::media::audio::common::AudioFormatType;
49  using aidl::android::media::audio::common::AudioInputFlags;
50  using aidl::android::media::audio::common::AudioIoFlags;
51  using aidl::android::media::audio::common::AudioMMapPolicy;
52  using aidl::android::media::audio::common::AudioMMapPolicyInfo;
53  using aidl::android::media::audio::common::AudioMMapPolicyType;
54  using aidl::android::media::audio::common::AudioMode;
55  using aidl::android::media::audio::common::AudioOffloadInfo;
56  using aidl::android::media::audio::common::AudioOutputFlags;
57  using aidl::android::media::audio::common::AudioPort;
58  using aidl::android::media::audio::common::AudioPortConfig;
59  using aidl::android::media::audio::common::AudioPortExt;
60  using aidl::android::media::audio::common::AudioProfile;
61  using aidl::android::media::audio::common::Boolean;
62  using aidl::android::media::audio::common::Int;
63  using aidl::android::media::audio::common::MicrophoneInfo;
64  using aidl::android::media::audio::common::PcmType;
65  
66  namespace aidl::android::hardware::audio::core {
67  
68  namespace {
69  
hasDynamicChannelMasks(const std::vector<AudioChannelLayout> & channelMasks)70  inline bool hasDynamicChannelMasks(const std::vector<AudioChannelLayout>& channelMasks) {
71      return channelMasks.empty() ||
72             std::all_of(channelMasks.begin(), channelMasks.end(),
73                         [](const auto& channelMask) { return channelMask == AudioChannelLayout{}; });
74  }
75  
hasDynamicFormat(const AudioFormatDescription & format)76  inline bool hasDynamicFormat(const AudioFormatDescription& format) {
77      return format == AudioFormatDescription{};
78  }
79  
hasDynamicSampleRates(const std::vector<int32_t> & sampleRates)80  inline bool hasDynamicSampleRates(const std::vector<int32_t>& sampleRates) {
81      return sampleRates.empty() ||
82             std::all_of(sampleRates.begin(), sampleRates.end(),
83                         [](const auto& sampleRate) { return sampleRate == 0; });
84  }
85  
isDynamicProfile(const AudioProfile & profile)86  inline bool isDynamicProfile(const AudioProfile& profile) {
87      return hasDynamicFormat(profile.format) || hasDynamicChannelMasks(profile.channelMasks) ||
88             hasDynamicSampleRates(profile.sampleRates);
89  }
90  
hasDynamicProfilesOnly(const std::vector<AudioProfile> & profiles)91  bool hasDynamicProfilesOnly(const std::vector<AudioProfile>& profiles) {
92      if (profiles.empty()) return true;
93      return std::all_of(profiles.begin(), profiles.end(), isDynamicProfile);
94  }
95  
findAudioProfile(const AudioPort & port,const AudioFormatDescription & format,AudioProfile * profile)96  bool findAudioProfile(const AudioPort& port, const AudioFormatDescription& format,
97                        AudioProfile* profile) {
98      if (auto profilesIt =
99                  find_if(port.profiles.begin(), port.profiles.end(),
100                          [&format](const auto& profile) { return profile.format == format; });
101          profilesIt != port.profiles.end()) {
102          *profile = *profilesIt;
103          return true;
104      }
105      return false;
106  }
107  
108  }  // namespace
109  
110  // static
createInstance(Type type,std::unique_ptr<Configuration> && config)111  std::shared_ptr<Module> Module::createInstance(Type type, std::unique_ptr<Configuration>&& config) {
112      switch (type) {
113          case Type::DEFAULT:
114              return ndk::SharedRefBase::make<ModulePrimary>(std::move(config));
115          case Type::R_SUBMIX:
116              return ndk::SharedRefBase::make<ModuleRemoteSubmix>(std::move(config));
117          case Type::STUB:
118              return ndk::SharedRefBase::make<ModuleStub>(std::move(config));
119          case Type::USB:
120              return ndk::SharedRefBase::make<ModuleUsb>(std::move(config));
121          case Type::BLUETOOTH:
122              return ndk::SharedRefBase::make<ModuleBluetooth>(std::move(config));
123      }
124  }
125  
126  // static
typeFromString(const std::string & type)127  std::optional<Module::Type> Module::typeFromString(const std::string& type) {
128      if (type == "default")
129          return Module::Type::DEFAULT;
130      else if (type == "r_submix")
131          return Module::Type::R_SUBMIX;
132      else if (type == "stub")
133          return Module::Type::STUB;
134      else if (type == "usb")
135          return Module::Type::USB;
136      else if (type == "bluetooth")
137          return Module::Type::BLUETOOTH;
138      return {};
139  }
140  
operator <<(std::ostream & os,Module::Type t)141  std::ostream& operator<<(std::ostream& os, Module::Type t) {
142      switch (t) {
143          case Module::Type::DEFAULT:
144              os << "default";
145              break;
146          case Module::Type::R_SUBMIX:
147              os << "r_submix";
148              break;
149          case Module::Type::STUB:
150              os << "stub";
151              break;
152          case Module::Type::USB:
153              os << "usb";
154              break;
155          case Module::Type::BLUETOOTH:
156              os << "bluetooth";
157              break;
158      }
159      return os;
160  }
161  
Module(Type type,std::unique_ptr<Configuration> && config)162  Module::Module(Type type, std::unique_ptr<Configuration>&& config)
163      : mType(type), mConfig(std::move(config)) {
164      populateConnectedProfiles();
165  }
166  
cleanUpPatch(int32_t patchId)167  void Module::cleanUpPatch(int32_t patchId) {
168      erase_all_values(mPatches, std::set<int32_t>{patchId});
169  }
170  
createStreamContext(int32_t in_portConfigId,int64_t in_bufferSizeFrames,std::shared_ptr<IStreamCallback> asyncCallback,std::shared_ptr<IStreamOutEventCallback> outEventCallback,StreamContext * out_context)171  ndk::ScopedAStatus Module::createStreamContext(
172          int32_t in_portConfigId, int64_t in_bufferSizeFrames,
173          std::shared_ptr<IStreamCallback> asyncCallback,
174          std::shared_ptr<IStreamOutEventCallback> outEventCallback, StreamContext* out_context) {
175      if (in_bufferSizeFrames <= 0) {
176          LOG(ERROR) << __func__ << ": " << mType << ": non-positive buffer size "
177                     << in_bufferSizeFrames;
178          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
179      }
180      auto& configs = getConfig().portConfigs;
181      auto portConfigIt = findById<AudioPortConfig>(configs, in_portConfigId);
182      const int32_t nominalLatencyMs = getNominalLatencyMs(*portConfigIt);
183      // Since this is a private method, it is assumed that
184      // validity of the portConfigId has already been checked.
185      const int32_t minimumStreamBufferSizeFrames =
186              calculateBufferSizeFrames(nominalLatencyMs, portConfigIt->sampleRate.value().value);
187      if (in_bufferSizeFrames < minimumStreamBufferSizeFrames) {
188          LOG(ERROR) << __func__ << ": " << mType << ": insufficient buffer size "
189                     << in_bufferSizeFrames << ", must be at least " << minimumStreamBufferSizeFrames;
190          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
191      }
192      const size_t frameSize =
193              getFrameSizeInBytes(portConfigIt->format.value(), portConfigIt->channelMask.value());
194      if (frameSize == 0) {
195          LOG(ERROR) << __func__ << ": " << mType
196                     << ": could not calculate frame size for port config "
197                     << portConfigIt->toString();
198          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
199      }
200      LOG(DEBUG) << __func__ << ": " << mType << ": frame size " << frameSize << " bytes";
201      if (frameSize > static_cast<size_t>(kMaximumStreamBufferSizeBytes / in_bufferSizeFrames)) {
202          LOG(ERROR) << __func__ << ": " << mType << ": buffer size " << in_bufferSizeFrames
203                     << " frames is too large, maximum size is "
204                     << kMaximumStreamBufferSizeBytes / frameSize;
205          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
206      }
207      const auto& flags = portConfigIt->flags.value();
208      if ((flags.getTag() == AudioIoFlags::Tag::input &&
209           !isBitPositionFlagSet(flags.get<AudioIoFlags::Tag::input>(),
210                                 AudioInputFlags::MMAP_NOIRQ)) ||
211          (flags.getTag() == AudioIoFlags::Tag::output &&
212           !isBitPositionFlagSet(flags.get<AudioIoFlags::Tag::output>(),
213                                 AudioOutputFlags::MMAP_NOIRQ))) {
214          StreamContext::DebugParameters params{mDebug.streamTransientStateDelayMs,
215                                                mVendorDebug.forceTransientBurst,
216                                                mVendorDebug.forceSynchronousDrain};
217          std::shared_ptr<ISoundDose> soundDose;
218          if (!getSoundDose(&soundDose).isOk()) {
219              LOG(ERROR) << __func__ << ": could not create sound dose instance";
220              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
221          }
222          StreamContext temp(
223                  std::make_unique<StreamContext::CommandMQ>(1, true /*configureEventFlagWord*/),
224                  std::make_unique<StreamContext::ReplyMQ>(1, true /*configureEventFlagWord*/),
225                  portConfigIt->format.value(), portConfigIt->channelMask.value(),
226                  portConfigIt->sampleRate.value().value, flags, nominalLatencyMs,
227                  portConfigIt->ext.get<AudioPortExt::mix>().handle,
228                  std::make_unique<StreamContext::DataMQ>(frameSize * in_bufferSizeFrames),
229                  asyncCallback, outEventCallback, mSoundDose.getInstance(), params);
230          if (temp.isValid()) {
231              *out_context = std::move(temp);
232          } else {
233              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
234          }
235      } else {
236          // TODO: Implement simulation of MMAP buffer allocation
237      }
238      return ndk::ScopedAStatus::ok();
239  }
240  
findConnectedDevices(int32_t portConfigId)241  std::vector<AudioDevice> Module::findConnectedDevices(int32_t portConfigId) {
242      std::vector<AudioDevice> result;
243      auto& ports = getConfig().ports;
244      auto portIds = portIdsFromPortConfigIds(findConnectedPortConfigIds(portConfigId));
245      for (auto it = portIds.begin(); it != portIds.end(); ++it) {
246          auto portIt = findById<AudioPort>(ports, *it);
247          if (portIt != ports.end() && portIt->ext.getTag() == AudioPortExt::Tag::device) {
248              result.push_back(portIt->ext.template get<AudioPortExt::Tag::device>().device);
249          }
250      }
251      return result;
252  }
253  
findConnectedPortConfigIds(int32_t portConfigId)254  std::set<int32_t> Module::findConnectedPortConfigIds(int32_t portConfigId) {
255      std::set<int32_t> result;
256      auto patchIdsRange = mPatches.equal_range(portConfigId);
257      auto& patches = getConfig().patches;
258      for (auto it = patchIdsRange.first; it != patchIdsRange.second; ++it) {
259          auto patchIt = findById<AudioPatch>(patches, it->second);
260          if (patchIt == patches.end()) {
261              LOG(FATAL) << __func__ << ": " << mType << ": patch with id " << it->second
262                         << " taken from mPatches "
263                         << "not found in the configuration";
264          }
265          if (std::find(patchIt->sourcePortConfigIds.begin(), patchIt->sourcePortConfigIds.end(),
266                        portConfigId) != patchIt->sourcePortConfigIds.end()) {
267              result.insert(patchIt->sinkPortConfigIds.begin(), patchIt->sinkPortConfigIds.end());
268          } else {
269              result.insert(patchIt->sourcePortConfigIds.begin(), patchIt->sourcePortConfigIds.end());
270          }
271      }
272      return result;
273  }
274  
findPortIdForNewStream(int32_t in_portConfigId,AudioPort ** port)275  ndk::ScopedAStatus Module::findPortIdForNewStream(int32_t in_portConfigId, AudioPort** port) {
276      auto& configs = getConfig().portConfigs;
277      auto portConfigIt = findById<AudioPortConfig>(configs, in_portConfigId);
278      if (portConfigIt == configs.end()) {
279          LOG(ERROR) << __func__ << ": " << mType << ": existing port config id " << in_portConfigId
280                     << " not found";
281          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
282      }
283      const int32_t portId = portConfigIt->portId;
284      // In our implementation, configs of mix ports always have unique IDs.
285      CHECK(portId != in_portConfigId);
286      auto& ports = getConfig().ports;
287      auto portIt = findById<AudioPort>(ports, portId);
288      if (portIt == ports.end()) {
289          LOG(ERROR) << __func__ << ": " << mType << ": port id " << portId
290                     << " used by port config id " << in_portConfigId << " not found";
291          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
292      }
293      if (mStreams.count(in_portConfigId) != 0) {
294          LOG(ERROR) << __func__ << ": " << mType << ": port config id " << in_portConfigId
295                     << " already has a stream opened on it";
296          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
297      }
298      if (portIt->ext.getTag() != AudioPortExt::Tag::mix) {
299          LOG(ERROR) << __func__ << ": " << mType << ": port config id " << in_portConfigId
300                     << " does not correspond to a mix port";
301          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
302      }
303      const size_t maxOpenStreamCount = portIt->ext.get<AudioPortExt::Tag::mix>().maxOpenStreamCount;
304      if (maxOpenStreamCount != 0 && mStreams.count(portId) >= maxOpenStreamCount) {
305          LOG(ERROR) << __func__ << ": " << mType << ": port id " << portId
306                     << " has already reached maximum allowed opened stream count: "
307                     << maxOpenStreamCount;
308          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
309      }
310      *port = &(*portIt);
311      return ndk::ScopedAStatus::ok();
312  }
313  
generateDefaultPortConfig(const AudioPort & port,AudioPortConfig * config)314  bool Module::generateDefaultPortConfig(const AudioPort& port, AudioPortConfig* config) {
315      const bool allowDynamicConfig = port.ext.getTag() == AudioPortExt::device;
316      for (const auto& profile : port.profiles) {
317          if (isDynamicProfile(profile)) continue;
318          config->format = profile.format;
319          config->channelMask = *profile.channelMasks.begin();
320          config->sampleRate = Int{.value = *profile.sampleRates.begin()};
321          config->flags = port.flags;
322          config->ext = port.ext;
323          return true;
324      }
325      if (allowDynamicConfig) {
326          config->format = AudioFormatDescription{};
327          config->channelMask = AudioChannelLayout{};
328          config->sampleRate = Int{.value = 0};
329          config->flags = port.flags;
330          config->ext = port.ext;
331          return true;
332      }
333      LOG(ERROR) << __func__ << ": " << mType << ": port " << port.id << " only has dynamic profiles";
334      return false;
335  }
336  
populateConnectedProfiles()337  void Module::populateConnectedProfiles() {
338      Configuration& config = getConfig();
339      for (const AudioPort& port : config.ports) {
340          if (port.ext.getTag() == AudioPortExt::device) {
341              if (auto devicePort = port.ext.get<AudioPortExt::device>();
342                  !devicePort.device.type.connection.empty() && port.profiles.empty()) {
343                  if (auto connIt = config.connectedProfiles.find(port.id);
344                      connIt == config.connectedProfiles.end()) {
345                      config.connectedProfiles.emplace(
346                              port.id, internal::getStandard16And24BitPcmAudioProfiles());
347                  }
348              }
349          }
350      }
351  }
352  
353  template <typename C>
portIdsFromPortConfigIds(C portConfigIds)354  std::set<int32_t> Module::portIdsFromPortConfigIds(C portConfigIds) {
355      std::set<int32_t> result;
356      auto& portConfigs = getConfig().portConfigs;
357      for (auto it = portConfigIds.begin(); it != portConfigIds.end(); ++it) {
358          auto portConfigIt = findById<AudioPortConfig>(portConfigs, *it);
359          if (portConfigIt != portConfigs.end()) {
360              result.insert(portConfigIt->portId);
361          }
362      }
363      return result;
364  }
365  
initializeConfig()366  std::unique_ptr<Module::Configuration> Module::initializeConfig() {
367      return internal::getConfiguration(getType());
368  }
369  
getNominalLatencyMs(const AudioPortConfig &)370  int32_t Module::getNominalLatencyMs(const AudioPortConfig&) {
371      // Arbitrary value. Implementations must override this method to provide their actual latency.
372      static constexpr int32_t kLatencyMs = 5;
373      return kLatencyMs;
374  }
375  
getAudioRoutesForAudioPortImpl(int32_t portId)376  std::vector<AudioRoute*> Module::getAudioRoutesForAudioPortImpl(int32_t portId) {
377      std::vector<AudioRoute*> result;
378      auto& routes = getConfig().routes;
379      for (auto& r : routes) {
380          const auto& srcs = r.sourcePortIds;
381          if (r.sinkPortId == portId || std::find(srcs.begin(), srcs.end(), portId) != srcs.end()) {
382              result.push_back(&r);
383          }
384      }
385      return result;
386  }
387  
getConfig()388  Module::Configuration& Module::getConfig() {
389      if (!mConfig) {
390          mConfig = std::move(initializeConfig());
391      }
392      return *mConfig;
393  }
394  
getRoutableAudioPortIds(int32_t portId,std::vector<AudioRoute * > * routes)395  std::set<int32_t> Module::getRoutableAudioPortIds(int32_t portId,
396                                                    std::vector<AudioRoute*>* routes) {
397      std::vector<AudioRoute*> routesStorage;
398      if (routes == nullptr) {
399          routesStorage = getAudioRoutesForAudioPortImpl(portId);
400          routes = &routesStorage;
401      }
402      std::set<int32_t> result;
403      for (AudioRoute* r : *routes) {
404          if (r->sinkPortId == portId) {
405              result.insert(r->sourcePortIds.begin(), r->sourcePortIds.end());
406          } else {
407              result.insert(r->sinkPortId);
408          }
409      }
410      return result;
411  }
412  
registerPatch(const AudioPatch & patch)413  void Module::registerPatch(const AudioPatch& patch) {
414      auto& configs = getConfig().portConfigs;
415      auto do_insert = [&](const std::vector<int32_t>& portConfigIds) {
416          for (auto portConfigId : portConfigIds) {
417              auto configIt = findById<AudioPortConfig>(configs, portConfigId);
418              if (configIt != configs.end()) {
419                  mPatches.insert(std::pair{portConfigId, patch.id});
420                  if (configIt->portId != portConfigId) {
421                      mPatches.insert(std::pair{configIt->portId, patch.id});
422                  }
423              }
424          };
425      };
426      do_insert(patch.sourcePortConfigIds);
427      do_insert(patch.sinkPortConfigIds);
428  }
429  
updateStreamsConnectedState(const AudioPatch & oldPatch,const AudioPatch & newPatch)430  ndk::ScopedAStatus Module::updateStreamsConnectedState(const AudioPatch& oldPatch,
431                                                         const AudioPatch& newPatch) {
432      // Notify streams about the new set of devices they are connected to.
433      auto maybeFailure = ndk::ScopedAStatus::ok();
434      using Connections =
435              std::map<int32_t /*mixPortConfigId*/, std::set<int32_t /*devicePortConfigId*/>>;
436      Connections oldConnections, newConnections;
437      auto fillConnectionsHelper = [&](Connections& connections,
438                                       const std::vector<int32_t>& mixPortCfgIds,
439                                       const std::vector<int32_t>& devicePortCfgIds) {
440          for (int32_t mixPortCfgId : mixPortCfgIds) {
441              connections[mixPortCfgId].insert(devicePortCfgIds.begin(), devicePortCfgIds.end());
442          }
443      };
444      auto fillConnections = [&](Connections& connections, const AudioPatch& patch) {
445          if (std::find_if(patch.sourcePortConfigIds.begin(), patch.sourcePortConfigIds.end(),
446                           [&](int32_t portConfigId) { return mStreams.count(portConfigId) > 0; }) !=
447              patch.sourcePortConfigIds.end()) {
448              // Sources are mix ports.
449              fillConnectionsHelper(connections, patch.sourcePortConfigIds, patch.sinkPortConfigIds);
450          } else if (std::find_if(patch.sinkPortConfigIds.begin(), patch.sinkPortConfigIds.end(),
451                                  [&](int32_t portConfigId) {
452                                      return mStreams.count(portConfigId) > 0;
453                                  }) != patch.sinkPortConfigIds.end()) {
454              // Sources are device ports.
455              fillConnectionsHelper(connections, patch.sinkPortConfigIds, patch.sourcePortConfigIds);
456          }  // Otherwise, there are no streams to notify.
457      };
458      fillConnections(oldConnections, oldPatch);
459      fillConnections(newConnections, newPatch);
460  
461      std::for_each(oldConnections.begin(), oldConnections.end(), [&](const auto& connectionPair) {
462          const int32_t mixPortConfigId = connectionPair.first;
463          if (auto it = newConnections.find(mixPortConfigId);
464              it == newConnections.end() || it->second != connectionPair.second) {
465              if (auto status = mStreams.setStreamConnectedDevices(mixPortConfigId, {});
466                  status.isOk()) {
467                  LOG(DEBUG) << "updateStreamsConnectedState: The stream on port config id "
468                             << mixPortConfigId << " has been disconnected";
469              } else {
470                  // Disconnection is tricky to roll back, just register a failure.
471                  maybeFailure = std::move(status);
472              }
473          }
474      });
475      if (!maybeFailure.isOk()) return maybeFailure;
476      std::set<int32_t> idsToDisconnectOnFailure;
477      std::for_each(newConnections.begin(), newConnections.end(), [&](const auto& connectionPair) {
478          const int32_t mixPortConfigId = connectionPair.first;
479          if (auto it = oldConnections.find(mixPortConfigId);
480              it == oldConnections.end() || it->second != connectionPair.second) {
481              const auto connectedDevices = findConnectedDevices(mixPortConfigId);
482              if (connectedDevices.empty()) {
483                  // This is important as workers use the vector size to derive the connection status.
484                  LOG(FATAL) << "updateStreamsConnectedState: No connected devices found for port "
485                                "config id "
486                             << mixPortConfigId;
487              }
488              if (auto status = mStreams.setStreamConnectedDevices(mixPortConfigId, connectedDevices);
489                  status.isOk()) {
490                  LOG(DEBUG) << "updateStreamsConnectedState: The stream on port config id "
491                             << mixPortConfigId << " has been connected to: "
492                             << ::android::internal::ToString(connectedDevices);
493              } else {
494                  maybeFailure = std::move(status);
495                  idsToDisconnectOnFailure.insert(mixPortConfigId);
496              }
497          }
498      });
499      if (!maybeFailure.isOk()) {
500          LOG(WARNING) << __func__ << ": " << mType
501                       << ": Due to a failure, disconnecting streams on port config ids "
502                       << ::android::internal::ToString(idsToDisconnectOnFailure);
503          std::for_each(idsToDisconnectOnFailure.begin(), idsToDisconnectOnFailure.end(),
504                        [&](const auto& portConfigId) {
505                            auto status = mStreams.setStreamConnectedDevices(portConfigId, {});
506                            (void)status.isOk();  // Can't do much about a failure here.
507                        });
508          return maybeFailure;
509      }
510      return ndk::ScopedAStatus::ok();
511  }
512  
setModuleDebug(const::aidl::android::hardware::audio::core::ModuleDebug & in_debug)513  ndk::ScopedAStatus Module::setModuleDebug(
514          const ::aidl::android::hardware::audio::core::ModuleDebug& in_debug) {
515      LOG(DEBUG) << __func__ << ": " << mType << ": old flags:" << mDebug.toString()
516                 << ", new flags: " << in_debug.toString();
517      if (mDebug.simulateDeviceConnections != in_debug.simulateDeviceConnections &&
518          !mConnectedDevicePorts.empty()) {
519          LOG(ERROR) << __func__ << ": " << mType
520                     << ": attempting to change device connections simulation while "
521                        "having external "
522                     << "devices connected";
523          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
524      }
525      if (in_debug.streamTransientStateDelayMs < 0) {
526          LOG(ERROR) << __func__ << ": " << mType << ": streamTransientStateDelayMs is negative: "
527                     << in_debug.streamTransientStateDelayMs;
528          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
529      }
530      mDebug = in_debug;
531      return ndk::ScopedAStatus::ok();
532  }
533  
getTelephony(std::shared_ptr<ITelephony> * _aidl_return)534  ndk::ScopedAStatus Module::getTelephony(std::shared_ptr<ITelephony>* _aidl_return) {
535      *_aidl_return = nullptr;
536      LOG(DEBUG) << __func__ << ": " << mType << ": returning null";
537      return ndk::ScopedAStatus::ok();
538  }
539  
getBluetooth(std::shared_ptr<IBluetooth> * _aidl_return)540  ndk::ScopedAStatus Module::getBluetooth(std::shared_ptr<IBluetooth>* _aidl_return) {
541      *_aidl_return = nullptr;
542      LOG(DEBUG) << __func__ << ": " << mType << ": returning null";
543      return ndk::ScopedAStatus::ok();
544  }
545  
getBluetoothA2dp(std::shared_ptr<IBluetoothA2dp> * _aidl_return)546  ndk::ScopedAStatus Module::getBluetoothA2dp(std::shared_ptr<IBluetoothA2dp>* _aidl_return) {
547      *_aidl_return = nullptr;
548      LOG(DEBUG) << __func__ << ": " << mType << ": returning null";
549      return ndk::ScopedAStatus::ok();
550  }
551  
getBluetoothLe(std::shared_ptr<IBluetoothLe> * _aidl_return)552  ndk::ScopedAStatus Module::getBluetoothLe(std::shared_ptr<IBluetoothLe>* _aidl_return) {
553      *_aidl_return = nullptr;
554      LOG(DEBUG) << __func__ << ": " << mType << ": returning null";
555      return ndk::ScopedAStatus::ok();
556  }
557  
connectExternalDevice(const AudioPort & in_templateIdAndAdditionalData,AudioPort * _aidl_return)558  ndk::ScopedAStatus Module::connectExternalDevice(const AudioPort& in_templateIdAndAdditionalData,
559                                                   AudioPort* _aidl_return) {
560      const int32_t templateId = in_templateIdAndAdditionalData.id;
561      auto& ports = getConfig().ports;
562      AudioPort connectedPort;
563      {  // Scope the template port so that we don't accidentally modify it.
564          auto templateIt = findById<AudioPort>(ports, templateId);
565          if (templateIt == ports.end()) {
566              LOG(ERROR) << __func__ << ": " << mType << ": port id " << templateId << " not found";
567              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
568          }
569          if (templateIt->ext.getTag() != AudioPortExt::Tag::device) {
570              LOG(ERROR) << __func__ << ": " << mType << ": port id " << templateId
571                         << " is not a device port";
572              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
573          }
574          auto& templateDevicePort = templateIt->ext.get<AudioPortExt::Tag::device>();
575          if (templateDevicePort.device.type.connection.empty()) {
576              LOG(ERROR) << __func__ << ": " << mType << ": port id " << templateId
577                         << " is permanently attached";
578              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
579          }
580          if (mConnectedDevicePorts.find(templateId) != mConnectedDevicePorts.end()) {
581              LOG(ERROR) << __func__ << ": " << mType << ": port id " << templateId
582                         << " is a connected device port";
583              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
584          }
585          // Postpone id allocation until we ensure that there are no client errors.
586          connectedPort = *templateIt;
587          connectedPort.extraAudioDescriptors = in_templateIdAndAdditionalData.extraAudioDescriptors;
588          const auto& inputDevicePort =
589                  in_templateIdAndAdditionalData.ext.get<AudioPortExt::Tag::device>();
590          auto& connectedDevicePort = connectedPort.ext.get<AudioPortExt::Tag::device>();
591          connectedDevicePort.device.address = inputDevicePort.device.address;
592          LOG(DEBUG) << __func__ << ": " << mType << ": device port " << connectedPort.id
593                     << " device set to " << connectedDevicePort.device.toString();
594          // Check if there is already a connected port with for the same external device.
595  
596          for (auto connectedPortPair : mConnectedDevicePorts) {
597              auto connectedPortIt = findById<AudioPort>(ports, connectedPortPair.first);
598              if (connectedPortIt->ext.get<AudioPortExt::Tag::device>().device ==
599                  connectedDevicePort.device) {
600                  LOG(ERROR) << __func__ << ": " << mType << ": device "
601                             << connectedDevicePort.device.toString()
602                             << " is already connected at the device port id "
603                             << connectedPortPair.first;
604                  return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
605              }
606          }
607      }
608  
609      // Two main cases are considered with regard to the profiles of the connected device port:
610      //
611      //  1. If the template device port has dynamic profiles, and at least one routable mix
612      //     port also has dynamic profiles, it means that after connecting the device, the
613      //     connected device port must have profiles populated with actual capabilities of
614      //     the connected device, and dynamic of routable mix ports will be filled
615      //     according to these capabilities. An example of this case is connection of an
616      //     HDMI or USB device. For USB handled by ADSP, there can be mix ports with static
617      //     profiles, and one dedicated mix port for "hi-fi" playback. The latter is left with
618      //     dynamic profiles so that they can be populated with actual capabilities of
619      //     the connected device.
620      //
621      //  2. If the template device port has dynamic profiles, while all routable mix ports
622      //     have static profiles, it means that after connecting the device, the connected
623      //     device port can be left with dynamic profiles, and profiles of mix ports are
624      //     left untouched. An example of this case is connection of an analog wired
625      //     headset, it should be treated in the same way as a speaker.
626      //
627      //  Yet another possible case is when both the template device port and all routable
628      //  mix ports have static profiles. This is allowed and handled correctly, however, it
629      //  is not very practical, since these profiles are likely duplicates of each other.
630  
631      std::vector<AudioRoute*> routesToMixPorts = getAudioRoutesForAudioPortImpl(templateId);
632      std::set<int32_t> routableMixPortIds = getRoutableAudioPortIds(templateId, &routesToMixPorts);
633      const int32_t nextPortId = getConfig().nextPortId++;
634      if (!mDebug.simulateDeviceConnections) {
635          // Even if the device port has static profiles, the HAL module might need to update
636          // them, or abort the connection process.
637          RETURN_STATUS_IF_ERROR(populateConnectedDevicePort(&connectedPort, nextPortId));
638      } else if (hasDynamicProfilesOnly(connectedPort.profiles)) {
639          auto& connectedProfiles = getConfig().connectedProfiles;
640          if (auto connectedProfilesIt = connectedProfiles.find(templateId);
641              connectedProfilesIt != connectedProfiles.end()) {
642              connectedPort.profiles = connectedProfilesIt->second;
643          }
644      }
645      if (hasDynamicProfilesOnly(connectedPort.profiles)) {
646          // Possible case 2. Check if all routable mix ports have static profiles.
647          if (auto dynamicMixPortIt = std::find_if(ports.begin(), ports.end(),
648                                                   [&routableMixPortIds](const auto& p) {
649                                                       return routableMixPortIds.count(p.id) > 0 &&
650                                                              hasDynamicProfilesOnly(p.profiles);
651                                                   });
652              dynamicMixPortIt != ports.end()) {
653              LOG(ERROR) << __func__ << ": " << mType
654                         << ": connected port only has dynamic profiles after connecting "
655                         << "external device " << connectedPort.toString() << ", and there exist "
656                         << "a routable mix port with dynamic profiles: "
657                         << dynamicMixPortIt->toString();
658              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
659          }
660      }
661  
662      connectedPort.id = nextPortId;
663      auto [connectedPortsIt, _] =
664              mConnectedDevicePorts.insert(std::pair(connectedPort.id, std::set<int32_t>()));
665      LOG(DEBUG) << __func__ << ": " << mType << ": template port " << templateId
666                 << " external device connected, "
667                 << "connected port ID " << connectedPort.id;
668      ports.push_back(connectedPort);
669      onExternalDeviceConnectionChanged(connectedPort, true /*connected*/);
670  
671      // For routes where the template port is a source, add the connected port to sources,
672      // otherwise, create a new route by copying from the route for the template port.
673      std::vector<AudioRoute> newRoutes;
674      for (AudioRoute* r : routesToMixPorts) {
675          if (r->sinkPortId == templateId) {
676              newRoutes.push_back(AudioRoute{.sourcePortIds = r->sourcePortIds,
677                                             .sinkPortId = connectedPort.id,
678                                             .isExclusive = r->isExclusive});
679          } else {
680              r->sourcePortIds.push_back(connectedPort.id);
681          }
682      }
683      auto& routes = getConfig().routes;
684      routes.insert(routes.end(), newRoutes.begin(), newRoutes.end());
685  
686      if (!hasDynamicProfilesOnly(connectedPort.profiles) && !routableMixPortIds.empty()) {
687          // Note: this is a simplistic approach assuming that a mix port can only be populated
688          // from a single device port. Implementing support for stuffing dynamic profiles with
689          // a superset of all profiles from all routable dynamic device ports would be more involved.
690          for (auto& port : ports) {
691              if (routableMixPortIds.count(port.id) == 0) continue;
692              if (hasDynamicProfilesOnly(port.profiles)) {
693                  port.profiles = connectedPort.profiles;
694                  connectedPortsIt->second.insert(port.id);
695              } else {
696                  // Check if profiles are not all dynamic because they were populated by
697                  // a previous connection. Otherwise, it means that they are actually static.
698                  for (const auto& cp : mConnectedDevicePorts) {
699                      if (cp.second.count(port.id) > 0) {
700                          connectedPortsIt->second.insert(port.id);
701                          break;
702                      }
703                  }
704              }
705          }
706      }
707      *_aidl_return = std::move(connectedPort);
708  
709      return ndk::ScopedAStatus::ok();
710  }
711  
disconnectExternalDevice(int32_t in_portId)712  ndk::ScopedAStatus Module::disconnectExternalDevice(int32_t in_portId) {
713      auto& ports = getConfig().ports;
714      auto portIt = findById<AudioPort>(ports, in_portId);
715      if (portIt == ports.end()) {
716          LOG(ERROR) << __func__ << ": " << mType << ": port id " << in_portId << " not found";
717          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
718      }
719      if (portIt->ext.getTag() != AudioPortExt::Tag::device) {
720          LOG(ERROR) << __func__ << ": " << mType << ": port id " << in_portId
721                     << " is not a device port";
722          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
723      }
724      auto connectedPortsIt = mConnectedDevicePorts.find(in_portId);
725      if (connectedPortsIt == mConnectedDevicePorts.end()) {
726          LOG(ERROR) << __func__ << ": " << mType << ": port id " << in_portId
727                     << " is not a connected device port";
728          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
729      }
730      auto& configs = getConfig().portConfigs;
731      auto& initials = getConfig().initialConfigs;
732      auto configIt = std::find_if(configs.begin(), configs.end(), [&](const auto& config) {
733          if (config.portId == in_portId) {
734              // Check if the configuration was provided by the client.
735              const auto& initialIt = findById<AudioPortConfig>(initials, config.id);
736              return initialIt == initials.end() || config != *initialIt;
737          }
738          return false;
739      });
740      if (configIt != configs.end()) {
741          LOG(ERROR) << __func__ << ": " << mType << ": port id " << in_portId
742                     << " has a non-default config with id " << configIt->id;
743          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
744      }
745      onExternalDeviceConnectionChanged(*portIt, false /*connected*/);
746      ports.erase(portIt);
747      LOG(DEBUG) << __func__ << ": " << mType << ": connected device port " << in_portId
748                 << " released";
749  
750      auto& routes = getConfig().routes;
751      for (auto routesIt = routes.begin(); routesIt != routes.end();) {
752          if (routesIt->sinkPortId == in_portId) {
753              routesIt = routes.erase(routesIt);
754          } else {
755              // Note: the list of sourcePortIds can't become empty because there must
756              // be the id of the template port in the route.
757              erase_if(routesIt->sourcePortIds, [in_portId](auto src) { return src == in_portId; });
758              ++routesIt;
759          }
760      }
761  
762      // Clear profiles for mix ports that are not connected to any other ports.
763      std::set<int32_t> mixPortsToClear = std::move(connectedPortsIt->second);
764      mConnectedDevicePorts.erase(connectedPortsIt);
765      for (const auto& connectedPort : mConnectedDevicePorts) {
766          for (int32_t mixPortId : connectedPort.second) {
767              mixPortsToClear.erase(mixPortId);
768          }
769      }
770      for (int32_t mixPortId : mixPortsToClear) {
771          auto mixPortIt = findById<AudioPort>(ports, mixPortId);
772          if (mixPortIt != ports.end()) {
773              mixPortIt->profiles = {};
774          }
775      }
776  
777      return ndk::ScopedAStatus::ok();
778  }
779  
prepareToDisconnectExternalDevice(int32_t in_portId)780  ndk::ScopedAStatus Module::prepareToDisconnectExternalDevice(int32_t in_portId) {
781      auto& ports = getConfig().ports;
782      auto portIt = findById<AudioPort>(ports, in_portId);
783      if (portIt == ports.end()) {
784          LOG(ERROR) << __func__ << ": " << mType << ": port id " << in_portId << " not found";
785          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
786      }
787      if (portIt->ext.getTag() != AudioPortExt::Tag::device) {
788          LOG(ERROR) << __func__ << ": " << mType << ": port id " << in_portId
789                     << " is not a device port";
790          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
791      }
792      auto connectedPortsIt = mConnectedDevicePorts.find(in_portId);
793      if (connectedPortsIt == mConnectedDevicePorts.end()) {
794          LOG(ERROR) << __func__ << ": " << mType << ": port id " << in_portId
795                     << " is not a connected device port";
796          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
797      }
798  
799      onPrepareToDisconnectExternalDevice(*portIt);
800  
801      return ndk::ScopedAStatus::ok();
802  }
803  
getAudioPatches(std::vector<AudioPatch> * _aidl_return)804  ndk::ScopedAStatus Module::getAudioPatches(std::vector<AudioPatch>* _aidl_return) {
805      *_aidl_return = getConfig().patches;
806      LOG(DEBUG) << __func__ << ": " << mType << ": returning " << _aidl_return->size() << " patches";
807      return ndk::ScopedAStatus::ok();
808  }
809  
getAudioPort(int32_t in_portId,AudioPort * _aidl_return)810  ndk::ScopedAStatus Module::getAudioPort(int32_t in_portId, AudioPort* _aidl_return) {
811      auto& ports = getConfig().ports;
812      auto portIt = findById<AudioPort>(ports, in_portId);
813      if (portIt != ports.end()) {
814          *_aidl_return = *portIt;
815          LOG(DEBUG) << __func__ << ": " << mType << ": returning port by id " << in_portId;
816          return ndk::ScopedAStatus::ok();
817      }
818      LOG(ERROR) << __func__ << ": " << mType << ": port id " << in_portId << " not found";
819      return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
820  }
821  
getAudioPortConfigs(std::vector<AudioPortConfig> * _aidl_return)822  ndk::ScopedAStatus Module::getAudioPortConfigs(std::vector<AudioPortConfig>* _aidl_return) {
823      *_aidl_return = getConfig().portConfigs;
824      LOG(DEBUG) << __func__ << ": " << mType << ": returning " << _aidl_return->size()
825                 << " port configs";
826      return ndk::ScopedAStatus::ok();
827  }
828  
getAudioPorts(std::vector<AudioPort> * _aidl_return)829  ndk::ScopedAStatus Module::getAudioPorts(std::vector<AudioPort>* _aidl_return) {
830      *_aidl_return = getConfig().ports;
831      LOG(DEBUG) << __func__ << ": " << mType << ": returning " << _aidl_return->size() << " ports";
832      return ndk::ScopedAStatus::ok();
833  }
834  
getAudioRoutes(std::vector<AudioRoute> * _aidl_return)835  ndk::ScopedAStatus Module::getAudioRoutes(std::vector<AudioRoute>* _aidl_return) {
836      *_aidl_return = getConfig().routes;
837      LOG(DEBUG) << __func__ << ": " << mType << ": returning " << _aidl_return->size() << " routes";
838      return ndk::ScopedAStatus::ok();
839  }
840  
getAudioRoutesForAudioPort(int32_t in_portId,std::vector<AudioRoute> * _aidl_return)841  ndk::ScopedAStatus Module::getAudioRoutesForAudioPort(int32_t in_portId,
842                                                        std::vector<AudioRoute>* _aidl_return) {
843      auto& ports = getConfig().ports;
844      if (auto portIt = findById<AudioPort>(ports, in_portId); portIt == ports.end()) {
845          LOG(ERROR) << __func__ << ": " << mType << ": port id " << in_portId << " not found";
846          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
847      }
848      std::vector<AudioRoute*> routes = getAudioRoutesForAudioPortImpl(in_portId);
849      std::transform(routes.begin(), routes.end(), std::back_inserter(*_aidl_return),
850                     [](auto rptr) { return *rptr; });
851      return ndk::ScopedAStatus::ok();
852  }
853  
openInputStream(const OpenInputStreamArguments & in_args,OpenInputStreamReturn * _aidl_return)854  ndk::ScopedAStatus Module::openInputStream(const OpenInputStreamArguments& in_args,
855                                             OpenInputStreamReturn* _aidl_return) {
856      LOG(DEBUG) << __func__ << ": " << mType << ": port config id " << in_args.portConfigId
857                 << ", buffer size " << in_args.bufferSizeFrames << " frames";
858      AudioPort* port = nullptr;
859      RETURN_STATUS_IF_ERROR(findPortIdForNewStream(in_args.portConfigId, &port));
860      if (port->flags.getTag() != AudioIoFlags::Tag::input) {
861          LOG(ERROR) << __func__ << ": " << mType << ": port config id " << in_args.portConfigId
862                     << " does not correspond to an input mix port";
863          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
864      }
865      StreamContext context;
866      RETURN_STATUS_IF_ERROR(createStreamContext(in_args.portConfigId, in_args.bufferSizeFrames,
867                                                 nullptr, nullptr, &context));
868      context.fillDescriptor(&_aidl_return->desc);
869      std::shared_ptr<StreamIn> stream;
870      RETURN_STATUS_IF_ERROR(createInputStream(std::move(context), in_args.sinkMetadata,
871                                               getMicrophoneInfos(), &stream));
872      StreamWrapper streamWrapper(stream);
873      if (auto patchIt = mPatches.find(in_args.portConfigId); patchIt != mPatches.end()) {
874          RETURN_STATUS_IF_ERROR(
875                  streamWrapper.setConnectedDevices(findConnectedDevices(in_args.portConfigId)));
876      }
877      auto streamBinder = streamWrapper.getBinder();
878      AIBinder_setMinSchedulerPolicy(streamBinder.get(), SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
879      AIBinder_setInheritRt(streamBinder.get(), true);
880      mStreams.insert(port->id, in_args.portConfigId, std::move(streamWrapper));
881      _aidl_return->stream = std::move(stream);
882      return ndk::ScopedAStatus::ok();
883  }
884  
openOutputStream(const OpenOutputStreamArguments & in_args,OpenOutputStreamReturn * _aidl_return)885  ndk::ScopedAStatus Module::openOutputStream(const OpenOutputStreamArguments& in_args,
886                                              OpenOutputStreamReturn* _aidl_return) {
887      LOG(DEBUG) << __func__ << ": " << mType << ": port config id " << in_args.portConfigId
888                 << ", has offload info? " << (in_args.offloadInfo.has_value()) << ", buffer size "
889                 << in_args.bufferSizeFrames << " frames";
890      AudioPort* port = nullptr;
891      RETURN_STATUS_IF_ERROR(findPortIdForNewStream(in_args.portConfigId, &port));
892      if (port->flags.getTag() != AudioIoFlags::Tag::output) {
893          LOG(ERROR) << __func__ << ": " << mType << ": port config id " << in_args.portConfigId
894                     << " does not correspond to an output mix port";
895          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
896      }
897      const bool isOffload = isBitPositionFlagSet(port->flags.get<AudioIoFlags::Tag::output>(),
898                                                  AudioOutputFlags::COMPRESS_OFFLOAD);
899      if (isOffload && !in_args.offloadInfo.has_value()) {
900          LOG(ERROR) << __func__ << ": " << mType << ": port id " << port->id
901                     << " has COMPRESS_OFFLOAD flag set, requires offload info";
902          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
903      }
904      const bool isNonBlocking = isBitPositionFlagSet(port->flags.get<AudioIoFlags::Tag::output>(),
905                                                      AudioOutputFlags::NON_BLOCKING);
906      if (isNonBlocking && in_args.callback == nullptr) {
907          LOG(ERROR) << __func__ << ": " << mType << ": port id " << port->id
908                     << " has NON_BLOCKING flag set, requires async callback";
909          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
910      }
911      StreamContext context;
912      RETURN_STATUS_IF_ERROR(createStreamContext(in_args.portConfigId, in_args.bufferSizeFrames,
913                                                 isNonBlocking ? in_args.callback : nullptr,
914                                                 in_args.eventCallback, &context));
915      context.fillDescriptor(&_aidl_return->desc);
916      std::shared_ptr<StreamOut> stream;
917      RETURN_STATUS_IF_ERROR(createOutputStream(std::move(context), in_args.sourceMetadata,
918                                                in_args.offloadInfo, &stream));
919      StreamWrapper streamWrapper(stream);
920      if (auto patchIt = mPatches.find(in_args.portConfigId); patchIt != mPatches.end()) {
921          RETURN_STATUS_IF_ERROR(
922                  streamWrapper.setConnectedDevices(findConnectedDevices(in_args.portConfigId)));
923      }
924      auto streamBinder = streamWrapper.getBinder();
925      AIBinder_setMinSchedulerPolicy(streamBinder.get(), SCHED_NORMAL, ANDROID_PRIORITY_AUDIO);
926      AIBinder_setInheritRt(streamBinder.get(), true);
927      mStreams.insert(port->id, in_args.portConfigId, std::move(streamWrapper));
928      _aidl_return->stream = std::move(stream);
929      return ndk::ScopedAStatus::ok();
930  }
931  
getSupportedPlaybackRateFactors(SupportedPlaybackRateFactors * _aidl_return)932  ndk::ScopedAStatus Module::getSupportedPlaybackRateFactors(
933          SupportedPlaybackRateFactors* _aidl_return) {
934      LOG(DEBUG) << __func__ << ": " << mType;
935      (void)_aidl_return;
936      return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
937  }
938  
setAudioPatch(const AudioPatch & in_requested,AudioPatch * _aidl_return)939  ndk::ScopedAStatus Module::setAudioPatch(const AudioPatch& in_requested, AudioPatch* _aidl_return) {
940      LOG(DEBUG) << __func__ << ": " << mType << ": requested patch " << in_requested.toString();
941      if (in_requested.sourcePortConfigIds.empty()) {
942          LOG(ERROR) << __func__ << ": " << mType << ": requested patch has empty sources list";
943          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
944      }
945      if (!all_unique<int32_t>(in_requested.sourcePortConfigIds)) {
946          LOG(ERROR) << __func__ << ": " << mType
947                     << ": requested patch has duplicate ids in the sources list";
948          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
949      }
950      if (in_requested.sinkPortConfigIds.empty()) {
951          LOG(ERROR) << __func__ << ": " << mType << ": requested patch has empty sinks list";
952          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
953      }
954      if (!all_unique<int32_t>(in_requested.sinkPortConfigIds)) {
955          LOG(ERROR) << __func__ << ": " << mType
956                     << ": requested patch has duplicate ids in the sinks list";
957          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
958      }
959  
960      auto& configs = getConfig().portConfigs;
961      std::vector<int32_t> missingIds;
962      auto sources =
963              selectByIds<AudioPortConfig>(configs, in_requested.sourcePortConfigIds, &missingIds);
964      if (!missingIds.empty()) {
965          LOG(ERROR) << __func__ << ": " << mType << ": following source port config ids not found: "
966                     << ::android::internal::ToString(missingIds);
967          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
968      }
969      auto sinks = selectByIds<AudioPortConfig>(configs, in_requested.sinkPortConfigIds, &missingIds);
970      if (!missingIds.empty()) {
971          LOG(ERROR) << __func__ << ": " << mType << ": following sink port config ids not found: "
972                     << ::android::internal::ToString(missingIds);
973          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
974      }
975      // bool indicates whether a non-exclusive route is available.
976      // If only an exclusive route is available, that means the patch can not be
977      // established if there is any other patch which currently uses the sink port.
978      std::map<int32_t, bool> allowedSinkPorts;
979      auto& routes = getConfig().routes;
980      for (auto src : sources) {
981          for (const auto& r : routes) {
982              const auto& srcs = r.sourcePortIds;
983              if (std::find(srcs.begin(), srcs.end(), src->portId) != srcs.end()) {
984                  if (!allowedSinkPorts[r.sinkPortId]) {  // prefer non-exclusive
985                      allowedSinkPorts[r.sinkPortId] = !r.isExclusive;
986                  }
987              }
988          }
989      }
990      for (auto sink : sinks) {
991          if (allowedSinkPorts.count(sink->portId) == 0) {
992              LOG(ERROR) << __func__ << ": " << mType << ": there is no route to the sink port id "
993                         << sink->portId;
994              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
995          }
996      }
997      RETURN_STATUS_IF_ERROR(checkAudioPatchEndpointsMatch(sources, sinks));
998  
999      auto& patches = getConfig().patches;
1000      auto existing = patches.end();
1001      std::optional<decltype(mPatches)> patchesBackup;
1002      if (in_requested.id != 0) {
1003          existing = findById<AudioPatch>(patches, in_requested.id);
1004          if (existing != patches.end()) {
1005              patchesBackup = mPatches;
1006              cleanUpPatch(existing->id);
1007          } else {
1008              LOG(ERROR) << __func__ << ": " << mType << ": not found existing patch id "
1009                         << in_requested.id;
1010              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1011          }
1012      }
1013      // Validate the requested patch.
1014      for (const auto& [sinkPortId, nonExclusive] : allowedSinkPorts) {
1015          if (!nonExclusive && mPatches.count(sinkPortId) != 0) {
1016              LOG(ERROR) << __func__ << ": " << mType << ": sink port id " << sinkPortId
1017                         << "is exclusive and is already used by some other patch";
1018              if (patchesBackup.has_value()) {
1019                  mPatches = std::move(*patchesBackup);
1020              }
1021              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
1022          }
1023      }
1024      // Find the highest sample rate among mix port configs.
1025      std::map<int32_t, AudioPortConfig*> sampleRates;
1026      std::vector<AudioPortConfig*>& mixPortConfigs =
1027              sources[0]->ext.getTag() == AudioPortExt::mix ? sources : sinks;
1028      for (auto mix : mixPortConfigs) {
1029          sampleRates.emplace(mix->sampleRate.value().value, mix);
1030      }
1031      *_aidl_return = in_requested;
1032      auto maxSampleRateIt = std::max_element(sampleRates.begin(), sampleRates.end());
1033      const int32_t latencyMs = getNominalLatencyMs(*(maxSampleRateIt->second));
1034      _aidl_return->minimumStreamBufferSizeFrames =
1035              calculateBufferSizeFrames(latencyMs, maxSampleRateIt->first);
1036      _aidl_return->latenciesMs.clear();
1037      _aidl_return->latenciesMs.insert(_aidl_return->latenciesMs.end(),
1038                                       _aidl_return->sinkPortConfigIds.size(), latencyMs);
1039      AudioPatch oldPatch{};
1040      if (existing == patches.end()) {
1041          _aidl_return->id = getConfig().nextPatchId++;
1042          patches.push_back(*_aidl_return);
1043      } else {
1044          oldPatch = *existing;
1045          *existing = *_aidl_return;
1046      }
1047      patchesBackup = mPatches;
1048      registerPatch(*_aidl_return);
1049      if (auto status = updateStreamsConnectedState(oldPatch, *_aidl_return); !status.isOk()) {
1050          mPatches = std::move(*patchesBackup);
1051          if (existing == patches.end()) {
1052              patches.pop_back();
1053          } else {
1054              *existing = oldPatch;
1055          }
1056          return status;
1057      }
1058  
1059      LOG(DEBUG) << __func__ << ": " << mType << ": " << (oldPatch.id == 0 ? "created" : "updated")
1060                 << " patch " << _aidl_return->toString();
1061      return ndk::ScopedAStatus::ok();
1062  }
1063  
setAudioPortConfig(const AudioPortConfig & in_requested,AudioPortConfig * out_suggested,bool * _aidl_return)1064  ndk::ScopedAStatus Module::setAudioPortConfig(const AudioPortConfig& in_requested,
1065                                                AudioPortConfig* out_suggested, bool* _aidl_return) {
1066      auto generate = [this](const AudioPort& port, AudioPortConfig* config) {
1067          return generateDefaultPortConfig(port, config);
1068      };
1069      return setAudioPortConfigImpl(in_requested, generate, out_suggested, _aidl_return);
1070  }
1071  
setAudioPortConfigImpl(const AudioPortConfig & in_requested,const std::function<bool (const::aidl::android::media::audio::common::AudioPort & port,::aidl::android::media::audio::common::AudioPortConfig * config)> & fillPortConfig,AudioPortConfig * out_suggested,bool * applied)1072  ndk::ScopedAStatus Module::setAudioPortConfigImpl(
1073          const AudioPortConfig& in_requested,
1074          const std::function<bool(const ::aidl::android::media::audio::common::AudioPort& port,
1075                                   ::aidl::android::media::audio::common::AudioPortConfig* config)>&
1076                  fillPortConfig,
1077          AudioPortConfig* out_suggested, bool* applied) {
1078      LOG(DEBUG) << __func__ << ": " << mType << ": requested " << in_requested.toString();
1079      auto& configs = getConfig().portConfigs;
1080      auto existing = configs.end();
1081      if (in_requested.id != 0) {
1082          if (existing = findById<AudioPortConfig>(configs, in_requested.id);
1083              existing == configs.end()) {
1084              LOG(ERROR) << __func__ << ": " << mType << ": existing port config id "
1085                         << in_requested.id << " not found";
1086              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1087          }
1088      }
1089  
1090      const int portId = existing != configs.end() ? existing->portId : in_requested.portId;
1091      if (portId == 0) {
1092          LOG(ERROR) << __func__ << ": " << mType
1093                     << ": requested port config does not specify portId";
1094          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1095      }
1096      auto& ports = getConfig().ports;
1097      auto portIt = findById<AudioPort>(ports, portId);
1098      if (portIt == ports.end()) {
1099          LOG(ERROR) << __func__ << ": " << mType
1100                     << ": requested port config points to non-existent portId " << portId;
1101          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1102      }
1103      if (existing != configs.end()) {
1104          *out_suggested = *existing;
1105      } else {
1106          AudioPortConfig newConfig;
1107          newConfig.portId = portIt->id;
1108          if (fillPortConfig(*portIt, &newConfig)) {
1109              *out_suggested = newConfig;
1110          } else {
1111              LOG(ERROR) << __func__ << ": " << mType
1112                         << ": unable generate a default config for port " << portId;
1113              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1114          }
1115      }
1116      // From this moment, 'out_suggested' is either an existing port config,
1117      // or a new generated config. Now attempt to update it according to the specified
1118      // fields of 'in_requested'.
1119  
1120      // Device ports with only dynamic profiles are used for devices that are connected via ADSP,
1121      // which takes care of their actual configuration automatically.
1122      const bool allowDynamicConfig = portIt->ext.getTag() == AudioPortExt::device &&
1123                                      hasDynamicProfilesOnly(portIt->profiles);
1124      bool requestedIsValid = true, requestedIsFullySpecified = true;
1125  
1126      AudioIoFlags portFlags = portIt->flags;
1127      if (in_requested.flags.has_value()) {
1128          if (in_requested.flags.value() != portFlags) {
1129              LOG(WARNING) << __func__ << ": " << mType << ": requested flags "
1130                           << in_requested.flags.value().toString() << " do not match port's "
1131                           << portId << " flags " << portFlags.toString();
1132              requestedIsValid = false;
1133          }
1134      } else {
1135          requestedIsFullySpecified = false;
1136      }
1137  
1138      AudioProfile portProfile;
1139      if (in_requested.format.has_value()) {
1140          const auto& format = in_requested.format.value();
1141          if ((format == AudioFormatDescription{} && allowDynamicConfig) ||
1142              findAudioProfile(*portIt, format, &portProfile)) {
1143              out_suggested->format = format;
1144          } else {
1145              LOG(WARNING) << __func__ << ": " << mType << ": requested format " << format.toString()
1146                           << " is not found in the profiles of port " << portId;
1147              requestedIsValid = false;
1148          }
1149      } else {
1150          requestedIsFullySpecified = false;
1151      }
1152      if (!(out_suggested->format.value() == AudioFormatDescription{} && allowDynamicConfig) &&
1153          !findAudioProfile(*portIt, out_suggested->format.value(), &portProfile)) {
1154          LOG(ERROR) << __func__ << ": " << mType << ": port " << portId
1155                     << " does not support format " << out_suggested->format.value().toString()
1156                     << " anymore";
1157          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1158      }
1159  
1160      if (in_requested.channelMask.has_value()) {
1161          const auto& channelMask = in_requested.channelMask.value();
1162          if ((channelMask == AudioChannelLayout{} && allowDynamicConfig) ||
1163              find(portProfile.channelMasks.begin(), portProfile.channelMasks.end(), channelMask) !=
1164                      portProfile.channelMasks.end()) {
1165              out_suggested->channelMask = channelMask;
1166          } else {
1167              LOG(WARNING) << __func__ << ": " << mType << ": requested channel mask "
1168                           << channelMask.toString() << " is not supported for the format "
1169                           << portProfile.format.toString() << " by the port " << portId;
1170              requestedIsValid = false;
1171          }
1172      } else {
1173          requestedIsFullySpecified = false;
1174      }
1175  
1176      if (in_requested.sampleRate.has_value()) {
1177          const auto& sampleRate = in_requested.sampleRate.value();
1178          if ((sampleRate.value == 0 && allowDynamicConfig) ||
1179              find(portProfile.sampleRates.begin(), portProfile.sampleRates.end(),
1180                   sampleRate.value) != portProfile.sampleRates.end()) {
1181              out_suggested->sampleRate = sampleRate;
1182          } else {
1183              LOG(WARNING) << __func__ << ": " << mType << ": requested sample rate "
1184                           << sampleRate.value << " is not supported for the format "
1185                           << portProfile.format.toString() << " by the port " << portId;
1186              requestedIsValid = false;
1187          }
1188      } else {
1189          requestedIsFullySpecified = false;
1190      }
1191  
1192      if (in_requested.gain.has_value()) {
1193          // Let's pretend that gain can always be applied.
1194          out_suggested->gain = in_requested.gain.value();
1195      }
1196  
1197      if (in_requested.ext.getTag() != AudioPortExt::Tag::unspecified) {
1198          if (in_requested.ext.getTag() == out_suggested->ext.getTag()) {
1199              if (out_suggested->ext.getTag() == AudioPortExt::Tag::mix) {
1200                  // 'AudioMixPortExt.handle' and '.usecase' are set by the client,
1201                  // copy from in_requested.
1202                  const auto& src = in_requested.ext.get<AudioPortExt::Tag::mix>();
1203                  auto& dst = out_suggested->ext.get<AudioPortExt::Tag::mix>();
1204                  dst.handle = src.handle;
1205                  dst.usecase = src.usecase;
1206              }
1207          } else {
1208              LOG(WARNING) << __func__ << ": " << mType << ": requested ext tag "
1209                           << toString(in_requested.ext.getTag()) << " do not match port's tag "
1210                           << toString(out_suggested->ext.getTag());
1211              requestedIsValid = false;
1212          }
1213      }
1214  
1215      if (existing == configs.end() && requestedIsValid && requestedIsFullySpecified) {
1216          out_suggested->id = getConfig().nextPortId++;
1217          configs.push_back(*out_suggested);
1218          *applied = true;
1219          LOG(DEBUG) << __func__ << ": " << mType << ": created new port config "
1220                     << out_suggested->toString();
1221      } else if (existing != configs.end() && requestedIsValid) {
1222          *existing = *out_suggested;
1223          *applied = true;
1224          LOG(DEBUG) << __func__ << ": " << mType << ": updated port config "
1225                     << out_suggested->toString();
1226      } else {
1227          LOG(DEBUG) << __func__ << ": " << mType << ": not applied; existing config ? "
1228                     << (existing != configs.end()) << "; requested is valid? " << requestedIsValid
1229                     << ", fully specified? " << requestedIsFullySpecified;
1230          *applied = false;
1231      }
1232      return ndk::ScopedAStatus::ok();
1233  }
1234  
resetAudioPatch(int32_t in_patchId)1235  ndk::ScopedAStatus Module::resetAudioPatch(int32_t in_patchId) {
1236      auto& patches = getConfig().patches;
1237      auto patchIt = findById<AudioPatch>(patches, in_patchId);
1238      if (patchIt != patches.end()) {
1239          auto patchesBackup = mPatches;
1240          cleanUpPatch(patchIt->id);
1241          if (auto status = updateStreamsConnectedState(*patchIt, AudioPatch{}); !status.isOk()) {
1242              mPatches = std::move(patchesBackup);
1243              return status;
1244          }
1245          patches.erase(patchIt);
1246          LOG(DEBUG) << __func__ << ": " << mType << ": erased patch " << in_patchId;
1247          return ndk::ScopedAStatus::ok();
1248      }
1249      LOG(ERROR) << __func__ << ": " << mType << ": patch id " << in_patchId << " not found";
1250      return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1251  }
1252  
resetAudioPortConfig(int32_t in_portConfigId)1253  ndk::ScopedAStatus Module::resetAudioPortConfig(int32_t in_portConfigId) {
1254      auto& configs = getConfig().portConfigs;
1255      auto configIt = findById<AudioPortConfig>(configs, in_portConfigId);
1256      if (configIt != configs.end()) {
1257          if (mStreams.count(in_portConfigId) != 0) {
1258              LOG(ERROR) << __func__ << ": " << mType << ": port config id " << in_portConfigId
1259                         << " has a stream opened on it";
1260              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
1261          }
1262          auto patchIt = mPatches.find(in_portConfigId);
1263          if (patchIt != mPatches.end()) {
1264              LOG(ERROR) << __func__ << ": " << mType << ": port config id " << in_portConfigId
1265                         << " is used by the patch with id " << patchIt->second;
1266              return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
1267          }
1268          auto& initials = getConfig().initialConfigs;
1269          auto initialIt = findById<AudioPortConfig>(initials, in_portConfigId);
1270          if (initialIt == initials.end()) {
1271              configs.erase(configIt);
1272              LOG(DEBUG) << __func__ << ": " << mType << ": erased port config " << in_portConfigId;
1273          } else if (*configIt != *initialIt) {
1274              *configIt = *initialIt;
1275              LOG(DEBUG) << __func__ << ": " << mType << ": reset port config " << in_portConfigId;
1276          }
1277          return ndk::ScopedAStatus::ok();
1278      }
1279      LOG(ERROR) << __func__ << ": " << mType << ": port config id " << in_portConfigId
1280                 << " not found";
1281      return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1282  }
1283  
getMasterMute(bool * _aidl_return)1284  ndk::ScopedAStatus Module::getMasterMute(bool* _aidl_return) {
1285      *_aidl_return = mMasterMute;
1286      LOG(DEBUG) << __func__ << ": " << mType << ": returning " << *_aidl_return;
1287      return ndk::ScopedAStatus::ok();
1288  }
1289  
setMasterMute(bool in_mute)1290  ndk::ScopedAStatus Module::setMasterMute(bool in_mute) {
1291      LOG(DEBUG) << __func__ << ": " << mType << ": " << in_mute;
1292      auto result = mDebug.simulateDeviceConnections ? ndk::ScopedAStatus::ok()
1293                                                     : onMasterMuteChanged(in_mute);
1294      if (result.isOk()) {
1295          mMasterMute = in_mute;
1296      } else {
1297          LOG(ERROR) << __func__ << ": " << mType << ": failed calling onMasterMuteChanged("
1298                     << in_mute << "), error=" << result;
1299          // Reset master mute if it failed.
1300          onMasterMuteChanged(mMasterMute);
1301      }
1302      return result;
1303  }
1304  
getMasterVolume(float * _aidl_return)1305  ndk::ScopedAStatus Module::getMasterVolume(float* _aidl_return) {
1306      *_aidl_return = mMasterVolume;
1307      LOG(DEBUG) << __func__ << ": " << mType << ": returning " << *_aidl_return;
1308      return ndk::ScopedAStatus::ok();
1309  }
1310  
setMasterVolume(float in_volume)1311  ndk::ScopedAStatus Module::setMasterVolume(float in_volume) {
1312      LOG(DEBUG) << __func__ << ": " << mType << ": " << in_volume;
1313      if (in_volume >= 0.0f && in_volume <= 1.0f) {
1314          auto result = mDebug.simulateDeviceConnections ? ndk::ScopedAStatus::ok()
1315                                                         : onMasterVolumeChanged(in_volume);
1316          if (result.isOk()) {
1317              mMasterVolume = in_volume;
1318          } else {
1319              // Reset master volume if it failed.
1320              LOG(ERROR) << __func__ << ": " << mType << ": failed calling onMasterVolumeChanged("
1321                         << in_volume << "), error=" << result;
1322              onMasterVolumeChanged(mMasterVolume);
1323          }
1324          return result;
1325      }
1326      LOG(ERROR) << __func__ << ": " << mType << ": invalid master volume value: " << in_volume;
1327      return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1328  }
1329  
getMicMute(bool * _aidl_return)1330  ndk::ScopedAStatus Module::getMicMute(bool* _aidl_return) {
1331      *_aidl_return = mMicMute;
1332      LOG(DEBUG) << __func__ << ": " << mType << ": returning " << *_aidl_return;
1333      return ndk::ScopedAStatus::ok();
1334  }
1335  
setMicMute(bool in_mute)1336  ndk::ScopedAStatus Module::setMicMute(bool in_mute) {
1337      LOG(DEBUG) << __func__ << ": " << mType << ": " << in_mute;
1338      mMicMute = in_mute;
1339      return ndk::ScopedAStatus::ok();
1340  }
1341  
getMicrophones(std::vector<MicrophoneInfo> * _aidl_return)1342  ndk::ScopedAStatus Module::getMicrophones(std::vector<MicrophoneInfo>* _aidl_return) {
1343      *_aidl_return = getMicrophoneInfos();
1344      LOG(DEBUG) << __func__ << ": " << mType << ": returning "
1345                 << ::android::internal::ToString(*_aidl_return);
1346      return ndk::ScopedAStatus::ok();
1347  }
1348  
updateAudioMode(AudioMode in_mode)1349  ndk::ScopedAStatus Module::updateAudioMode(AudioMode in_mode) {
1350      if (!isValidAudioMode(in_mode)) {
1351          LOG(ERROR) << __func__ << ": " << mType << ": invalid mode " << toString(in_mode);
1352          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1353      }
1354      // No checks for supported audio modes here, it's an informative notification.
1355      LOG(DEBUG) << __func__ << ": " << mType << ": " << toString(in_mode);
1356      return ndk::ScopedAStatus::ok();
1357  }
1358  
updateScreenRotation(ScreenRotation in_rotation)1359  ndk::ScopedAStatus Module::updateScreenRotation(ScreenRotation in_rotation) {
1360      LOG(DEBUG) << __func__ << ": " << mType << ": " << toString(in_rotation);
1361      return ndk::ScopedAStatus::ok();
1362  }
1363  
updateScreenState(bool in_isTurnedOn)1364  ndk::ScopedAStatus Module::updateScreenState(bool in_isTurnedOn) {
1365      LOG(DEBUG) << __func__ << ": " << mType << ": " << in_isTurnedOn;
1366      return ndk::ScopedAStatus::ok();
1367  }
1368  
getSoundDose(std::shared_ptr<ISoundDose> * _aidl_return)1369  ndk::ScopedAStatus Module::getSoundDose(std::shared_ptr<ISoundDose>* _aidl_return) {
1370      if (!mSoundDose) {
1371          mSoundDose = ndk::SharedRefBase::make<sounddose::SoundDose>();
1372      }
1373      *_aidl_return = mSoundDose.getInstance();
1374      LOG(DEBUG) << __func__ << ": " << mType
1375                 << ": returning instance of ISoundDose: " << _aidl_return->get();
1376      return ndk::ScopedAStatus::ok();
1377  }
1378  
generateHwAvSyncId(int32_t * _aidl_return)1379  ndk::ScopedAStatus Module::generateHwAvSyncId(int32_t* _aidl_return) {
1380      LOG(DEBUG) << __func__ << ": " << mType;
1381      (void)_aidl_return;
1382      return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
1383  }
1384  
1385  const std::string Module::VendorDebug::kForceTransientBurstName = "aosp.forceTransientBurst";
1386  const std::string Module::VendorDebug::kForceSynchronousDrainName = "aosp.forceSynchronousDrain";
1387  
getVendorParameters(const std::vector<std::string> & in_ids,std::vector<VendorParameter> * _aidl_return)1388  ndk::ScopedAStatus Module::getVendorParameters(const std::vector<std::string>& in_ids,
1389                                                 std::vector<VendorParameter>* _aidl_return) {
1390      LOG(VERBOSE) << __func__ << ": " << mType << ": id count: " << in_ids.size();
1391      bool allParametersKnown = true;
1392      for (const auto& id : in_ids) {
1393          if (id == VendorDebug::kForceTransientBurstName) {
1394              VendorParameter forceTransientBurst{.id = id};
1395              forceTransientBurst.ext.setParcelable(Boolean{mVendorDebug.forceTransientBurst});
1396              _aidl_return->push_back(std::move(forceTransientBurst));
1397          } else if (id == VendorDebug::kForceSynchronousDrainName) {
1398              VendorParameter forceSynchronousDrain{.id = id};
1399              forceSynchronousDrain.ext.setParcelable(Boolean{mVendorDebug.forceSynchronousDrain});
1400              _aidl_return->push_back(std::move(forceSynchronousDrain));
1401          } else {
1402              allParametersKnown = false;
1403              LOG(VERBOSE) << __func__ << ": " << mType << ": unrecognized parameter \"" << id << "\"";
1404          }
1405      }
1406      if (allParametersKnown) return ndk::ScopedAStatus::ok();
1407      return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1408  }
1409  
1410  namespace {
1411  
1412  template <typename W>
extractParameter(const VendorParameter & p,decltype(W::value) * v)1413  bool extractParameter(const VendorParameter& p, decltype(W::value)* v) {
1414      std::optional<W> value;
1415      binder_status_t result = p.ext.getParcelable(&value);
1416      if (result == STATUS_OK && value.has_value()) {
1417          *v = value.value().value;
1418          return true;
1419      }
1420      LOG(ERROR) << __func__ << ": failed to read the value of the parameter \"" << p.id
1421                 << "\": " << result;
1422      return false;
1423  }
1424  
1425  }  // namespace
1426  
setVendorParameters(const std::vector<VendorParameter> & in_parameters,bool in_async)1427  ndk::ScopedAStatus Module::setVendorParameters(const std::vector<VendorParameter>& in_parameters,
1428                                                 bool in_async) {
1429      LOG(VERBOSE) << __func__ << ": " << mType << ": parameter count " << in_parameters.size()
1430                   << ", async: " << in_async;
1431      bool allParametersKnown = true;
1432      for (const auto& p : in_parameters) {
1433          if (p.id == VendorDebug::kForceTransientBurstName) {
1434              if (!extractParameter<Boolean>(p, &mVendorDebug.forceTransientBurst)) {
1435                  return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1436              }
1437          } else if (p.id == VendorDebug::kForceSynchronousDrainName) {
1438              if (!extractParameter<Boolean>(p, &mVendorDebug.forceSynchronousDrain)) {
1439                  return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1440              }
1441          } else {
1442              allParametersKnown = false;
1443              LOG(VERBOSE) << __func__ << ": " << mType << ": unrecognized parameter \"" << p.id
1444                           << "\"";
1445          }
1446      }
1447      if (allParametersKnown) return ndk::ScopedAStatus::ok();
1448      return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1449  }
1450  
addDeviceEffect(int32_t in_portConfigId,const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> & in_effect)1451  ndk::ScopedAStatus Module::addDeviceEffect(
1452          int32_t in_portConfigId,
1453          const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect>& in_effect) {
1454      if (in_effect == nullptr) {
1455          LOG(DEBUG) << __func__ << ": " << mType << ": port id " << in_portConfigId
1456                     << ", null effect";
1457      } else {
1458          LOG(DEBUG) << __func__ << ": " << mType << ": port id " << in_portConfigId
1459                     << ", effect Binder " << in_effect->asBinder().get();
1460      }
1461      return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
1462  }
1463  
removeDeviceEffect(int32_t in_portConfigId,const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect> & in_effect)1464  ndk::ScopedAStatus Module::removeDeviceEffect(
1465          int32_t in_portConfigId,
1466          const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect>& in_effect) {
1467      if (in_effect == nullptr) {
1468          LOG(DEBUG) << __func__ << ": " << mType << ": port id " << in_portConfigId
1469                     << ", null effect";
1470      } else {
1471          LOG(DEBUG) << __func__ << ": " << mType << ": port id " << in_portConfigId
1472                     << ", effect Binder " << in_effect->asBinder().get();
1473      }
1474      return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
1475  }
1476  
getMmapPolicyInfos(AudioMMapPolicyType mmapPolicyType,std::vector<AudioMMapPolicyInfo> * _aidl_return)1477  ndk::ScopedAStatus Module::getMmapPolicyInfos(AudioMMapPolicyType mmapPolicyType,
1478                                                std::vector<AudioMMapPolicyInfo>* _aidl_return) {
1479      LOG(DEBUG) << __func__ << ": " << mType << ": mmap policy type " << toString(mmapPolicyType);
1480      std::set<int32_t> mmapSinks;
1481      std::set<int32_t> mmapSources;
1482      auto& ports = getConfig().ports;
1483      for (const auto& port : ports) {
1484          if (port.flags.getTag() == AudioIoFlags::Tag::input &&
1485              isBitPositionFlagSet(port.flags.get<AudioIoFlags::Tag::input>(),
1486                                   AudioInputFlags::MMAP_NOIRQ)) {
1487              mmapSinks.insert(port.id);
1488          } else if (port.flags.getTag() == AudioIoFlags::Tag::output &&
1489                     isBitPositionFlagSet(port.flags.get<AudioIoFlags::Tag::output>(),
1490                                          AudioOutputFlags::MMAP_NOIRQ)) {
1491              mmapSources.insert(port.id);
1492          }
1493      }
1494      if (mmapSources.empty() && mmapSinks.empty()) {
1495          AudioMMapPolicyInfo never;
1496          never.mmapPolicy = AudioMMapPolicy::NEVER;
1497          _aidl_return->push_back(never);
1498          return ndk::ScopedAStatus::ok();
1499      }
1500      for (const auto& route : getConfig().routes) {
1501          if (mmapSinks.count(route.sinkPortId) != 0) {
1502              // The sink is a mix port, add the sources if they are device ports.
1503              for (int sourcePortId : route.sourcePortIds) {
1504                  auto sourcePortIt = findById<AudioPort>(ports, sourcePortId);
1505                  if (sourcePortIt == ports.end()) {
1506                      // This must not happen
1507                      LOG(ERROR) << __func__ << ": " << mType << ": port id " << sourcePortId
1508                                 << " cannot be found";
1509                      continue;
1510                  }
1511                  if (sourcePortIt->ext.getTag() != AudioPortExt::Tag::device) {
1512                      // The source is not a device port, skip
1513                      continue;
1514                  }
1515                  AudioMMapPolicyInfo policyInfo;
1516                  policyInfo.device = sourcePortIt->ext.get<AudioPortExt::Tag::device>().device;
1517                  // Always return AudioMMapPolicy.AUTO if the device supports mmap for
1518                  // default implementation.
1519                  policyInfo.mmapPolicy = AudioMMapPolicy::AUTO;
1520                  _aidl_return->push_back(policyInfo);
1521              }
1522          } else {
1523              auto sinkPortIt = findById<AudioPort>(ports, route.sinkPortId);
1524              if (sinkPortIt == ports.end()) {
1525                  // This must not happen
1526                  LOG(ERROR) << __func__ << ": " << mType << ": port id " << route.sinkPortId
1527                             << " cannot be found";
1528                  continue;
1529              }
1530              if (sinkPortIt->ext.getTag() != AudioPortExt::Tag::device) {
1531                  // The sink is not a device port, skip
1532                  continue;
1533              }
1534              if (count_any(mmapSources, route.sourcePortIds)) {
1535                  AudioMMapPolicyInfo policyInfo;
1536                  policyInfo.device = sinkPortIt->ext.get<AudioPortExt::Tag::device>().device;
1537                  // Always return AudioMMapPolicy.AUTO if the device supports mmap for
1538                  // default implementation.
1539                  policyInfo.mmapPolicy = AudioMMapPolicy::AUTO;
1540                  _aidl_return->push_back(policyInfo);
1541              }
1542          }
1543      }
1544      return ndk::ScopedAStatus::ok();
1545  }
1546  
supportsVariableLatency(bool * _aidl_return)1547  ndk::ScopedAStatus Module::supportsVariableLatency(bool* _aidl_return) {
1548      LOG(DEBUG) << __func__ << ": " << mType;
1549      *_aidl_return = false;
1550      return ndk::ScopedAStatus::ok();
1551  }
1552  
getAAudioMixerBurstCount(int32_t * _aidl_return)1553  ndk::ScopedAStatus Module::getAAudioMixerBurstCount(int32_t* _aidl_return) {
1554      if (!isMmapSupported()) {
1555          LOG(DEBUG) << __func__ << ": " << mType << ": mmap is not supported ";
1556          return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
1557      }
1558      *_aidl_return = DEFAULT_AAUDIO_MIXER_BURST_COUNT;
1559      LOG(DEBUG) << __func__ << ": " << mType << ": returning " << *_aidl_return;
1560      return ndk::ScopedAStatus::ok();
1561  }
1562  
getAAudioHardwareBurstMinUsec(int32_t * _aidl_return)1563  ndk::ScopedAStatus Module::getAAudioHardwareBurstMinUsec(int32_t* _aidl_return) {
1564      if (!isMmapSupported()) {
1565          LOG(DEBUG) << __func__ << ": " << mType << ": mmap is not supported ";
1566          return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
1567      }
1568      *_aidl_return = DEFAULT_AAUDIO_HARDWARE_BURST_MIN_DURATION_US;
1569      LOG(DEBUG) << __func__ << ": " << mType << ": returning " << *_aidl_return;
1570      return ndk::ScopedAStatus::ok();
1571  }
1572  
isMmapSupported()1573  bool Module::isMmapSupported() {
1574      if (mIsMmapSupported.has_value()) {
1575          return mIsMmapSupported.value();
1576      }
1577      std::vector<AudioMMapPolicyInfo> mmapPolicyInfos;
1578      if (!getMmapPolicyInfos(AudioMMapPolicyType::DEFAULT, &mmapPolicyInfos).isOk()) {
1579          mIsMmapSupported = false;
1580      } else {
1581          mIsMmapSupported =
1582                  std::find_if(mmapPolicyInfos.begin(), mmapPolicyInfos.end(), [](const auto& info) {
1583                      return info.mmapPolicy == AudioMMapPolicy::AUTO ||
1584                             info.mmapPolicy == AudioMMapPolicy::ALWAYS;
1585                  }) != mmapPolicyInfos.end();
1586      }
1587      return mIsMmapSupported.value();
1588  }
1589  
populateConnectedDevicePort(AudioPort * audioPort,int32_t)1590  ndk::ScopedAStatus Module::populateConnectedDevicePort(AudioPort* audioPort, int32_t) {
1591      if (audioPort->ext.getTag() != AudioPortExt::device) {
1592          LOG(ERROR) << __func__ << ": " << mType << ": not a device port: " << audioPort->toString();
1593          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
1594      }
1595      const auto& devicePort = audioPort->ext.get<AudioPortExt::device>();
1596      if (!devicePort.device.type.connection.empty()) {
1597          LOG(ERROR) << __func__ << ": " << mType << ": module implementation must override "
1598                                                    "'populateConnectedDevicePort' "
1599                     << "to handle connection of external devices.";
1600          return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
1601      }
1602      LOG(VERBOSE) << __func__ << ": " << mType << ": do nothing and return ok";
1603      return ndk::ScopedAStatus::ok();
1604  }
1605  
checkAudioPatchEndpointsMatch(const std::vector<AudioPortConfig * > & sources __unused,const std::vector<AudioPortConfig * > & sinks __unused)1606  ndk::ScopedAStatus Module::checkAudioPatchEndpointsMatch(
1607          const std::vector<AudioPortConfig*>& sources __unused,
1608          const std::vector<AudioPortConfig*>& sinks __unused) {
1609      LOG(VERBOSE) << __func__ << ": " << mType << ": do nothing and return ok";
1610      return ndk::ScopedAStatus::ok();
1611  }
1612  
onExternalDeviceConnectionChanged(const::aidl::android::media::audio::common::AudioPort & audioPort __unused,bool connected __unused)1613  void Module::onExternalDeviceConnectionChanged(
1614          const ::aidl::android::media::audio::common::AudioPort& audioPort __unused,
1615          bool connected __unused) {
1616      LOG(DEBUG) << __func__ << ": " << mType << ": do nothing and return";
1617  }
1618  
onPrepareToDisconnectExternalDevice(const::aidl::android::media::audio::common::AudioPort & audioPort __unused)1619  void Module::onPrepareToDisconnectExternalDevice(
1620          const ::aidl::android::media::audio::common::AudioPort& audioPort __unused) {
1621      LOG(DEBUG) << __func__ << ": " << mType << ": do nothing and return";
1622  }
1623  
onMasterMuteChanged(bool mute __unused)1624  ndk::ScopedAStatus Module::onMasterMuteChanged(bool mute __unused) {
1625      LOG(VERBOSE) << __func__ << ": " << mType << ": do nothing and return ok";
1626      return ndk::ScopedAStatus::ok();
1627  }
1628  
onMasterVolumeChanged(float volume __unused)1629  ndk::ScopedAStatus Module::onMasterVolumeChanged(float volume __unused) {
1630      LOG(VERBOSE) << __func__ << ": " << mType << ": do nothing and return ok";
1631      return ndk::ScopedAStatus::ok();
1632  }
1633  
getMicrophoneInfos()1634  std::vector<MicrophoneInfo> Module::getMicrophoneInfos() {
1635      std::vector<MicrophoneInfo> result;
1636      Configuration& config = getConfig();
1637      for (const AudioPort& port : config.ports) {
1638          if (port.ext.getTag() == AudioPortExt::Tag::device) {
1639              const AudioDeviceType deviceType =
1640                      port.ext.get<AudioPortExt::Tag::device>().device.type.type;
1641              if (deviceType == AudioDeviceType::IN_MICROPHONE ||
1642                  deviceType == AudioDeviceType::IN_MICROPHONE_BACK) {
1643                  // Placeholder values. Vendor implementations must populate MicrophoneInfo
1644                  // accordingly based on their physical microphone parameters.
1645                  result.push_back(MicrophoneInfo{
1646                          .id = port.name,
1647                          .device = port.ext.get<AudioPortExt::Tag::device>().device,
1648                          .group = 0,
1649                          .indexInTheGroup = 0,
1650                  });
1651              }
1652          }
1653      }
1654      return result;
1655  }
1656  
bluetoothParametersUpdated()1657  ndk::ScopedAStatus Module::bluetoothParametersUpdated() {
1658      return mStreams.bluetoothParametersUpdated();
1659  }
1660  
1661  }  // namespace aidl::android::hardware::audio::core
1662