1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "AudioPolicyManagerInterface.h"
#include "Gains.h"
#include <AudioGain.h>
#include <policy.h>
namespace android
{
class AudioPolicyManagerObserver;
namespace audio_policy
{
class Engine
{
public:
Engine();
virtual ~Engine();
template <class RequestedInterface>
RequestedInterface *queryInterface();
private:
/// Interface members
class ManagerInterfaceImpl : public AudioPolicyManagerInterface
{
public:
ManagerInterfaceImpl(Engine *policyEngine)
: mPolicyEngine(policyEngine) {}
virtual void setObserver(AudioPolicyManagerObserver *observer)
{
mPolicyEngine->setObserver(observer);
}
virtual status_t initCheck()
{
return mPolicyEngine->initCheck();
}
virtual audio_devices_t getDeviceForInputSource(audio_source_t inputSource) const
{
return mPolicyEngine->getDeviceForInputSource(inputSource);
}
virtual audio_devices_t getDeviceForStrategy(routing_strategy strategy) const
{
return mPolicyEngine->getDeviceForStrategy(strategy);
}
virtual routing_strategy getStrategyForStream(audio_stream_type_t stream)
{
return mPolicyEngine->getStrategyForStream(stream);
}
virtual routing_strategy getStrategyForUsage(audio_usage_t usage)
{
return mPolicyEngine->getStrategyForUsage(usage);
}
virtual status_t setPhoneState(audio_mode_t mode)
{
return mPolicyEngine->setPhoneState(mode);
}
virtual audio_mode_t getPhoneState() const
{
return mPolicyEngine->getPhoneState();
}
virtual status_t setForceUse(audio_policy_force_use_t usage,
audio_policy_forced_cfg_t config)
{
return mPolicyEngine->setForceUse(usage, config);
}
virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) const
{
return mPolicyEngine->getForceUse(usage);
}
virtual status_t setDeviceConnectionState(const sp<DeviceDescriptor> /*devDesc*/,
audio_policy_dev_state_t /*state*/)
{
return NO_ERROR;
}
virtual status_t initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax)
{
return mPolicyEngine->initStreamVolume(stream, indexMin, indexMax);
}
virtual void initializeVolumeCurves(bool isSpeakerDrcEnabled)
{
return mPolicyEngine->initializeVolumeCurves(isSpeakerDrcEnabled);
}
virtual float volIndexToAmpl(Volume::device_category deviceCategory,
audio_stream_type_t stream,int indexInUi)
{
return mPolicyEngine->volIndexToAmpl(deviceCategory, stream, indexInUi);
}
private:
Engine *mPolicyEngine;
} mManagerInterface;
private:
/* Copy facilities are put private to disable copy. */
Engine(const Engine &object);
Engine &operator=(const Engine &object);
void setObserver(AudioPolicyManagerObserver *observer);
status_t initCheck();
inline bool isInCall() const
{
return is_state_in_call(mPhoneState);
}
status_t setPhoneState(audio_mode_t mode);
audio_mode_t getPhoneState() const
{
return mPhoneState;
}
status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config);
audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) const
{
return mForceUse[usage];
}
status_t setDefaultDevice(audio_devices_t device);
routing_strategy getStrategyForStream(audio_stream_type_t stream);
routing_strategy getStrategyForUsage(audio_usage_t usage);
audio_devices_t getDeviceForStrategy(routing_strategy strategy) const;
audio_devices_t getDeviceForInputSource(audio_source_t inputSource) const;
float volIndexToAmpl(Volume::device_category category,
audio_stream_type_t stream, int indexInUi);
status_t initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax);
void initializeVolumeCurves(bool isSpeakerDrcEnabled);
audio_mode_t mPhoneState; /**< current phone state. */
/** current forced use configuration. */
audio_policy_forced_cfg_t mForceUse[AUDIO_POLICY_FORCE_USE_CNT];
AudioPolicyManagerObserver *mApmObserver;
};
} // namespace audio_policy
} // namespace android
|
