1 /* 2 * Copyright (C) 2015 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 #pragma once 18 19 #include "DeviceDescriptor.h" 20 #include "AudioRoute.h" 21 #include <utils/RefBase.h> 22 #include <utils/String8.h> 23 #include <utils/Errors.h> 24 #include <utils/Vector.h> 25 #include <system/audio.h> 26 #include <cutils/config_utils.h> 27 #include <string> 28 29 namespace android { 30 31 class IOProfile; 32 class InputProfile; 33 class OutputProfile; 34 35 typedef Vector<sp<IOProfile> > InputProfileCollection; 36 typedef Vector<sp<IOProfile> > OutputProfileCollection; 37 typedef Vector<sp<IOProfile> > IOProfileCollection; 38 39 class HwModule : public RefBase 40 { 41 public: 42 explicit HwModule(const char *name, uint32_t halVersionMajor, uint32_t halVersionMinor); 43 HwModule(const char *name, uint32_t halVersion = 0); 44 ~HwModule(); 45 getName()46 const char *getName() const { return mName.c_str(); } 47 getDeclaredDevices()48 const DeviceVector &getDeclaredDevices() const { return mDeclaredDevices; } 49 void setDeclaredDevices(const DeviceVector &devices); getAllDevices()50 DeviceVector getAllDevices() const 51 { 52 DeviceVector devices = mDeclaredDevices; 53 devices.merge(mDynamicDevices); 54 return devices; 55 } 56 std::string getTagForDevice(audio_devices_t device, 57 const String8 &address = String8(), 58 audio_format_t codec = AUDIO_FORMAT_DEFAULT); addDynamicDevice(const sp<DeviceDescriptor> & device)59 void addDynamicDevice(const sp<DeviceDescriptor> &device) 60 { 61 device->setDynamic(); 62 mDynamicDevices.add(device); 63 } 64 removeDynamicDevice(const sp<DeviceDescriptor> & device)65 bool removeDynamicDevice(const sp<DeviceDescriptor> &device) 66 { 67 return mDynamicDevices.remove(device) >= 0; 68 } getDynamicDevices()69 DeviceVector getDynamicDevices() const { return mDynamicDevices; } 70 getInputProfiles()71 const InputProfileCollection &getInputProfiles() const { return mInputProfiles; } getOutputProfiles()72 const OutputProfileCollection &getOutputProfiles() const { return mOutputProfiles; } 73 74 void setProfiles(const IOProfileCollection &profiles); 75 setHalVersion(uint32_t major,uint32_t minor)76 void setHalVersion(uint32_t major, uint32_t minor) { 77 mHalVersion = (major << 8) | (minor & 0xff); 78 } getHalVersionMajor()79 uint32_t getHalVersionMajor() const { return mHalVersion >> 8; } getHalVersionMinor()80 uint32_t getHalVersionMinor() const { return mHalVersion & 0xff; } 81 82 sp<DeviceDescriptor> getRouteSinkDevice(const sp<AudioRoute> &route) const; 83 DeviceVector getRouteSourceDevices(const sp<AudioRoute> &route) const; getRoutes()84 const AudioRouteVector& getRoutes() const { return mRoutes; } 85 void setRoutes(const AudioRouteVector &routes); 86 87 status_t addOutputProfile(const sp<IOProfile> &profile); 88 status_t addInputProfile(const sp<IOProfile> &profile); 89 status_t addProfile(const sp<IOProfile> &profile); 90 91 status_t addOutputProfile(const std::string& name, const audio_config_t *config, 92 audio_devices_t device, const String8& address, 93 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE); 94 status_t removeOutputProfile(const std::string& name); 95 status_t addInputProfile(const std::string& name, const audio_config_t *config, 96 audio_devices_t device, const String8& address, 97 audio_input_flags_t flags = AUDIO_INPUT_FLAG_NONE); 98 status_t removeInputProfile(const std::string& name); 99 getHandle()100 audio_module_handle_t getHandle() const { return mHandle; } 101 void setHandle(audio_module_handle_t handle); 102 findPortByTagName(const std::string & tagName)103 sp<PolicyAudioPort> findPortByTagName(const std::string &tagName) const 104 { 105 return findByTagName(mPorts, tagName); 106 } 107 108 /** 109 * @brief supportsPatch checks if an audio patch between 2 ports beloging to this HwModule 110 * is supported by a HwModule. The ports and the route shall be declared in the 111 * audio_policy_configuration.xml file. 112 * @param srcPort (aka the source) to be considered 113 * @param dstPort (aka the sink) to be considered 114 * @return true if the HwModule supports the connection between the sink and the source, 115 * false otherwise 116 */ 117 bool supportsPatch(const sp<PolicyAudioPort> &srcPort, 118 const sp<PolicyAudioPort> &dstPort) const; 119 120 // TODO remove from here (split serialization) 121 void dump(String8 *dst, int spaces) const; 122 123 private: 124 void refreshSupportedDevices(); 125 126 const String8 mName; // base name of the audio HW module (primary, a2dp ...) 127 audio_module_handle_t mHandle; 128 OutputProfileCollection mOutputProfiles; // output profiles exposed by this module 129 InputProfileCollection mInputProfiles; // input profiles exposed by this module 130 uint32_t mHalVersion; // audio HAL API version 131 DeviceVector mDeclaredDevices; // devices declared in audio_policy configuration file. 132 DeviceVector mDynamicDevices; /**< devices that can be added/removed at runtime (e.g. rsbumix)*/ 133 AudioRouteVector mRoutes; 134 PolicyAudioPortVector mPorts; 135 }; 136 137 class HwModuleCollection : public Vector<sp<HwModule> > 138 { 139 public: 140 sp<HwModule> getModuleFromName(const char *name) const; 141 142 /** 143 * @brief getModuleForDeviceType try to get a device from type / format on all modules 144 * @param device type to consider 145 * @param encodedFormat to consider 146 * @param[out] tagName if not null, if a matching device is found, will return the tagName 147 * of original device from XML file so that audio routes matchin rules work. 148 * @return valid module if considered device found, nullptr otherwise. 149 */ 150 sp<HwModule> getModuleForDeviceType(audio_devices_t device, 151 audio_format_t encodedFormat, 152 std::string *tagName = nullptr) const; 153 154 sp<HwModule> getModuleForDevice(const sp<DeviceDescriptor> &device, 155 audio_format_t encodedFormat) const; 156 157 DeviceVector getAvailableDevicesFromModuleName(const char *name, 158 const DeviceVector &availableDevices) const; 159 160 /** 161 * @brief getDeviceDescriptor returns a device descriptor associated to the device type and 162 * device address (if matchAddress is true). 163 * It may loop twice on all modules to check if allowToCreate is true 164 * -first loop will check if the device is found on a module since declared in the list 165 * of device port in configuration file 166 * -(allowToCreate is true)second loop will check if the device is weakly supported by one 167 * or more profiles on a given module and will add as a supported device for this module. 168 * The device will also be added to the dynamic list of device of this module 169 * @param type of the device requested 170 * @param address of the device requested 171 * @param name of the device that requested 172 * @param encodedFormat if not AUDIO_FORMAT_DEFAULT, must match one supported format 173 * @param matchAddress true if a strong match is required 174 * @param allowToCreate true if allowed to create dynamic device (e.g. hdmi, usb...) 175 * @return device descriptor associated to the type (and address if matchAddress is true) 176 */ 177 sp<DeviceDescriptor> getDeviceDescriptor(const audio_devices_t type, 178 const char *address, 179 const char *name, 180 audio_format_t encodedFormat, 181 bool allowToCreate = false, 182 bool matchAddress = true) const; 183 184 /** 185 * @brief createDevice creates a new device from the type and address given. It checks that 186 * according to the device type, a module is supporting this device (weak check). 187 * This concerns only dynamic device, aka device with a specific address and not 188 * already supported by module/underlying profiles. 189 * @param type of the device to be created 190 * @param address of the device to be created 191 * @param name of the device to be created 192 * @return device descriptor if a module is supporting this type, nullptr otherwise. 193 */ 194 sp<DeviceDescriptor> createDevice(const audio_devices_t type, 195 const char *address, 196 const char *name, 197 const audio_format_t encodedFormat) const; 198 199 /** 200 * @brief cleanUpForDevice: loop on all profiles of all modules to remove device from 201 * the list of supported device. If this device is a dynamic device (aka a device not in the 202 * xml file with a runtime address), it is also removed from the module collection of dynamic 203 * devices. 204 * @param device that has been disconnected 205 */ 206 void cleanUpForDevice(const sp<DeviceDescriptor> &device); 207 208 void dump(String8 *dst) const; 209 }; 210 211 } // namespace android 212