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 
20 #include <AudioPolicyManagerInterface.h>
21 #include <AudioPolicyPluginInterface.h>
22 #include "Collection.h"
23 
24 namespace android
25 {
26 class AudioPolicyManagerObserver;
27 
28 namespace audio_policy
29 {
30 
31 class ParameterManagerWrapper;
32 class VolumeProfile;
33 
34 class Engine
35 {
36 public:
37     Engine();
38     virtual ~Engine();
39 
40     template <class RequestedInterface>
41     RequestedInterface *queryInterface();
42 
43 private:
44     /// Interface members
45     class ManagerInterfaceImpl : public AudioPolicyManagerInterface
46     {
47     public:
ManagerInterfaceImpl(Engine * policyEngine)48         ManagerInterfaceImpl(Engine *policyEngine)
49             : mPolicyEngine(policyEngine) {}
50 
initCheck()51         virtual android::status_t initCheck()
52         {
53             return mPolicyEngine->initCheck();
54         }
setObserver(AudioPolicyManagerObserver * observer)55         virtual void setObserver(AudioPolicyManagerObserver *observer)
56         {
57             mPolicyEngine->setObserver(observer);
58         }
getDeviceForInputSource(audio_source_t inputSource)59         virtual audio_devices_t getDeviceForInputSource(audio_source_t inputSource) const
60         {
61             return mPolicyEngine->getPropertyForKey<audio_devices_t, audio_source_t>(inputSource);
62         }
63         virtual audio_devices_t getDeviceForStrategy(routing_strategy stategy) const;
getStrategyForStream(audio_stream_type_t stream)64         virtual routing_strategy getStrategyForStream(audio_stream_type_t stream)
65         {
66             return mPolicyEngine->getPropertyForKey<routing_strategy, audio_stream_type_t>(stream);
67         }
68         virtual routing_strategy getStrategyForUsage(audio_usage_t usage);
setPhoneState(audio_mode_t mode)69         virtual status_t setPhoneState(audio_mode_t mode)
70         {
71             return mPolicyEngine->setPhoneState(mode);
72         }
getPhoneState()73         virtual audio_mode_t getPhoneState() const
74         {
75             return mPolicyEngine->getPhoneState();
76         }
setForceUse(audio_policy_force_use_t usage,audio_policy_forced_cfg_t config)77         virtual status_t setForceUse(audio_policy_force_use_t usage,
78                                               audio_policy_forced_cfg_t config)
79         {
80             return mPolicyEngine->setForceUse(usage, config);
81         }
getForceUse(audio_policy_force_use_t usage)82         virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) const
83         {
84             return mPolicyEngine->getForceUse(usage);
85         }
setDeviceConnectionState(const sp<DeviceDescriptor> devDesc,audio_policy_dev_state_t state)86         virtual android::status_t setDeviceConnectionState(const sp<DeviceDescriptor> devDesc,
87                                                            audio_policy_dev_state_t state)
88         {
89             return mPolicyEngine->setDeviceConnectionState(devDesc, state);
90         }
91 
92     private:
93         Engine *mPolicyEngine;
94     } mManagerInterface;
95 
96     class PluginInterfaceImpl : public AudioPolicyPluginInterface
97     {
98     public:
PluginInterfaceImpl(Engine * policyEngine)99         PluginInterfaceImpl(Engine *policyEngine)
100             : mPolicyEngine(policyEngine) {}
101 
addStrategy(const std::string & name,routing_strategy strategy)102         virtual status_t addStrategy(const std::string &name, routing_strategy strategy)
103         {
104             return mPolicyEngine->add<routing_strategy>(name, strategy);
105         }
addStream(const std::string & name,audio_stream_type_t stream)106         virtual status_t addStream(const std::string &name, audio_stream_type_t stream)
107         {
108             return mPolicyEngine->add<audio_stream_type_t>(name, stream);
109         }
addUsage(const std::string & name,audio_usage_t usage)110         virtual status_t addUsage(const std::string &name, audio_usage_t usage)
111         {
112             return mPolicyEngine->add<audio_usage_t>(name, usage);
113         }
addInputSource(const std::string & name,audio_source_t source)114         virtual status_t addInputSource(const std::string &name, audio_source_t source)
115         {
116             return mPolicyEngine->add<audio_source_t>(name, source);
117         }
setDeviceForStrategy(const routing_strategy & strategy,audio_devices_t devices)118         virtual bool setDeviceForStrategy(const routing_strategy &strategy, audio_devices_t devices)
119         {
120             return mPolicyEngine->setPropertyForKey<audio_devices_t, routing_strategy>(devices,
121                                                                                        strategy);
122         }
setStrategyForStream(const audio_stream_type_t & stream,routing_strategy strategy)123         virtual bool setStrategyForStream(const audio_stream_type_t &stream,
124                                           routing_strategy strategy)
125         {
126             return mPolicyEngine->setPropertyForKey<routing_strategy, audio_stream_type_t>(strategy,
127                                                                                            stream);
128         }
129         virtual bool setVolumeProfileForStream(const audio_stream_type_t &stream,
130                                                const audio_stream_type_t &volumeProfile);
131 
setStrategyForUsage(const audio_usage_t & usage,routing_strategy strategy)132         virtual bool setStrategyForUsage(const audio_usage_t &usage, routing_strategy strategy)
133         {
134             return mPolicyEngine->setPropertyForKey<routing_strategy, audio_usage_t>(strategy,
135                                                                                      usage);
136         }
setDeviceForInputSource(const audio_source_t & inputSource,audio_devices_t device)137         virtual bool setDeviceForInputSource(const audio_source_t &inputSource,
138                                              audio_devices_t device)
139         {
140             return mPolicyEngine->setPropertyForKey<audio_devices_t, audio_source_t>(device,
141                                                                                      inputSource);
142         }
143 
144     private:
145         Engine *mPolicyEngine;
146     } mPluginInterface;
147 
148 private:
149     /* Copy facilities are put private to disable copy. */
150     Engine(const Engine &object);
151     Engine &operator=(const Engine &object);
152 
153     void setObserver(AudioPolicyManagerObserver *observer);
154 
155     bool setVolumeProfileForStream(const audio_stream_type_t &stream,
156                                    device_category deviceCategory,
157                                    const VolumeCurvePoints &points);
158 
159     status_t initCheck();
160     status_t setPhoneState(audio_mode_t mode);
161     audio_mode_t getPhoneState() const;
162     status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config);
163     audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) const;
164     status_t setDeviceConnectionState(const sp<DeviceDescriptor> devDesc,
165                                       audio_policy_dev_state_t state);
166     StrategyCollection mStrategyCollection; /**< Strategies indexed by their enum id. */
167     StreamCollection mStreamCollection; /**< Streams indexed by their enum id.  */
168     UsageCollection mUsageCollection; /**< Usages indexed by their enum id. */
169     InputSourceCollection mInputSourceCollection; /**< Input sources indexed by their enum id. */
170 
171     template <typename Key>
172     status_t add(const std::string &name, const Key &key);
173 
174     template <typename Key>
175     Element<Key> *getFromCollection(const Key &key) const;
176 
177     template <typename Key>
178     const Collection<Key> &getCollection() const;
179 
180     template <typename Key>
181     Collection<Key> &getCollection();
182 
183     template <typename Property, typename Key>
184     Property getPropertyForKey(Key key) const;
185 
186     template <typename Property, typename Key>
187     bool setPropertyForKey(const Property &property, const Key &key);
188 
189     /**
190      * Policy Parameter Manager hidden through a wrapper.
191      */
192     ParameterManagerWrapper *mPolicyParameterMgr;
193 
194     AudioPolicyManagerObserver *mApmObserver;
195 };
196 
197 }; // namespace audio_policy
198 
199 }; // namespace android
200 
201