1/*
2 * Copyright (C) 2016 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 <common/all-versions/IncludeGuard.h>
18
19#ifdef AUDIO_HAL_VERSION_4_0
20#include <cmath>
21#endif
22
23namespace android {
24namespace hardware {
25namespace audio {
26namespace AUDIO_HAL_VERSION {
27namespace implementation {
28
29PrimaryDevice::PrimaryDevice(audio_hw_device_t* device) : mDevice(new Device(device)) {}
30
31PrimaryDevice::~PrimaryDevice() {}
32
33// Methods from ::android::hardware::audio::AUDIO_HAL_VERSION::IDevice follow.
34Return<Result> PrimaryDevice::initCheck() {
35    return mDevice->initCheck();
36}
37
38Return<Result> PrimaryDevice::setMasterVolume(float volume) {
39    return mDevice->setMasterVolume(volume);
40}
41
42Return<void> PrimaryDevice::getMasterVolume(getMasterVolume_cb _hidl_cb) {
43    return mDevice->getMasterVolume(_hidl_cb);
44}
45
46Return<Result> PrimaryDevice::setMicMute(bool mute) {
47    return mDevice->setMicMute(mute);
48}
49
50Return<void> PrimaryDevice::getMicMute(getMicMute_cb _hidl_cb) {
51    return mDevice->getMicMute(_hidl_cb);
52}
53
54Return<Result> PrimaryDevice::setMasterMute(bool mute) {
55    return mDevice->setMasterMute(mute);
56}
57
58Return<void> PrimaryDevice::getMasterMute(getMasterMute_cb _hidl_cb) {
59    return mDevice->getMasterMute(_hidl_cb);
60}
61
62Return<void> PrimaryDevice::getInputBufferSize(const AudioConfig& config,
63                                               getInputBufferSize_cb _hidl_cb) {
64    return mDevice->getInputBufferSize(config, _hidl_cb);
65}
66
67#ifdef AUDIO_HAL_VERSION_2_0
68Return<void> PrimaryDevice::openOutputStream(int32_t ioHandle, const DeviceAddress& device,
69                                             const AudioConfig& config,
70                                             AudioOutputFlagBitfield flags,
71                                             openOutputStream_cb _hidl_cb) {
72    return mDevice->openOutputStream(ioHandle, device, config, flags, _hidl_cb);
73}
74
75Return<void> PrimaryDevice::openInputStream(int32_t ioHandle, const DeviceAddress& device,
76                                            const AudioConfig& config, AudioInputFlagBitfield flags,
77                                            AudioSource source, openInputStream_cb _hidl_cb) {
78    return mDevice->openInputStream(ioHandle, device, config, flags, source, _hidl_cb);
79}
80#elif defined(AUDIO_HAL_VERSION_4_0)
81Return<void> PrimaryDevice::openOutputStream(int32_t ioHandle, const DeviceAddress& device,
82                                             const AudioConfig& config,
83                                             AudioOutputFlagBitfield flags,
84                                             const SourceMetadata& sourceMetadata,
85                                             openOutputStream_cb _hidl_cb) {
86    return mDevice->openOutputStream(ioHandle, device, config, flags, sourceMetadata, _hidl_cb);
87}
88
89Return<void> PrimaryDevice::openInputStream(int32_t ioHandle, const DeviceAddress& device,
90                                            const AudioConfig& config, AudioInputFlagBitfield flags,
91                                            const SinkMetadata& sinkMetadata,
92                                            openInputStream_cb _hidl_cb) {
93    return mDevice->openInputStream(ioHandle, device, config, flags, sinkMetadata, _hidl_cb);
94}
95#endif
96
97Return<bool> PrimaryDevice::supportsAudioPatches() {
98    return mDevice->supportsAudioPatches();
99}
100
101Return<void> PrimaryDevice::createAudioPatch(const hidl_vec<AudioPortConfig>& sources,
102                                             const hidl_vec<AudioPortConfig>& sinks,
103                                             createAudioPatch_cb _hidl_cb) {
104    return mDevice->createAudioPatch(sources, sinks, _hidl_cb);
105}
106
107Return<Result> PrimaryDevice::releaseAudioPatch(int32_t patch) {
108    return mDevice->releaseAudioPatch(patch);
109}
110
111Return<void> PrimaryDevice::getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb) {
112    return mDevice->getAudioPort(port, _hidl_cb);
113}
114
115Return<Result> PrimaryDevice::setAudioPortConfig(const AudioPortConfig& config) {
116    return mDevice->setAudioPortConfig(config);
117}
118
119Return<Result> PrimaryDevice::setScreenState(bool turnedOn) {
120    return mDevice->setScreenState(turnedOn);
121}
122
123#ifdef AUDIO_HAL_VERSION_2_0
124Return<AudioHwSync> PrimaryDevice::getHwAvSync() {
125    return mDevice->getHwAvSync();
126}
127
128Return<void> PrimaryDevice::getParameters(const hidl_vec<hidl_string>& keys,
129                                          getParameters_cb _hidl_cb) {
130    return mDevice->getParameters(keys, _hidl_cb);
131}
132
133Return<Result> PrimaryDevice::setParameters(const hidl_vec<ParameterValue>& parameters) {
134    return mDevice->setParameters(parameters);
135}
136
137Return<void> PrimaryDevice::debugDump(const hidl_handle& fd) {
138    return mDevice->debugDump(fd);
139}
140#elif defined(AUDIO_HAL_VERSION_4_0)
141Return<void> PrimaryDevice::getHwAvSync(getHwAvSync_cb _hidl_cb) {
142    return mDevice->getHwAvSync(_hidl_cb);
143}
144Return<void> PrimaryDevice::getParameters(const hidl_vec<ParameterValue>& context,
145                                          const hidl_vec<hidl_string>& keys,
146                                          getParameters_cb _hidl_cb) {
147    return mDevice->getParameters(context, keys, _hidl_cb);
148}
149Return<Result> PrimaryDevice::setParameters(const hidl_vec<ParameterValue>& context,
150                                            const hidl_vec<ParameterValue>& parameters) {
151    return mDevice->setParameters(context, parameters);
152}
153Return<void> PrimaryDevice::getMicrophones(getMicrophones_cb _hidl_cb) {
154    return mDevice->getMicrophones(_hidl_cb);
155}
156Return<Result> PrimaryDevice::setConnectedState(const DeviceAddress& address, bool connected) {
157    return mDevice->setConnectedState(address, connected);
158}
159#endif
160
161// Methods from ::android::hardware::audio::AUDIO_HAL_VERSION::IPrimaryDevice follow.
162Return<Result> PrimaryDevice::setVoiceVolume(float volume) {
163    if (!isGainNormalized(volume)) {
164        ALOGW("Can not set a voice volume (%f) outside [0,1]", volume);
165        return Result::INVALID_ARGUMENTS;
166    }
167    return mDevice->analyzeStatus("set_voice_volume",
168                                  mDevice->device()->set_voice_volume(mDevice->device(), volume));
169}
170
171Return<Result> PrimaryDevice::setMode(AudioMode mode) {
172    // INVALID, CURRENT, CNT, MAX are reserved for internal use.
173    // TODO: remove the values from the HIDL interface
174    switch (mode) {
175        case AudioMode::NORMAL:
176        case AudioMode::RINGTONE:
177        case AudioMode::IN_CALL:
178        case AudioMode::IN_COMMUNICATION:
179            break;  // Valid values
180        default:
181            return Result::INVALID_ARGUMENTS;
182    };
183
184    return mDevice->analyzeStatus(
185        "set_mode",
186        mDevice->device()->set_mode(mDevice->device(), static_cast<audio_mode_t>(mode)));
187}
188
189Return<void> PrimaryDevice::getBtScoNrecEnabled(getBtScoNrecEnabled_cb _hidl_cb) {
190    bool enabled;
191    Result retval = mDevice->getParam(AudioParameter::keyBtNrec, &enabled);
192    _hidl_cb(retval, enabled);
193    return Void();
194}
195
196Return<Result> PrimaryDevice::setBtScoNrecEnabled(bool enabled) {
197    return mDevice->setParam(AudioParameter::keyBtNrec, enabled);
198}
199
200Return<void> PrimaryDevice::getBtScoWidebandEnabled(getBtScoWidebandEnabled_cb _hidl_cb) {
201    bool enabled;
202    Result retval = mDevice->getParam(AUDIO_PARAMETER_KEY_BT_SCO_WB, &enabled);
203    _hidl_cb(retval, enabled);
204    return Void();
205}
206
207Return<Result> PrimaryDevice::setBtScoWidebandEnabled(bool enabled) {
208    return mDevice->setParam(AUDIO_PARAMETER_KEY_BT_SCO_WB, enabled);
209}
210
211static const char* convertTtyModeFromHIDL(IPrimaryDevice::TtyMode mode) {
212    switch (mode) {
213        case IPrimaryDevice::TtyMode::OFF:
214            return AUDIO_PARAMETER_VALUE_TTY_OFF;
215        case IPrimaryDevice::TtyMode::VCO:
216            return AUDIO_PARAMETER_VALUE_TTY_VCO;
217        case IPrimaryDevice::TtyMode::HCO:
218            return AUDIO_PARAMETER_VALUE_TTY_HCO;
219        case IPrimaryDevice::TtyMode::FULL:
220            return AUDIO_PARAMETER_VALUE_TTY_FULL;
221        default:
222            return nullptr;
223    }
224}
225static IPrimaryDevice::TtyMode convertTtyModeToHIDL(const char* halMode) {
226    if (strcmp(halMode, AUDIO_PARAMETER_VALUE_TTY_OFF) == 0)
227        return IPrimaryDevice::TtyMode::OFF;
228    else if (strcmp(halMode, AUDIO_PARAMETER_VALUE_TTY_VCO) == 0)
229        return IPrimaryDevice::TtyMode::VCO;
230    else if (strcmp(halMode, AUDIO_PARAMETER_VALUE_TTY_HCO) == 0)
231        return IPrimaryDevice::TtyMode::HCO;
232    else if (strcmp(halMode, AUDIO_PARAMETER_VALUE_TTY_FULL) == 0)
233        return IPrimaryDevice::TtyMode::FULL;
234    return IPrimaryDevice::TtyMode(-1);
235}
236
237Return<void> PrimaryDevice::getTtyMode(getTtyMode_cb _hidl_cb) {
238    String8 halMode;
239    Result retval = mDevice->getParam(AUDIO_PARAMETER_KEY_TTY_MODE, &halMode);
240    if (retval != Result::OK) {
241        _hidl_cb(retval, TtyMode::OFF);
242        return Void();
243    }
244    TtyMode mode = convertTtyModeToHIDL(halMode);
245    if (mode == TtyMode(-1)) {
246        ALOGE("HAL returned invalid TTY value: %s", halMode.c_str());
247        _hidl_cb(Result::INVALID_STATE, TtyMode::OFF);
248        return Void();
249    }
250    _hidl_cb(Result::OK, mode);
251    return Void();
252}
253
254Return<Result> PrimaryDevice::setTtyMode(IPrimaryDevice::TtyMode mode) {
255    const char* modeStr = convertTtyModeFromHIDL(mode);
256    if (modeStr == nullptr) {
257        ALOGW("Can not set an invalid TTY value: %d", mode);
258        return Result::INVALID_ARGUMENTS;
259    }
260    return mDevice->setParam(AUDIO_PARAMETER_KEY_TTY_MODE, modeStr);
261}
262
263Return<void> PrimaryDevice::getHacEnabled(getHacEnabled_cb _hidl_cb) {
264    bool enabled;
265    Result retval = mDevice->getParam(AUDIO_PARAMETER_KEY_HAC, &enabled);
266    _hidl_cb(retval, enabled);
267    return Void();
268}
269
270Return<Result> PrimaryDevice::setHacEnabled(bool enabled) {
271    return mDevice->setParam(AUDIO_PARAMETER_KEY_HAC, enabled);
272}
273
274#ifdef AUDIO_HAL_VERSION_4_0
275Return<Result> PrimaryDevice::setBtScoHeadsetDebugName(const hidl_string& name) {
276    return mDevice->setParam(AUDIO_PARAMETER_KEY_BT_SCO_HEADSET_NAME, name.c_str());
277}
278Return<void> PrimaryDevice::getBtHfpEnabled(getBtHfpEnabled_cb _hidl_cb) {
279    bool enabled;
280    Result retval = mDevice->getParam(AUDIO_PARAMETER_KEY_HFP_ENABLE, &enabled);
281    _hidl_cb(retval, enabled);
282    return Void();
283}
284Return<Result> PrimaryDevice::setBtHfpEnabled(bool enabled) {
285    return mDevice->setParam(AUDIO_PARAMETER_KEY_HFP_ENABLE, enabled);
286}
287Return<Result> PrimaryDevice::setBtHfpSampleRate(uint32_t sampleRateHz) {
288    return mDevice->setParam(AUDIO_PARAMETER_KEY_HFP_SET_SAMPLING_RATE, int(sampleRateHz));
289}
290Return<Result> PrimaryDevice::setBtHfpVolume(float volume) {
291    if (!isGainNormalized(volume)) {
292        ALOGW("Can not set BT HFP volume (%f) outside [0,1]", volume);
293        return Result::INVALID_ARGUMENTS;
294    }
295    // Map the normalized volume onto the range of [0, 15]
296    return mDevice->setParam(AUDIO_PARAMETER_KEY_HFP_VOLUME,
297                             static_cast<int>(std::round(volume * 15)));
298}
299Return<Result> PrimaryDevice::updateRotation(IPrimaryDevice::Rotation rotation) {
300    // legacy API expects the rotation in degree
301    return mDevice->setParam(AUDIO_PARAMETER_KEY_ROTATION, int(rotation) * 90);
302}
303#endif
304
305Return<void> PrimaryDevice::debug(const hidl_handle& fd, const hidl_vec<hidl_string>& options) {
306    return mDevice->debug(fd, options);
307}
308
309}  // namespace implementation
310}  // namespace AUDIO_HAL_VERSION
311}  // namespace audio
312}  // namespace hardware
313}  // namespace android
314