1 /*
2 * Copyright (C) 2017 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 <cstring>
18 #include <memory>
19 #include <string>
20 #include <sys/wait.h>
21 #include <unistd.h>
22
23 #include <gtest/gtest.h>
24 #include <gmock/gmock.h>
25
26 #define LOG_TAG "APM_Test"
27 #include <Serializer.h>
28 #include <android-base/file.h>
29 #include <android-base/properties.h>
30 #include <android/content/AttributionSourceState.h>
31 #include <android_media_audiopolicy.h>
32 #include <com_android_media_audioserver.h>
33 #include <flag_macros.h>
34 #include <hardware/audio_effect.h>
35 #include <media/AudioPolicy.h>
36 #include <media/PatchBuilder.h>
37 #include <media/RecordingActivityTracker.h>
38 #include <media/TypeConverter.h>
39 #include <utils/Log.h>
40 #include <utils/Vector.h>
41 #include <cutils/multiuser.h>
42
43 #include "AudioPolicyInterface.h"
44 #include "AudioPolicyManagerTestClient.h"
45 #include "AudioPolicyTestClient.h"
46 #include "AudioPolicyTestManager.h"
47 #include "test_execution_tracer.h"
48
49 using namespace android;
50 using testing::UnorderedElementsAre;
51 using testing::IsEmpty;
52 using android::content::AttributionSourceState;
53
54 namespace {
55
createUidCriterion(uint32_t uid,bool exclude=false)56 AudioMixMatchCriterion createUidCriterion(uint32_t uid, bool exclude = false) {
57 AudioMixMatchCriterion criterion;
58 criterion.mValue.mUid = uid;
59 criterion.mRule = exclude ? RULE_EXCLUDE_UID : RULE_MATCH_UID;
60 return criterion;
61 }
62
createUserIdCriterion(int userId,bool exclude=false)63 AudioMixMatchCriterion createUserIdCriterion(int userId, bool exclude = false) {
64 AudioMixMatchCriterion criterion;
65 criterion.mValue.mUserId = userId;
66 criterion.mRule = exclude ? RULE_EXCLUDE_USERID : RULE_MATCH_USERID;
67 return criterion;
68 }
69
createUsageCriterion(audio_usage_t usage,bool exclude=false)70 AudioMixMatchCriterion createUsageCriterion(audio_usage_t usage, bool exclude = false) {
71 AudioMixMatchCriterion criterion;
72 criterion.mValue.mUsage = usage;
73 criterion.mRule = exclude ? RULE_EXCLUDE_ATTRIBUTE_USAGE : RULE_MATCH_ATTRIBUTE_USAGE;
74 return criterion;
75 }
76
createCapturePresetCriterion(audio_source_t source,bool exclude=false)77 AudioMixMatchCriterion createCapturePresetCriterion(audio_source_t source, bool exclude = false) {
78 AudioMixMatchCriterion criterion;
79 criterion.mValue.mSource = source;
80 criterion.mRule = exclude ?
81 RULE_EXCLUDE_ATTRIBUTE_CAPTURE_PRESET : RULE_MATCH_ATTRIBUTE_CAPTURE_PRESET;
82 return criterion;
83 }
84
createSessionIdCriterion(audio_session_t session,bool exclude=false)85 AudioMixMatchCriterion createSessionIdCriterion(audio_session_t session, bool exclude = false) {
86 AudioMixMatchCriterion criterion;
87 criterion.mValue.mAudioSessionId = session;
88 criterion.mRule = exclude ?
89 RULE_EXCLUDE_AUDIO_SESSION_ID : RULE_MATCH_AUDIO_SESSION_ID;
90 return criterion;
91 }
92
93 // TODO b/182392769: use attribution source util
createAttributionSourceState(uid_t uid)94 AttributionSourceState createAttributionSourceState(uid_t uid) {
95 AttributionSourceState attributionSourceState;
96 attributionSourceState.uid = uid;
97 attributionSourceState.token = sp<BBinder>::make();
98 return attributionSourceState;
99 }
100 } // namespace
101
TEST(AudioPolicyConfigTest,DefaultConfigForTestsIsEmpty)102 TEST(AudioPolicyConfigTest, DefaultConfigForTestsIsEmpty) {
103 auto config = AudioPolicyConfig::createWritableForTests();
104 EXPECT_TRUE(config->getSource().empty());
105 EXPECT_TRUE(config->getHwModules().isEmpty());
106 EXPECT_TRUE(config->getInputDevices().isEmpty());
107 EXPECT_TRUE(config->getOutputDevices().isEmpty());
108 }
109
TEST(AudioPolicyConfigTest,FallbackToDefault)110 TEST(AudioPolicyConfigTest, FallbackToDefault) {
111 auto config = AudioPolicyConfig::loadFromApmXmlConfigWithFallback(
112 base::GetExecutableDirectory() + "/test_invalid_audio_policy_configuration.xml");
113 EXPECT_EQ(AudioPolicyConfig::kDefaultConfigSource, config->getSource());
114 }
115
TEST(AudioPolicyConfigTest,LoadForTests)116 TEST(AudioPolicyConfigTest, LoadForTests) {
117 {
118 auto result = AudioPolicyConfig::loadFromCustomXmlConfigForTests(
119 base::GetExecutableDirectory() + "/test_invalid_audio_policy_configuration.xml");
120 EXPECT_FALSE(result.ok());
121 }
122 {
123 const std::string source =
124 base::GetExecutableDirectory() + "/test_audio_policy_configuration.xml";
125 auto result = AudioPolicyConfig::loadFromCustomXmlConfigForTests(source);
126 ASSERT_TRUE(result.ok());
127 EXPECT_EQ(source, result.value()->getSource());
128 EXPECT_FALSE(result.value()->getHwModules().isEmpty());
129 EXPECT_FALSE(result.value()->getInputDevices().isEmpty());
130 EXPECT_FALSE(result.value()->getOutputDevices().isEmpty());
131 }
132 }
133
TEST(AudioPolicyManagerTestInit,EngineFailure)134 TEST(AudioPolicyManagerTestInit, EngineFailure) {
135 AudioPolicyTestClient client;
136 auto config = AudioPolicyConfig::createWritableForTests();
137 config->setDefault();
138 config->setEngineLibraryNameSuffix("non-existent");
139 AudioPolicyTestManager manager(config, &client);
140 ASSERT_EQ(NO_INIT, manager.initialize());
141 ASSERT_EQ(NO_INIT, manager.initCheck());
142 }
143
TEST(AudioPolicyManagerTestInit,ClientFailure)144 TEST(AudioPolicyManagerTestInit, ClientFailure) {
145 AudioPolicyTestClient client;
146 AudioPolicyTestManager manager(&client);
147 // Since the default client fails to open anything,
148 // APM should indicate that the initialization didn't succeed.
149 ASSERT_EQ(NO_INIT, manager.initialize());
150 ASSERT_EQ(NO_INIT, manager.initCheck());
151 }
152
153
154 class PatchCountCheck {
155 public:
PatchCountCheck(AudioPolicyManagerTestClient * client)156 explicit PatchCountCheck(AudioPolicyManagerTestClient *client)
157 : mClient{client},
158 mInitialCount{mClient->getActivePatchesCount()} {}
deltaFromSnapshot() const159 int deltaFromSnapshot() const {
160 size_t currentCount = mClient->getActivePatchesCount();
161 if (mInitialCount <= currentCount) {
162 return currentCount - mInitialCount;
163 } else {
164 return -(static_cast<int>(mInitialCount - currentCount));
165 }
166 }
167 private:
168 const AudioPolicyManagerTestClient *mClient;
169 const size_t mInitialCount;
170 };
171
172 class AudioPolicyManagerTest : public testing::Test {
173 public:
174 constexpr static uint32_t k384000SamplingRate = 384000;
175 constexpr static uint32_t k48000SamplingRate = 48000;
176 constexpr static uint32_t k96000SamplingRate = 96000;
177
178 protected:
179 void SetUp() override;
180 void TearDown() override;
181 virtual void SetUpManagerConfig();
getEngineConfigFilePath() const182 virtual std::string getEngineConfigFilePath() const { return sTestEngineConfig; }
183
184 void dumpToLog();
185 // When explicit routing is needed, selectedDeviceId needs to be set as the wanted port
186 // id. Otherwise, selectedDeviceId needs to be initialized as AUDIO_PORT_HANDLE_NONE.
187 void getOutputForAttr(
188 DeviceIdVector *selectedDeviceIds,
189 audio_format_t format,
190 audio_channel_mask_t channelMask,
191 int sampleRate,
192 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE,
193 audio_io_handle_t *output = nullptr,
194 audio_port_handle_t *portId = nullptr,
195 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER,
196 audio_session_t session = AUDIO_SESSION_NONE,
197 int uid = 0,
198 bool* isBitPerfect = nullptr);
199 void getInputForAttr(
200 const audio_attributes_t &attr,
201 audio_io_handle_t *input,
202 audio_session_t session,
203 audio_unique_id_t riid,
204 audio_port_handle_t *selectedDeviceId,
205 audio_format_t format,
206 audio_channel_mask_t channelMask,
207 int sampleRate,
208 audio_input_flags_t flags = AUDIO_INPUT_FLAG_NONE,
209 audio_port_handle_t *portId = nullptr,
210 uint32_t *virtualDeviceId = nullptr);
snapshotPatchCount()211 PatchCountCheck snapshotPatchCount() { return PatchCountCheck(mClient.get()); }
212
213 void getAudioPorts(audio_port_type_t type, audio_port_role_t role,
214 std::vector<audio_port_v7>* ports);
215 // Tries to find a device port. If 'foundPort' isn't nullptr,
216 // will generate a failure if the port hasn't been found.
217 bool findDevicePort(audio_port_role_t role, audio_devices_t deviceType,
218 const std::string &address, audio_port_v7 *foundPort);
219 static audio_port_handle_t getDeviceIdFromPatch(const struct audio_patch* patch);
getClient()220 virtual AudioPolicyManagerTestClient* getClient() { return new AudioPolicyManagerTestClient; }
221 void verifyBuiltInStrategyIdsAreValid();
222
223 sp<AudioPolicyConfig> mConfig;
224 std::unique_ptr<AudioPolicyManagerTestClient> mClient;
225 std::unique_ptr<AudioPolicyTestManager> mManager;
226
227 static const std::string sTestEngineConfig;
228 };
229
230 const std::string AudioPolicyManagerTest::sTestEngineConfig =
231 base::GetExecutableDirectory() + "/engine/test_audio_policy_engine_configuration.xml";
232
SetUp()233 void AudioPolicyManagerTest::SetUp() {
234 mClient.reset(getClient());
235 ASSERT_NO_FATAL_FAILURE(SetUpManagerConfig()); // Subclasses may want to customize the config.
236 mManager.reset(new AudioPolicyTestManager(mConfig, mClient.get(), getEngineConfigFilePath()));
237 ASSERT_EQ(NO_ERROR, mManager->initialize());
238 ASSERT_EQ(NO_ERROR, mManager->initCheck());
239 }
240
TearDown()241 void AudioPolicyManagerTest::TearDown() {
242 mManager.reset();
243 mClient.reset();
244 }
245
SetUpManagerConfig()246 void AudioPolicyManagerTest::SetUpManagerConfig() {
247 mConfig = AudioPolicyConfig::createWritableForTests();
248 mConfig->setDefault();
249 }
250
dumpToLog()251 void AudioPolicyManagerTest::dumpToLog() {
252 int pipefd[2];
253 ASSERT_NE(-1, pipe(pipefd));
254 pid_t cpid = fork();
255 ASSERT_NE(-1, cpid);
256 if (cpid == 0) {
257 // Child process reads from the pipe and logs.
258 close(pipefd[1]);
259 std::string line;
260 char buf;
261 while (read(pipefd[0], &buf, sizeof(buf)) > 0) {
262 if (buf != '\n') {
263 line += buf;
264 } else {
265 ALOGI("%s", line.c_str());
266 line = "";
267 }
268 }
269 if (!line.empty()) ALOGI("%s", line.c_str());
270 close(pipefd[0]);
271 _exit(EXIT_SUCCESS);
272 } else {
273 // Parent does the dump and checks the status code.
274 close(pipefd[0]);
275 ASSERT_EQ(NO_ERROR, mManager->dump(pipefd[1]));
276 close(pipefd[1]);
277 wait(NULL); // Wait for the child to exit.
278 }
279 }
280
getOutputForAttr(DeviceIdVector * selectedDeviceIds,audio_format_t format,audio_channel_mask_t channelMask,int sampleRate,audio_output_flags_t flags,audio_io_handle_t * output,audio_port_handle_t * portId,audio_attributes_t attr,audio_session_t session,int uid,bool * isBitPerfect)281 void AudioPolicyManagerTest::getOutputForAttr(
282 DeviceIdVector *selectedDeviceIds,
283 audio_format_t format,
284 audio_channel_mask_t channelMask,
285 int sampleRate,
286 audio_output_flags_t flags,
287 audio_io_handle_t *output,
288 audio_port_handle_t *portId,
289 audio_attributes_t attr,
290 audio_session_t session,
291 int uid,
292 bool* isBitPerfect) {
293 audio_io_handle_t localOutput;
294 if (!output) output = &localOutput;
295 *output = AUDIO_IO_HANDLE_NONE;
296 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
297 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
298 config.sample_rate = sampleRate;
299 config.channel_mask = channelMask;
300 config.format = format;
301 audio_port_handle_t localPortId;
302 if (!portId) portId = &localPortId;
303 *portId = AUDIO_PORT_HANDLE_NONE;
304 AudioPolicyInterface::output_type_t outputType;
305 bool isSpatialized;
306 bool isBitPerfectInternal;
307 float volume;
308 bool muted;
309 AttributionSourceState attributionSource = createAttributionSourceState(uid);
310 ASSERT_EQ(OK, mManager->getOutputForAttr(
311 &attr, output, session, &stream, attributionSource, &config, &flags,
312 selectedDeviceIds, portId, {}, &outputType, &isSpatialized,
313 isBitPerfect == nullptr ? &isBitPerfectInternal : isBitPerfect, &volume,
314 &muted));
315 ASSERT_NE(AUDIO_PORT_HANDLE_NONE, *portId);
316 ASSERT_NE(AUDIO_IO_HANDLE_NONE, *output);
317 }
318
getInputForAttr(const audio_attributes_t & attr,audio_io_handle_t * input,const audio_session_t session,audio_unique_id_t riid,audio_port_handle_t * selectedDeviceId,audio_format_t format,audio_channel_mask_t channelMask,int sampleRate,audio_input_flags_t flags,audio_port_handle_t * portId,uint32_t * virtualDeviceId)319 void AudioPolicyManagerTest::getInputForAttr(
320 const audio_attributes_t &attr,
321 audio_io_handle_t *input,
322 const audio_session_t session,
323 audio_unique_id_t riid,
324 audio_port_handle_t *selectedDeviceId,
325 audio_format_t format,
326 audio_channel_mask_t channelMask,
327 int sampleRate,
328 audio_input_flags_t flags,
329 audio_port_handle_t *portId,
330 uint32_t *virtualDeviceId) {
331 audio_config_base_t config = AUDIO_CONFIG_BASE_INITIALIZER;
332 config.sample_rate = sampleRate;
333 config.channel_mask = channelMask;
334 config.format = format;
335 audio_port_handle_t localPortId;
336 if (!portId) portId = &localPortId;
337 *portId = AUDIO_PORT_HANDLE_NONE;
338 if (!virtualDeviceId) virtualDeviceId = 0;
339 AttributionSourceState attributionSource = createAttributionSourceState(/*uid=*/ 0);
340 auto inputRes = mManager->getInputForAttr(attr, *input, *selectedDeviceId,
341 config, flags, riid, session, attributionSource);
342 ASSERT_TRUE(inputRes.has_value());
343 ASSERT_NE(inputRes->portId, AUDIO_PORT_HANDLE_NONE);
344 *input = inputRes->input;
345 if (selectedDeviceId != nullptr) *selectedDeviceId = inputRes->selectedDeviceId;
346 *portId = inputRes->portId;
347 if (virtualDeviceId != nullptr) *virtualDeviceId = inputRes->virtualDeviceId;
348 }
349
getAudioPorts(audio_port_type_t type,audio_port_role_t role,std::vector<audio_port_v7> * ports)350 void AudioPolicyManagerTest::getAudioPorts(audio_port_type_t type, audio_port_role_t role,
351 std::vector<audio_port_v7>* ports) {
352 uint32_t numPorts = 0;
353 uint32_t generation1;
354 status_t ret;
355
356 ret = mManager->listAudioPorts(role, type, &numPorts, nullptr, &generation1);
357 ASSERT_EQ(NO_ERROR, ret) << "mManager->listAudioPorts returned error";
358
359 uint32_t generation2;
360 ports->resize(numPorts);
361 ret = mManager->listAudioPorts(role, type, &numPorts, ports->data(), &generation2);
362 ASSERT_EQ(NO_ERROR, ret) << "mManager->listAudioPorts returned error";
363 ASSERT_EQ(generation1, generation2) << "Generations changed during ports retrieval";
364 }
365
findDevicePort(audio_port_role_t role,audio_devices_t deviceType,const std::string & address,audio_port_v7 * foundPort)366 bool AudioPolicyManagerTest::findDevicePort(audio_port_role_t role,
367 audio_devices_t deviceType, const std::string &address, audio_port_v7 *foundPort) {
368 std::vector<audio_port_v7> ports;
369 getAudioPorts(AUDIO_PORT_TYPE_DEVICE, role, &ports);
370 if (HasFailure()) return false;
371
372 for (const auto &port : ports) {
373 if (port.role == role && port.ext.device.type == deviceType &&
374 (strncmp(port.ext.device.address, address.c_str(),
375 AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0)) {
376 if (foundPort) *foundPort = port;
377 return true;
378 }
379 }
380 if (foundPort) {
381 ADD_FAILURE() << "Device port with role " << role << " and address "
382 << address << " not found";
383 }
384 return false;
385 }
386
getDeviceIdFromPatch(const struct audio_patch * patch)387 audio_port_handle_t AudioPolicyManagerTest::getDeviceIdFromPatch(
388 const struct audio_patch* patch) {
389 // The logic here is the same as the one in AudioIoDescriptor.
390 // Note this function is aim to get routed device id for test.
391 // In that case, device to device patch is not expected here.
392 if (patch->num_sources != 0 && patch->num_sinks != 0) {
393 if (patch->sources[0].type == AUDIO_PORT_TYPE_MIX) {
394 return patch->sinks[0].id;
395 } else {
396 return patch->sources[0].id;
397 }
398 }
399 return AUDIO_PORT_HANDLE_NONE;
400 }
401
verifyBuiltInStrategyIdsAreValid()402 void AudioPolicyManagerTest::verifyBuiltInStrategyIdsAreValid() {
403 AudioProductStrategyVector strategies;
404 ASSERT_EQ(NO_ERROR, mManager->listAudioProductStrategies(strategies));
405 for (const auto& strategy : strategies) {
406 // Since ids are unsigned, this will also cover the case when the id is 'NONE' which is -1.
407 EXPECT_LT(strategy.getId(),
408 media::audio::common::AudioHalProductStrategy::VENDOR_STRATEGY_ID_START)
409 << strategy.getName();
410 }
411 }
412
TEST_F(AudioPolicyManagerTest,InitSuccess)413 TEST_F(AudioPolicyManagerTest, InitSuccess) {
414 // SetUp must finish with no assertions.
415 }
416
TEST_F(AudioPolicyManagerTest,Dump)417 TEST_F(AudioPolicyManagerTest, Dump) {
418 dumpToLog();
419 }
420
TEST_F(AudioPolicyManagerTest,CreateAudioPatchFailure)421 TEST_F(AudioPolicyManagerTest, CreateAudioPatchFailure) {
422 audio_patch patch{};
423 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
424 const PatchCountCheck patchCount = snapshotPatchCount();
425 ASSERT_EQ(BAD_VALUE, mManager->createAudioPatch(nullptr, &handle, 0));
426 ASSERT_EQ(BAD_VALUE, mManager->createAudioPatch(&patch, nullptr, 0));
427 ASSERT_EQ(BAD_VALUE, mManager->createAudioPatch(&patch, &handle, 0));
428 patch.num_sources = AUDIO_PATCH_PORTS_MAX + 1;
429 patch.num_sinks = 1;
430 ASSERT_EQ(BAD_VALUE, mManager->createAudioPatch(&patch, &handle, 0));
431 patch.num_sources = 1;
432 patch.num_sinks = AUDIO_PATCH_PORTS_MAX + 1;
433 ASSERT_EQ(BAD_VALUE, mManager->createAudioPatch(&patch, &handle, 0));
434 patch.num_sources = 2;
435 patch.num_sinks = 1;
436 ASSERT_EQ(INVALID_OPERATION, mManager->createAudioPatch(&patch, &handle, 0));
437 patch = {};
438 patch.num_sources = 1;
439 patch.sources[0].role = AUDIO_PORT_ROLE_SINK;
440 patch.num_sinks = 1;
441 patch.sinks[0].role = AUDIO_PORT_ROLE_SINK;
442 ASSERT_EQ(INVALID_OPERATION, mManager->createAudioPatch(&patch, &handle, 0));
443 patch = {};
444 patch.num_sources = 1;
445 patch.sources[0].role = AUDIO_PORT_ROLE_SOURCE;
446 patch.num_sinks = 1;
447 patch.sinks[0].role = AUDIO_PORT_ROLE_SOURCE;
448 ASSERT_EQ(INVALID_OPERATION, mManager->createAudioPatch(&patch, &handle, 0));
449 // Verify that the handle is left unchanged.
450 ASSERT_EQ(AUDIO_PATCH_HANDLE_NONE, handle);
451 ASSERT_EQ(0, patchCount.deltaFromSnapshot());
452 }
453
TEST_F(AudioPolicyManagerTest,CreateAudioPatchFromMix)454 TEST_F(AudioPolicyManagerTest, CreateAudioPatchFromMix) {
455 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
456 uid_t uid = 42;
457 const PatchCountCheck patchCount = snapshotPatchCount();
458 ASSERT_FALSE(mManager->getAvailableInputDevices().isEmpty());
459 PatchBuilder patchBuilder;
460 patchBuilder.addSource(mManager->getAvailableInputDevices()[0]).
461 addSink(mManager->getConfig().getDefaultOutputDevice());
462 ASSERT_EQ(NO_ERROR, mManager->createAudioPatch(patchBuilder.patch(), &handle, uid));
463 ASSERT_NE(AUDIO_PATCH_HANDLE_NONE, handle);
464 ASSERT_EQ(1, patchCount.deltaFromSnapshot());
465 }
466
467 // TODO: Add patch creation tests that involve already existing patch
468
TEST_F(AudioPolicyManagerTest,BuiltInStrategyIdsAreValid)469 TEST_F(AudioPolicyManagerTest, BuiltInStrategyIdsAreValid) {
470 verifyBuiltInStrategyIdsAreValid();
471 }
472
473 class AudioPolicyManagerTestWithDefaultEngineConfig : public AudioPolicyManagerTest {
474 protected:
475 // The APM will use the default engine config from EngineDefaultConfig.h.
getEngineConfigFilePath() const476 std::string getEngineConfigFilePath() const override { return ""; }
477 };
478
TEST_F(AudioPolicyManagerTestWithDefaultEngineConfig,BuiltInStrategyIdsAreValid)479 TEST_F(AudioPolicyManagerTestWithDefaultEngineConfig, BuiltInStrategyIdsAreValid) {
480 verifyBuiltInStrategyIdsAreValid();
481 }
482
483 enum
484 {
485 MSD_AUDIO_PATCH_COUNT_NUM_AUDIO_PATCHES_INDEX = 0,
486 MSD_AUDIO_PATCH_COUNT_NAME_INDEX = 1
487 };
488 using MsdAudioPatchCountSpecification = std::tuple<size_t, std::string>;
489
490 class AudioPolicyManagerTestMsd : public AudioPolicyManagerTest,
491 public ::testing::WithParamInterface<MsdAudioPatchCountSpecification> {
492 public:
493 AudioPolicyManagerTestMsd();
494 protected:
495 void SetUpManagerConfig() override;
496 void TearDown() override;
497 AudioProfileVector getDirectProfilesForAttributes(const audio_attributes_t& attr);
498
499 sp<DeviceDescriptor> mMsdOutputDevice;
500 sp<DeviceDescriptor> mMsdInputDevice;
501 sp<DeviceDescriptor> mDefaultOutputDevice;
502
503 const size_t mExpectedAudioPatchCount;
504 sp<DeviceDescriptor> mSpdifDevice;
505
506 sp<DeviceDescriptor> mHdmiInputDevice;
507 };
508
AudioPolicyManagerTestMsd()509 AudioPolicyManagerTestMsd::AudioPolicyManagerTestMsd()
510 : mExpectedAudioPatchCount(std::get<MSD_AUDIO_PATCH_COUNT_NUM_AUDIO_PATCHES_INDEX>(
511 GetParam())) {}
512
513 INSTANTIATE_TEST_CASE_P(
514 MsdAudioPatchCount,
515 AudioPolicyManagerTestMsd,
516 ::testing::Values(
517 MsdAudioPatchCountSpecification(2u, "single"),
518 MsdAudioPatchCountSpecification(3u, "dual")
519 ),
__anon9f2131310302(const ::testing::TestParamInfo<MsdAudioPatchCountSpecification> &info) 520 [](const ::testing::TestParamInfo<MsdAudioPatchCountSpecification> &info) {
521 return std::get<MSD_AUDIO_PATCH_COUNT_NAME_INDEX>(info.param); }
522 );
523
SetUpManagerConfig()524 void AudioPolicyManagerTestMsd::SetUpManagerConfig() {
525 // TODO: Consider using Serializer to load part of the config from a string.
526 ASSERT_NO_FATAL_FAILURE(AudioPolicyManagerTest::SetUpManagerConfig());
527 mConfig->getHwModules().getModuleFromName(
528 AUDIO_HARDWARE_MODULE_ID_PRIMARY)->setHalVersion(3, 0);
529
530 mMsdOutputDevice = new DeviceDescriptor(AUDIO_DEVICE_OUT_BUS);
531 sp<AudioProfile> pcmOutputProfile = new AudioProfile(
532 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, k48000SamplingRate);
533 sp<AudioProfile> ac3OutputProfile = new AudioProfile(
534 AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1, k48000SamplingRate);
535 sp<AudioProfile> iec958OutputProfile = new AudioProfile(
536 AUDIO_FORMAT_IEC60958, AUDIO_CHANNEL_INDEX_MASK_24, k48000SamplingRate);
537 mMsdOutputDevice->addAudioProfile(pcmOutputProfile);
538 mMsdOutputDevice->addAudioProfile(ac3OutputProfile);
539 mMsdOutputDevice->addAudioProfile(iec958OutputProfile);
540 mMsdInputDevice = new DeviceDescriptor(AUDIO_DEVICE_IN_BUS);
541 // Match output profile from AudioPolicyConfig::setDefault.
542 sp<AudioProfile> pcmInputProfile = new AudioProfile(
543 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO, 44100);
544 mMsdInputDevice->addAudioProfile(pcmInputProfile);
545 mConfig->addDevice(mMsdOutputDevice);
546 mConfig->addDevice(mMsdInputDevice);
547
548 if (mExpectedAudioPatchCount == 3) {
549 // Add SPDIF device with PCM output profile as a second device for dual MSD audio patching.
550 mSpdifDevice = new DeviceDescriptor(AUDIO_DEVICE_OUT_SPDIF);
551 mSpdifDevice->addAudioProfile(pcmOutputProfile);
552 mConfig->addDevice(mSpdifDevice);
553
554 sp<OutputProfile> spdifOutputProfile = new OutputProfile("spdif output");
555 spdifOutputProfile->addAudioProfile(pcmOutputProfile);
556 spdifOutputProfile->addSupportedDevice(mSpdifDevice);
557 mConfig->getHwModules().getModuleFromName(AUDIO_HARDWARE_MODULE_ID_PRIMARY)->
558 addOutputProfile(spdifOutputProfile);
559 }
560
561 sp<HwModule> msdModule = new HwModule(AUDIO_HARDWARE_MODULE_ID_MSD, 3 /*halVersionMajor*/);
562 HwModuleCollection modules = mConfig->getHwModules();
563 modules.add(msdModule);
564 mConfig->setHwModules(modules);
565
566 sp<OutputProfile> msdOutputProfile = new OutputProfile("msd input");
567 msdOutputProfile->addAudioProfile(pcmOutputProfile);
568 msdOutputProfile->addSupportedDevice(mMsdOutputDevice);
569 msdModule->addOutputProfile(msdOutputProfile);
570 sp<OutputProfile> msdCompressedOutputProfile = new OutputProfile("msd compressed input");
571 msdCompressedOutputProfile->addAudioProfile(ac3OutputProfile);
572 msdCompressedOutputProfile->setFlags(
573 AUDIO_OUTPUT_FLAG_DIRECT | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD |
574 AUDIO_OUTPUT_FLAG_NON_BLOCKING);
575 msdCompressedOutputProfile->addSupportedDevice(mMsdOutputDevice);
576 msdModule->addOutputProfile(msdCompressedOutputProfile);
577 sp<OutputProfile> msdIec958OutputProfile = new OutputProfile("msd iec958 input");
578 msdIec958OutputProfile->addAudioProfile(iec958OutputProfile);
579 msdIec958OutputProfile->setFlags(AUDIO_OUTPUT_FLAG_DIRECT);
580 msdIec958OutputProfile->addSupportedDevice(mMsdOutputDevice);
581 msdModule->addOutputProfile(msdIec958OutputProfile);
582
583 sp<InputProfile> msdInputProfile = new InputProfile("msd output");
584 msdInputProfile->addAudioProfile(pcmInputProfile);
585 msdInputProfile->addSupportedDevice(mMsdInputDevice);
586 msdModule->addInputProfile(msdInputProfile);
587
588 // Add a profile with another encoding to the default device to test routing
589 // of streams that are not supported by MSD.
590 sp<AudioProfile> dtsOutputProfile = new AudioProfile(
591 AUDIO_FORMAT_DTS, AUDIO_CHANNEL_OUT_5POINT1, k48000SamplingRate);
592 mConfig->getDefaultOutputDevice()->addAudioProfile(dtsOutputProfile);
593 sp<OutputProfile> primaryEncodedOutputProfile = new OutputProfile("encoded");
594 primaryEncodedOutputProfile->addAudioProfile(dtsOutputProfile);
595 primaryEncodedOutputProfile->setFlags(AUDIO_OUTPUT_FLAG_DIRECT);
596 primaryEncodedOutputProfile->addSupportedDevice(mConfig->getDefaultOutputDevice());
597 mConfig->getHwModules().getModuleFromName(AUDIO_HARDWARE_MODULE_ID_PRIMARY)->
598 addOutputProfile(primaryEncodedOutputProfile);
599
600 mDefaultOutputDevice = mConfig->getDefaultOutputDevice();
601 if (mExpectedAudioPatchCount == 3) {
602 mSpdifDevice->addAudioProfile(dtsOutputProfile);
603 primaryEncodedOutputProfile->addSupportedDevice(mSpdifDevice);
604 }
605
606 // Add HDMI input device with IEC60958 profile for HDMI in -> MSD patching.
607 mHdmiInputDevice = new DeviceDescriptor(AUDIO_DEVICE_IN_HDMI);
608 sp<AudioProfile> iec958InputProfile = new AudioProfile(
609 AUDIO_FORMAT_IEC60958, AUDIO_CHANNEL_INDEX_MASK_24, k48000SamplingRate);
610 mHdmiInputDevice->addAudioProfile(iec958InputProfile);
611 mConfig->addDevice(mHdmiInputDevice);
612 sp<InputProfile> hdmiInputProfile = new InputProfile("hdmi input");
613 hdmiInputProfile->addAudioProfile(iec958InputProfile);
614 hdmiInputProfile->setFlags(AUDIO_INPUT_FLAG_DIRECT);
615 hdmiInputProfile->addSupportedDevice(mHdmiInputDevice);
616 mConfig->getHwModules().getModuleFromName(AUDIO_HARDWARE_MODULE_ID_PRIMARY)->
617 addInputProfile(hdmiInputProfile);
618 }
619
TearDown()620 void AudioPolicyManagerTestMsd::TearDown() {
621 mMsdOutputDevice.clear();
622 mMsdInputDevice.clear();
623 mDefaultOutputDevice.clear();
624 mSpdifDevice.clear();
625 mHdmiInputDevice.clear();
626 AudioPolicyManagerTest::TearDown();
627 }
628
getDirectProfilesForAttributes(const audio_attributes_t & attr)629 AudioProfileVector AudioPolicyManagerTestMsd::getDirectProfilesForAttributes(
630 const audio_attributes_t& attr) {
631 AudioProfileVector audioProfilesVector;
632 mManager->getDirectProfilesForAttributes(&attr, audioProfilesVector);
633 return audioProfilesVector;
634 }
635
TEST_P(AudioPolicyManagerTestMsd,InitSuccess)636 TEST_P(AudioPolicyManagerTestMsd, InitSuccess) {
637 ASSERT_TRUE(mMsdOutputDevice);
638 ASSERT_TRUE(mMsdInputDevice);
639 ASSERT_TRUE(mDefaultOutputDevice);
640 }
641
TEST_P(AudioPolicyManagerTestMsd,Dump)642 TEST_P(AudioPolicyManagerTestMsd, Dump) {
643 dumpToLog();
644 }
645
TEST_P(AudioPolicyManagerTestMsd,PatchCreationOnSetForceUse)646 TEST_P(AudioPolicyManagerTestMsd, PatchCreationOnSetForceUse) {
647 const PatchCountCheck patchCount = snapshotPatchCount();
648 mManager->setForceUse(AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND,
649 AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS);
650 ASSERT_EQ(mExpectedAudioPatchCount -1 , patchCount.deltaFromSnapshot());
651 }
652
TEST_P(AudioPolicyManagerTestMsd,PatchCreationSetReleaseMsdOutputPatches)653 TEST_P(AudioPolicyManagerTestMsd, PatchCreationSetReleaseMsdOutputPatches) {
654 const PatchCountCheck patchCount = snapshotPatchCount();
655 DeviceVector devices = mManager->getAvailableOutputDevices();
656 // Remove MSD output device to avoid patching to itself
657 devices.remove(mMsdOutputDevice);
658 ASSERT_EQ(mExpectedAudioPatchCount -1 , devices.size());
659 mManager->setMsdOutputPatches(&devices);
660 ASSERT_EQ(mExpectedAudioPatchCount - 1, patchCount.deltaFromSnapshot());
661 // Dual patch: exercise creating one new audio patch and reusing another existing audio patch.
662 DeviceVector singleDevice(devices[0]);
663 mManager->releaseMsdOutputPatches(singleDevice);
664 ASSERT_EQ(mExpectedAudioPatchCount - 2, patchCount.deltaFromSnapshot());
665 mManager->setMsdOutputPatches(&devices);
666 ASSERT_EQ(mExpectedAudioPatchCount - 1, patchCount.deltaFromSnapshot());
667 mManager->releaseMsdOutputPatches(devices);
668 ASSERT_EQ(0, patchCount.deltaFromSnapshot());
669 }
670
TEST_P(AudioPolicyManagerTestMsd,GetOutputForAttrEncodedRoutesToMsd)671 TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrEncodedRoutesToMsd) {
672 const PatchCountCheck patchCount = snapshotPatchCount();
673 DeviceIdVector selectedDeviceIds;
674 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1,
675 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT);
676 ASSERT_EQ(mDefaultOutputDevice->getId(), selectedDeviceIds[0]);
677 ASSERT_EQ(mExpectedAudioPatchCount, patchCount.deltaFromSnapshot());
678 }
679
TEST_P(AudioPolicyManagerTestMsd,GetOutputForAttrPcmRoutesToMsd)680 TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrPcmRoutesToMsd) {
681 const PatchCountCheck patchCount = snapshotPatchCount();
682 DeviceIdVector selectedDeviceIds;
683 getOutputForAttr(&selectedDeviceIds,
684 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, k48000SamplingRate);
685 ASSERT_EQ(mDefaultOutputDevice->getId(), selectedDeviceIds[0]);
686 ASSERT_EQ(mExpectedAudioPatchCount - 1, patchCount.deltaFromSnapshot());
687 }
688
TEST_P(AudioPolicyManagerTestMsd,GetOutputForAttrEncodedPlusPcmRoutesToMsd)689 TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrEncodedPlusPcmRoutesToMsd) {
690 const PatchCountCheck patchCount = snapshotPatchCount();
691 DeviceIdVector selectedDeviceIds;
692 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1,
693 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT);
694 ASSERT_EQ(mDefaultOutputDevice->getId(), selectedDeviceIds[0]);
695 ASSERT_EQ(mExpectedAudioPatchCount, patchCount.deltaFromSnapshot());
696 selectedDeviceIds.clear();
697 getOutputForAttr(&selectedDeviceIds,
698 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO, k48000SamplingRate);
699 ASSERT_EQ(mDefaultOutputDevice->getId(), selectedDeviceIds[0]);
700 ASSERT_EQ(mExpectedAudioPatchCount, patchCount.deltaFromSnapshot());
701 }
702
TEST_P(AudioPolicyManagerTestMsd,GetOutputForAttrUnsupportedFormatBypassesMsd)703 TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrUnsupportedFormatBypassesMsd) {
704 const PatchCountCheck patchCount = snapshotPatchCount();
705 DeviceIdVector selectedDeviceIds;
706 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_DTS, AUDIO_CHANNEL_OUT_5POINT1,
707 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT);
708 ASSERT_NE(mMsdOutputDevice->getId(), selectedDeviceIds[0]);
709 ASSERT_EQ(1, patchCount.deltaFromSnapshot());
710 }
711
TEST_P(AudioPolicyManagerTestMsd,GetOutputForAttrFormatSwitching)712 TEST_P(AudioPolicyManagerTestMsd, GetOutputForAttrFormatSwitching) {
713 // Switch between formats that are supported and not supported by MSD.
714 {
715 const PatchCountCheck patchCount = snapshotPatchCount();
716 DeviceIdVector selectedDeviceIds;
717 audio_port_handle_t portId;
718 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1,
719 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, nullptr /*output*/, &portId);
720 ASSERT_EQ(mDefaultOutputDevice->getId(), selectedDeviceIds[0]);
721 ASSERT_EQ(mExpectedAudioPatchCount, patchCount.deltaFromSnapshot());
722 mManager->releaseOutput(portId);
723 ASSERT_EQ(mExpectedAudioPatchCount - 1, patchCount.deltaFromSnapshot());
724 }
725 {
726 const PatchCountCheck patchCount = snapshotPatchCount();
727 DeviceIdVector selectedDeviceIds;
728 audio_port_handle_t portId;
729 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_DTS, AUDIO_CHANNEL_OUT_5POINT1,
730 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, nullptr /*output*/, &portId);
731 ASSERT_GT(selectedDeviceIds.size(), 0);
732 ASSERT_NE(mMsdOutputDevice->getId(), selectedDeviceIds[0]);
733 ASSERT_EQ(-static_cast<int>(mExpectedAudioPatchCount) + 2, patchCount.deltaFromSnapshot());
734 mManager->releaseOutput(portId);
735 ASSERT_EQ(0, patchCount.deltaFromSnapshot());
736 }
737 {
738 const PatchCountCheck patchCount = snapshotPatchCount();
739 DeviceIdVector selectedDeviceIds;
740 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_AC3, AUDIO_CHANNEL_OUT_5POINT1,
741 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT);
742 ASSERT_EQ(mDefaultOutputDevice->getId(), selectedDeviceIds[0]);
743 ASSERT_EQ(1, patchCount.deltaFromSnapshot());
744 }
745 }
746
TEST_P(AudioPolicyManagerTestMsd,PatchCreationFromHdmiInToMsd)747 TEST_P(AudioPolicyManagerTestMsd, PatchCreationFromHdmiInToMsd) {
748 audio_patch_handle_t handle = AUDIO_PATCH_HANDLE_NONE;
749 uid_t uid = 42;
750 const PatchCountCheck patchCount = snapshotPatchCount();
751 ASSERT_FALSE(mManager->getAvailableInputDevices().isEmpty());
752 PatchBuilder patchBuilder;
753 patchBuilder.
754 addSource(mManager->getAvailableInputDevices().
755 getDevice(AUDIO_DEVICE_IN_HDMI, String8(""), AUDIO_FORMAT_DEFAULT)).
756 addSink(mManager->getAvailableOutputDevices().
757 getDevice(AUDIO_DEVICE_OUT_BUS, String8(""), AUDIO_FORMAT_DEFAULT));
758 ASSERT_EQ(NO_ERROR, mManager->createAudioPatch(patchBuilder.patch(), &handle, uid));
759 ASSERT_NE(AUDIO_PATCH_HANDLE_NONE, handle);
760 AudioPatchCollection patches = mManager->getAudioPatches();
761 sp<AudioPatch> patch = patches.valueFor(handle);
762 ASSERT_EQ(1, patch->mPatch.num_sources);
763 ASSERT_EQ(1, patch->mPatch.num_sinks);
764 ASSERT_EQ(AUDIO_PORT_ROLE_SOURCE, patch->mPatch.sources[0].role);
765 ASSERT_EQ(AUDIO_PORT_ROLE_SINK, patch->mPatch.sinks[0].role);
766 ASSERT_EQ(AUDIO_FORMAT_IEC60958, patch->mPatch.sources[0].format);
767 ASSERT_EQ(AUDIO_FORMAT_IEC60958, patch->mPatch.sinks[0].format);
768 ASSERT_EQ(AUDIO_CHANNEL_INDEX_MASK_24, patch->mPatch.sources[0].channel_mask);
769 ASSERT_EQ(AUDIO_CHANNEL_INDEX_MASK_24, patch->mPatch.sinks[0].channel_mask);
770 ASSERT_EQ(k48000SamplingRate, patch->mPatch.sources[0].sample_rate);
771 ASSERT_EQ(k48000SamplingRate, patch->mPatch.sinks[0].sample_rate);
772 ASSERT_EQ(1, patchCount.deltaFromSnapshot());
773 }
774
TEST_P(AudioPolicyManagerTestMsd,GetDirectProfilesForAttributesWithMsd)775 TEST_P(AudioPolicyManagerTestMsd, GetDirectProfilesForAttributesWithMsd) {
776 const audio_attributes_t attr = {
777 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_UNKNOWN,
778 AUDIO_SOURCE_INVALID, AUDIO_FLAG_NONE, ""};
779
780 // count expected direct profiles for the default device
781 int countDirectProfilesPrimary = 0;
782 const auto& primary = mManager->getConfig().getHwModules()
783 .getModuleFromName(AUDIO_HARDWARE_MODULE_ID_PRIMARY);
784 for (const auto& outputProfile : primary->getOutputProfiles()) {
785 if (outputProfile->asAudioPort()->isDirectOutput()) {
786 countDirectProfilesPrimary += outputProfile->asAudioPort()->getAudioProfiles().size();
787 }
788 }
789
790 // count expected direct profiles for the msd device
791 int countDirectProfilesMsd = 0;
792 const auto& msd = mManager->getConfig().getHwModules()
793 .getModuleFromName(AUDIO_HARDWARE_MODULE_ID_MSD);
794 for (const auto& outputProfile : msd->getOutputProfiles()) {
795 if (outputProfile->asAudioPort()->isDirectOutput()) {
796 countDirectProfilesMsd += outputProfile->asAudioPort()->getAudioProfiles().size();
797 }
798 }
799
800 // before setting up MSD audio patches we only have the primary hal direct profiles
801 ASSERT_EQ(countDirectProfilesPrimary, getDirectProfilesForAttributes(attr).size());
802
803 DeviceVector outputDevices = mManager->getAvailableOutputDevices();
804 // Remove MSD output device to avoid patching to itself
805 outputDevices.remove(mMsdOutputDevice);
806 mManager->setMsdOutputPatches(&outputDevices);
807
808 // after setting up MSD audio patches the MSD direct profiles are added
809 ASSERT_EQ(countDirectProfilesPrimary + countDirectProfilesMsd,
810 getDirectProfilesForAttributes(attr).size());
811
812 mManager->releaseMsdOutputPatches(outputDevices);
813 // releasing the MSD audio patches gets us back to the primary hal direct profiles only
814 ASSERT_EQ(countDirectProfilesPrimary, getDirectProfilesForAttributes(attr).size());
815 }
816
TEST_P(AudioPolicyManagerTestMsd,IsDirectPlaybackSupportedWithMsd)817 TEST_P(AudioPolicyManagerTestMsd, IsDirectPlaybackSupportedWithMsd) {
818 const audio_attributes_t attr = {
819 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_UNKNOWN,
820 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
821
822 audio_config_base_t directConfig = AUDIO_CONFIG_BASE_INITIALIZER;
823 directConfig.format = AUDIO_FORMAT_DTS;
824 directConfig.sample_rate = k48000SamplingRate;
825 directConfig.channel_mask = AUDIO_CHANNEL_OUT_5POINT1;
826
827 audio_config_base_t nonDirectConfig = AUDIO_CONFIG_BASE_INITIALIZER;
828 nonDirectConfig.format = AUDIO_FORMAT_PCM_16_BIT;
829 nonDirectConfig.sample_rate = k48000SamplingRate;
830 nonDirectConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
831
832 audio_config_base_t nonExistentConfig = AUDIO_CONFIG_BASE_INITIALIZER;
833 nonExistentConfig.format = AUDIO_FORMAT_E_AC3;
834 nonExistentConfig.sample_rate = k48000SamplingRate;
835 nonExistentConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
836
837 audio_config_base_t msdDirectConfig1 = AUDIO_CONFIG_BASE_INITIALIZER;
838 msdDirectConfig1.format = AUDIO_FORMAT_AC3;
839 msdDirectConfig1.sample_rate = k48000SamplingRate;
840 msdDirectConfig1.channel_mask = AUDIO_CHANNEL_OUT_5POINT1;
841
842 audio_config_base_t msdDirectConfig2 = AUDIO_CONFIG_BASE_INITIALIZER;
843 msdDirectConfig2.format = AUDIO_FORMAT_IEC60958;
844 msdDirectConfig2.sample_rate = k48000SamplingRate;
845 msdDirectConfig2.channel_mask = AUDIO_CHANNEL_INDEX_MASK_24;
846
847 audio_config_base_t msdNonDirectConfig = AUDIO_CONFIG_BASE_INITIALIZER;
848 msdNonDirectConfig.format = AUDIO_FORMAT_PCM_16_BIT;
849 msdNonDirectConfig.sample_rate = 96000;
850 msdNonDirectConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
851
852 ASSERT_TRUE(mManager->isDirectOutputSupported(directConfig, attr));
853 ASSERT_FALSE(mManager->isDirectOutputSupported(nonDirectConfig, attr));
854 ASSERT_FALSE(mManager->isDirectOutputSupported(nonExistentConfig, attr));
855 // before setting MSD patches the direct MSD configs return false
856 ASSERT_FALSE(mManager->isDirectOutputSupported(msdDirectConfig1, attr));
857 ASSERT_FALSE(mManager->isDirectOutputSupported(msdDirectConfig2, attr));
858 ASSERT_FALSE(mManager->isDirectOutputSupported(msdNonDirectConfig, attr));
859
860 DeviceVector outputDevices = mManager->getAvailableOutputDevices();
861 // Remove MSD output device to avoid patching to itself
862 outputDevices.remove(mMsdOutputDevice);
863 mManager->setMsdOutputPatches(&outputDevices);
864
865 ASSERT_TRUE(mManager->isDirectOutputSupported(directConfig, attr));
866 ASSERT_FALSE(mManager->isDirectOutputSupported(nonDirectConfig, attr));
867 ASSERT_FALSE(mManager->isDirectOutputSupported(nonExistentConfig, attr));
868 // after setting MSD patches the direct MSD configs return true
869 ASSERT_TRUE(mManager->isDirectOutputSupported(msdDirectConfig1, attr));
870 ASSERT_TRUE(mManager->isDirectOutputSupported(msdDirectConfig2, attr));
871 ASSERT_FALSE(mManager->isDirectOutputSupported(msdNonDirectConfig, attr));
872
873 mManager->releaseMsdOutputPatches(outputDevices);
874
875 ASSERT_TRUE(mManager->isDirectOutputSupported(directConfig, attr));
876 ASSERT_FALSE(mManager->isDirectOutputSupported(nonDirectConfig, attr));
877 ASSERT_FALSE(mManager->isDirectOutputSupported(nonExistentConfig, attr));
878 // AFTER releasing MSD patches the direct MSD configs return false
879 ASSERT_FALSE(mManager->isDirectOutputSupported(msdDirectConfig1, attr));
880 ASSERT_FALSE(mManager->isDirectOutputSupported(msdDirectConfig2, attr));
881 ASSERT_FALSE(mManager->isDirectOutputSupported(msdNonDirectConfig, attr));
882 }
883
TEST_P(AudioPolicyManagerTestMsd,GetDirectPlaybackSupportWithMsd)884 TEST_P(AudioPolicyManagerTestMsd, GetDirectPlaybackSupportWithMsd) {
885 const audio_attributes_t attr = {
886 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_UNKNOWN,
887 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
888
889 audio_config_t directConfig = AUDIO_CONFIG_INITIALIZER;
890 directConfig.format = AUDIO_FORMAT_DTS;
891 directConfig.sample_rate = k48000SamplingRate;
892 directConfig.channel_mask = AUDIO_CHANNEL_OUT_5POINT1;
893
894 audio_config_t nonDirectConfig = AUDIO_CONFIG_INITIALIZER;
895 nonDirectConfig.format = AUDIO_FORMAT_PCM_16_BIT;
896 nonDirectConfig.sample_rate = k48000SamplingRate;
897 nonDirectConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
898
899 audio_config_t nonExistentConfig = AUDIO_CONFIG_INITIALIZER;
900 nonExistentConfig.format = AUDIO_FORMAT_E_AC3;
901 nonExistentConfig.sample_rate = k48000SamplingRate;
902 nonExistentConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
903
904 audio_config_t msdDirectConfig1 = AUDIO_CONFIG_INITIALIZER;
905 msdDirectConfig1.format = AUDIO_FORMAT_AC3;
906 msdDirectConfig1.sample_rate = k48000SamplingRate;
907 msdDirectConfig1.channel_mask = AUDIO_CHANNEL_OUT_5POINT1;
908
909 audio_config_t msdDirectConfig2 = AUDIO_CONFIG_INITIALIZER;
910 msdDirectConfig2.format = AUDIO_FORMAT_IEC60958;
911 msdDirectConfig2.sample_rate = k48000SamplingRate;
912 msdDirectConfig2.channel_mask = AUDIO_CHANNEL_INDEX_MASK_24;
913
914 audio_config_t msdNonDirectConfig = AUDIO_CONFIG_INITIALIZER;
915 msdNonDirectConfig.format = AUDIO_FORMAT_PCM_16_BIT;
916 msdNonDirectConfig.sample_rate = 96000;
917 msdNonDirectConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
918
919 ASSERT_EQ(AUDIO_DIRECT_BITSTREAM_SUPPORTED,
920 mManager->getDirectPlaybackSupport(&attr, &directConfig));
921 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
922 mManager->getDirectPlaybackSupport(&attr, &nonDirectConfig));
923 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
924 mManager->getDirectPlaybackSupport(&attr, &nonExistentConfig));
925 // before setting MSD patches the direct MSD configs return AUDIO_DIRECT_NOT_SUPPORTED
926 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
927 mManager->getDirectPlaybackSupport(&attr, &msdDirectConfig1));
928 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
929 mManager->getDirectPlaybackSupport(&attr, &msdDirectConfig2));
930 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
931 mManager->getDirectPlaybackSupport(&attr, &msdNonDirectConfig));
932
933 DeviceVector outputDevices = mManager->getAvailableOutputDevices();
934 // Remove MSD output device to avoid patching to itself
935 outputDevices.remove(mMsdOutputDevice);
936 mManager->setMsdOutputPatches(&outputDevices);
937
938 ASSERT_EQ(AUDIO_DIRECT_BITSTREAM_SUPPORTED,
939 mManager->getDirectPlaybackSupport(&attr, &directConfig));
940 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
941 mManager->getDirectPlaybackSupport(&attr, &nonDirectConfig));
942 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
943 mManager->getDirectPlaybackSupport(&attr, &nonExistentConfig));
944 // after setting MSD patches the direct MSD configs return values according to their flags
945 ASSERT_EQ(AUDIO_DIRECT_OFFLOAD_SUPPORTED,
946 mManager->getDirectPlaybackSupport(&attr, &msdDirectConfig1));
947 ASSERT_EQ(AUDIO_DIRECT_BITSTREAM_SUPPORTED,
948 mManager->getDirectPlaybackSupport(&attr, &msdDirectConfig2));
949 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
950 mManager->getDirectPlaybackSupport(&attr, &msdNonDirectConfig));
951
952 mManager->releaseMsdOutputPatches(outputDevices);
953
954 ASSERT_EQ(AUDIO_DIRECT_BITSTREAM_SUPPORTED,
955 mManager->getDirectPlaybackSupport(&attr, &directConfig));
956 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
957 mManager->getDirectPlaybackSupport(&attr, &nonDirectConfig));
958 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
959 mManager->getDirectPlaybackSupport(&attr, &nonExistentConfig));
960 // after releasing MSD patches the direct MSD configs return AUDIO_DIRECT_NOT_SUPPORTED
961 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
962 mManager->getDirectPlaybackSupport(&attr, &msdDirectConfig1));
963 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
964 mManager->getDirectPlaybackSupport(&attr, &msdDirectConfig2));
965 ASSERT_EQ(AUDIO_DIRECT_NOT_SUPPORTED,
966 mManager->getDirectPlaybackSupport(&attr, &msdNonDirectConfig));
967 }
968
969 class AudioPolicyManagerTestWithConfigurationFile : public AudioPolicyManagerTest {
970 protected:
971 void SetUpManagerConfig() override;
getConfigFile()972 virtual std::string getConfigFile() { return sDefaultConfig; }
973
974 static const std::string sExecutableDir;
975 static const std::string sDefaultConfig;
976 };
977
978 const std::string AudioPolicyManagerTestWithConfigurationFile::sExecutableDir =
979 base::GetExecutableDirectory() + "/";
980
981 const std::string AudioPolicyManagerTestWithConfigurationFile::sDefaultConfig =
982 sExecutableDir + "test_audio_policy_configuration.xml";
983
SetUpManagerConfig()984 void AudioPolicyManagerTestWithConfigurationFile::SetUpManagerConfig() {
985 auto result = AudioPolicyConfig::loadFromCustomXmlConfigForTests(getConfigFile());
986 ASSERT_TRUE(result.ok());
987 mConfig = result.value();
988 }
989
TEST_F(AudioPolicyManagerTestWithConfigurationFile,InitSuccess)990 TEST_F(AudioPolicyManagerTestWithConfigurationFile, InitSuccess) {
991 // SetUp must finish with no assertions.
992 }
993
TEST_F(AudioPolicyManagerTestWithConfigurationFile,Dump)994 TEST_F(AudioPolicyManagerTestWithConfigurationFile, Dump) {
995 dumpToLog();
996 }
997
TEST_F(AudioPolicyManagerTestWithConfigurationFile,ListAudioPortsHasFlags)998 TEST_F(AudioPolicyManagerTestWithConfigurationFile, ListAudioPortsHasFlags) {
999 // Create an input for VOIP TX because it's not opened automatically like outputs are.
1000 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
1001 audio_port_handle_t mixPortId = AUDIO_PORT_HANDLE_NONE;
1002 audio_source_t source = AUDIO_SOURCE_VOICE_COMMUNICATION;
1003 audio_attributes_t attr = {AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_UNKNOWN, source,
1004 AUDIO_FLAG_NONE, ""};
1005 audio_io_handle_t input = AUDIO_PORT_HANDLE_NONE;
1006 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input, AUDIO_SESSION_NONE, 1,
1007 &selectedDeviceId, AUDIO_FORMAT_PCM_16_BIT,
1008 AUDIO_CHANNEL_IN_MONO, 8000, AUDIO_INPUT_FLAG_VOIP_TX,
1009 &mixPortId));
1010
1011 std::vector<audio_port_v7> ports;
1012 ASSERT_NO_FATAL_FAILURE(
1013 getAudioPorts(AUDIO_PORT_TYPE_MIX, AUDIO_PORT_ROLE_NONE, &ports));
1014 EXPECT_NE(0, ports.size());
1015 bool hasFlags = false, foundPrimary = false, foundVoipRx = false, foundVoipTx = false;
1016 for (const auto& port : ports) {
1017 if ((port.active_config.config_mask & AUDIO_PORT_CONFIG_FLAGS) != 0) {
1018 hasFlags = true;
1019 if (port.role == AUDIO_PORT_ROLE_SOURCE) {
1020 if ((port.active_config.flags.output & AUDIO_OUTPUT_FLAG_PRIMARY) != 0) {
1021 foundPrimary = true;
1022 }
1023 if ((port.active_config.flags.output & AUDIO_OUTPUT_FLAG_VOIP_RX) != 0) {
1024 foundVoipRx = true;
1025 }
1026 } else if (port.role == AUDIO_PORT_ROLE_SINK) {
1027 if ((port.active_config.flags.input & AUDIO_INPUT_FLAG_VOIP_TX) != 0) {
1028 foundVoipTx = true;
1029 }
1030 }
1031 }
1032 }
1033 EXPECT_TRUE(hasFlags);
1034 EXPECT_TRUE(foundPrimary);
1035 EXPECT_TRUE(foundVoipRx);
1036 EXPECT_TRUE(foundVoipTx);
1037 }
1038
TEST_F(AudioPolicyManagerTestWithConfigurationFile,HandleDeviceConfigChange)1039 TEST_F(AudioPolicyManagerTestWithConfigurationFile, HandleDeviceConfigChange) {
1040 {
1041 const auto prevCounter = mClient->getRoutingUpdatedCounter();
1042
1043 EXPECT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
1044 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
1045 "", "", AUDIO_FORMAT_LDAC));
1046 const auto currCounter = mClient->getRoutingUpdatedCounter();
1047 EXPECT_GT(currCounter, prevCounter);
1048 }
1049 {
1050 const auto prevCounter = mClient->getRoutingUpdatedCounter();
1051 // Update device configuration
1052 EXPECT_EQ(NO_ERROR, mManager->handleDeviceConfigChange(AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
1053 "" /*address*/, "" /*name*/,
1054 AUDIO_FORMAT_AAC));
1055
1056 // As mClient marks isReconfigA2dpSupported to false, device state needs to be toggled for
1057 // config changes to take effect
1058 const auto currCounter = mClient->getRoutingUpdatedCounter();
1059 EXPECT_GT(currCounter, prevCounter);
1060 }
1061 }
1062
TEST_F(AudioPolicyManagerTestWithConfigurationFile,PreferredMixerAttributes)1063 TEST_F(AudioPolicyManagerTestWithConfigurationFile, PreferredMixerAttributes) {
1064 mClient->addSupportedFormat(AUDIO_FORMAT_PCM_16_BIT);
1065 mClient->addSupportedChannelMask(AUDIO_CHANNEL_OUT_STEREO);
1066 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
1067 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
1068 "", "", AUDIO_FORMAT_DEFAULT));
1069 auto devices = mManager->getAvailableOutputDevices();
1070 audio_port_handle_t maxPortId = 0;
1071 audio_port_handle_t speakerPortId;
1072 audio_port_handle_t usbPortId;
1073 for (auto device : devices) {
1074 maxPortId = std::max(maxPortId, device->getId());
1075 if (device->type() == AUDIO_DEVICE_OUT_SPEAKER) {
1076 speakerPortId = device->getId();
1077 } else if (device->type() == AUDIO_DEVICE_OUT_USB_DEVICE) {
1078 usbPortId = device->getId();
1079 }
1080 }
1081
1082 const uid_t uid = 1234;
1083 const uid_t otherUid = 4321;
1084 const audio_attributes_t mediaAttr = {
1085 .content_type = AUDIO_CONTENT_TYPE_MUSIC,
1086 .usage = AUDIO_USAGE_MEDIA,
1087 };
1088 const audio_attributes_t alarmAttr = {
1089 .content_type = AUDIO_CONTENT_TYPE_SONIFICATION,
1090 .usage = AUDIO_USAGE_ALARM,
1091 };
1092
1093 std::vector<audio_mixer_attributes_t> mixerAttributes;
1094 EXPECT_EQ(NO_ERROR, mManager->getSupportedMixerAttributes(usbPortId, mixerAttributes));
1095 for (const auto attrToSet : mixerAttributes) {
1096 audio_mixer_attributes_t attrFromQuery = AUDIO_MIXER_ATTRIBUTES_INITIALIZER;
1097
1098 // The given device is not available
1099 EXPECT_EQ(BAD_VALUE,
1100 mManager->setPreferredMixerAttributes(
1101 &mediaAttr, maxPortId + 1, uid, &attrToSet));
1102 // The only allowed device is USB
1103 EXPECT_EQ(BAD_VALUE,
1104 mManager->setPreferredMixerAttributes(
1105 &mediaAttr, speakerPortId, uid, &attrToSet));
1106 // The only allowed usage is media
1107 EXPECT_EQ(BAD_VALUE,
1108 mManager->setPreferredMixerAttributes(&alarmAttr, usbPortId, uid, &attrToSet));
1109 // Nothing set yet, must get null when query
1110 EXPECT_EQ(NAME_NOT_FOUND,
1111 mManager->getPreferredMixerAttributes(&mediaAttr, usbPortId, &attrFromQuery));
1112 EXPECT_EQ(NO_ERROR,
1113 mManager->setPreferredMixerAttributes(
1114 &mediaAttr, usbPortId, uid, &attrToSet));
1115 EXPECT_EQ(NO_ERROR,
1116 mManager->getPreferredMixerAttributes(&mediaAttr, usbPortId, &attrFromQuery));
1117 EXPECT_EQ(attrToSet.config.format, attrFromQuery.config.format);
1118 EXPECT_EQ(attrToSet.config.sample_rate, attrFromQuery.config.sample_rate);
1119 EXPECT_EQ(attrToSet.config.channel_mask, attrFromQuery.config.channel_mask);
1120 EXPECT_EQ(attrToSet.mixer_behavior, attrFromQuery.mixer_behavior);
1121 EXPECT_EQ(NAME_NOT_FOUND,
1122 mManager->clearPreferredMixerAttributes(&mediaAttr, speakerPortId, uid));
1123 EXPECT_EQ(PERMISSION_DENIED,
1124 mManager->clearPreferredMixerAttributes(&mediaAttr, usbPortId, otherUid));
1125 EXPECT_EQ(NO_ERROR,
1126 mManager->clearPreferredMixerAttributes(&mediaAttr, usbPortId, uid));
1127 }
1128
1129 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
1130 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
1131 "", "", AUDIO_FORMAT_LDAC));
1132 }
1133
TEST_F(AudioPolicyManagerTestWithConfigurationFile,RoutingChangedWithPreferredMixerAttributes)1134 TEST_F(AudioPolicyManagerTestWithConfigurationFile, RoutingChangedWithPreferredMixerAttributes) {
1135 mClient->addSupportedFormat(AUDIO_FORMAT_PCM_16_BIT);
1136 mClient->addSupportedChannelMask(AUDIO_CHANNEL_OUT_STEREO);
1137 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
1138 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
1139 "", "", AUDIO_FORMAT_DEFAULT));
1140 auto devices = mManager->getAvailableOutputDevices();
1141 audio_port_handle_t usbPortId = AUDIO_PORT_HANDLE_NONE;
1142 for (auto device : devices) {
1143 if (device->type() == AUDIO_DEVICE_OUT_USB_DEVICE) {
1144 usbPortId = device->getId();
1145 break;
1146 }
1147 }
1148 EXPECT_NE(AUDIO_PORT_HANDLE_NONE, usbPortId);
1149
1150 const uid_t uid = 1234;
1151 const audio_attributes_t mediaAttr = {
1152 .content_type = AUDIO_CONTENT_TYPE_MUSIC,
1153 .usage = AUDIO_USAGE_MEDIA,
1154 };
1155
1156 std::vector<audio_mixer_attributes_t> mixerAttributes;
1157 EXPECT_EQ(NO_ERROR, mManager->getSupportedMixerAttributes(usbPortId, mixerAttributes));
1158 EXPECT_GT(mixerAttributes.size(), 0);
1159 EXPECT_EQ(NO_ERROR,
1160 mManager->setPreferredMixerAttributes(
1161 &mediaAttr, usbPortId, uid, &mixerAttributes[0]));
1162
1163 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
1164 DeviceIdVector selectedDeviceIds;
1165 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
1166 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
1167 k48000SamplingRate, AUDIO_OUTPUT_FLAG_NONE, &output, &portId, mediaAttr,
1168 AUDIO_SESSION_NONE, uid);
1169 status_t status = mManager->startOutput(portId);
1170 if (status == DEAD_OBJECT) {
1171 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
1172 k48000SamplingRate, AUDIO_OUTPUT_FLAG_NONE, &output, &portId, mediaAttr,
1173 AUDIO_SESSION_NONE, uid);
1174 status = mManager->startOutput(portId);
1175 }
1176 EXPECT_EQ(NO_ERROR, status);
1177 EXPECT_NE(AUDIO_IO_HANDLE_NONE, output);
1178 EXPECT_NE(nullptr, mManager->getOutputs().valueFor(output));
1179 EXPECT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
1180 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
1181 "", "", AUDIO_FORMAT_LDAC));
1182 // When BT device is connected, it will be selected as media device and trigger routing changed.
1183 // When this happens, existing output that is opened with preferred mixer attributes will be
1184 // closed and reopened with default config.
1185 EXPECT_EQ(nullptr, mManager->getOutputs().valueFor(output));
1186
1187 EXPECT_EQ(NO_ERROR,
1188 mManager->clearPreferredMixerAttributes(&mediaAttr, usbPortId, uid));
1189
1190 EXPECT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
1191 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
1192 "", "", AUDIO_FORMAT_LDAC));
1193 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
1194 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
1195 "", "", AUDIO_FORMAT_LDAC));
1196 }
1197
1198 template <typename T>
hasDuplicates(const T & container)1199 bool hasDuplicates(const T& container) {
1200 return std::unordered_set<typename T::value_type>(container.begin(),
1201 container.end()).size() != container.size();
1202 }
1203
TEST_F(AudioPolicyManagerTestWithConfigurationFile,UniqueSelectedDeviceIds)1204 TEST_F(AudioPolicyManagerTestWithConfigurationFile, UniqueSelectedDeviceIds) {
1205 mClient->addSupportedFormat(AUDIO_FORMAT_PCM_16_BIT);
1206 mClient->addSupportedChannelMask(AUDIO_CHANNEL_OUT_STEREO);
1207 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
1208 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
1209 "", "", AUDIO_FORMAT_DEFAULT));
1210 auto devices = mManager->getAvailableOutputDevices();
1211 audio_port_handle_t usbPortId = AUDIO_PORT_HANDLE_NONE;
1212 audio_port_handle_t speakerPortId = AUDIO_PORT_HANDLE_NONE;
1213 for (auto device : devices) {
1214 if (device->type() == AUDIO_DEVICE_OUT_USB_DEVICE) {
1215 usbPortId = device->getId();
1216 }
1217 if (device->type() == AUDIO_DEVICE_OUT_SPEAKER) {
1218 speakerPortId = device->getId();
1219 }
1220 }
1221 EXPECT_NE(AUDIO_PORT_HANDLE_NONE, usbPortId);
1222 EXPECT_NE(AUDIO_PORT_HANDLE_NONE, speakerPortId);
1223
1224 const uid_t uid = 1234;
1225 const audio_attributes_t mediaAttr = {
1226 .content_type = AUDIO_CONTENT_TYPE_SONIFICATION,
1227 .usage = AUDIO_USAGE_ALARM,
1228 };
1229
1230 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
1231 DeviceIdVector selectedDeviceIds;
1232 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
1233 ASSERT_NO_FATAL_FAILURE(getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT,
1234 AUDIO_CHANNEL_OUT_STEREO, k48000SamplingRate, AUDIO_OUTPUT_FLAG_NONE, &output,
1235 &portId, mediaAttr, AUDIO_SESSION_NONE, uid));
1236 EXPECT_FALSE(selectedDeviceIds.empty());
1237 EXPECT_NE(std::find(selectedDeviceIds.begin(), selectedDeviceIds.end(), usbPortId),
1238 selectedDeviceIds.end());
1239 EXPECT_NE(std::find(selectedDeviceIds.begin(), selectedDeviceIds.end(), speakerPortId),
1240 selectedDeviceIds.end());
1241 EXPECT_FALSE(hasDuplicates(selectedDeviceIds));
1242
1243 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
1244 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
1245 "", "", AUDIO_FORMAT_DEFAULT));
1246 }
1247
TEST_F(AudioPolicyManagerTestWithConfigurationFile,PreferExactConfigForInput)1248 TEST_F(AudioPolicyManagerTestWithConfigurationFile, PreferExactConfigForInput) {
1249 const audio_channel_mask_t deviceChannelMask = AUDIO_CHANNEL_IN_3POINT1;
1250 mClient->addSupportedFormat(AUDIO_FORMAT_PCM_16_BIT);
1251 mClient->addSupportedChannelMask(deviceChannelMask);
1252 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_IN_USB_DEVICE,
1253 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
1254 "", "", AUDIO_FORMAT_DEFAULT));
1255
1256 const audio_port_handle_t requestedDeviceId = AUDIO_PORT_HANDLE_NONE;
1257 const audio_io_handle_t requestedInput = AUDIO_PORT_HANDLE_NONE;
1258 const AttributionSourceState attributionSource = createAttributionSourceState(/*uid=*/ 0);
1259 AudioPolicyInterface::input_type_t inputType;
1260
1261 audio_attributes_t attr = {AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_UNKNOWN,
1262 AUDIO_SOURCE_VOICE_COMMUNICATION,AUDIO_FLAG_NONE, ""};
1263 audio_config_base_t requestedConfig = {
1264 .sample_rate = k48000SamplingRate,
1265 .channel_mask = AUDIO_CHANNEL_IN_STEREO,
1266 .format = AUDIO_FORMAT_PCM_16_BIT,
1267 };
1268 auto inputRes = mManager->getInputForAttr(attr, requestedInput, requestedDeviceId,
1269 requestedConfig, AUDIO_INPUT_FLAG_NONE, 1 /*riid*/,
1270 AUDIO_SESSION_NONE, attributionSource);
1271 ASSERT_TRUE(inputRes.has_value());
1272 ASSERT_NE(inputRes->portId, AUDIO_PORT_HANDLE_NONE);
1273 ASSERT_EQ(VALUE_OR_FATAL(legacy2aidl_audio_config_base_t_AudioConfigBase(
1274 requestedConfig, true /* isInput */)),
1275 inputRes->config);
1276
1277 attr = {AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_UNKNOWN,
1278 AUDIO_SOURCE_VOICE_COMMUNICATION, AUDIO_FLAG_NONE, ""};
1279 requestedConfig.channel_mask = deviceChannelMask;
1280
1281 inputRes = mManager->getInputForAttr(attr, requestedInput, requestedDeviceId, requestedConfig,
1282 AUDIO_INPUT_FLAG_NONE, 1 /*riid*/, AUDIO_SESSION_NONE,
1283 attributionSource);
1284 ASSERT_TRUE(inputRes.has_value());
1285 ASSERT_NE(inputRes->portId, AUDIO_PORT_HANDLE_NONE);
1286 ASSERT_EQ(VALUE_OR_FATAL(legacy2aidl_audio_config_base_t_AudioConfigBase(requestedConfig,
1287 true /* isInput */)),
1288 inputRes->config);
1289
1290 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_IN_USB_DEVICE,
1291 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
1292 "", "", AUDIO_FORMAT_DEFAULT));
1293 }
1294
TEST_F(AudioPolicyManagerTestWithConfigurationFile,CheckInputsForDeviceClosesStreams)1295 TEST_F(AudioPolicyManagerTestWithConfigurationFile, CheckInputsForDeviceClosesStreams) {
1296 mClient->addSupportedFormat(AUDIO_FORMAT_PCM_16_BIT);
1297 mClient->addSupportedFormat(AUDIO_FORMAT_PCM_24_BIT_PACKED);
1298 mClient->addSupportedChannelMask(AUDIO_CHANNEL_IN_MONO);
1299 mClient->addSupportedChannelMask(AUDIO_CHANNEL_IN_STEREO);
1300 // Since 'checkInputsForDevice' is called as part of the 'setDeviceConnectionState',
1301 // call it directly here, as we need to ensure that it does not keep all intermediate
1302 // streams opened, as it may cause a rejection from the HAL based on the cap.
1303 const size_t streamCountBefore = mClient->getOpenedInputsCount();
1304 sp<DeviceDescriptor> device = mManager->getHwModules().getDeviceDescriptor(
1305 AUDIO_DEVICE_IN_USB_DEVICE, "", "", AUDIO_FORMAT_DEFAULT, true /*allowToCreate*/);
1306 ASSERT_NE(nullptr, device.get());
1307 EXPECT_EQ(NO_ERROR,
1308 mManager->checkInputsForDevice(device, AUDIO_POLICY_DEVICE_STATE_AVAILABLE));
1309 EXPECT_EQ(streamCountBefore, mClient->getOpenedInputsCount());
1310 }
1311
TEST_F(AudioPolicyManagerTestWithConfigurationFile,SetDeviceConnectionStateClosesStreams)1312 TEST_F(AudioPolicyManagerTestWithConfigurationFile, SetDeviceConnectionStateClosesStreams) {
1313 mClient->addSupportedFormat(AUDIO_FORMAT_PCM_16_BIT);
1314 mClient->addSupportedFormat(AUDIO_FORMAT_PCM_24_BIT_PACKED);
1315 mClient->addSupportedChannelMask(AUDIO_CHANNEL_IN_MONO);
1316 mClient->addSupportedChannelMask(AUDIO_CHANNEL_IN_STEREO);
1317 const size_t streamCountBefore = mClient->getOpenedInputsCount();
1318 EXPECT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_IN_USB_DEVICE,
1319 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
1320 "", "", AUDIO_FORMAT_DEFAULT));
1321 EXPECT_EQ(streamCountBefore, mClient->getOpenedInputsCount());
1322 }
1323
TEST_F(AudioPolicyManagerTestWithConfigurationFile,UpdateConfigFromInexactProfile)1324 TEST_F(AudioPolicyManagerTestWithConfigurationFile, UpdateConfigFromInexactProfile) {
1325 const audio_format_t expectedFormat = AUDIO_FORMAT_PCM_16_BIT;
1326 const uint32_t expectedSampleRate = 48000;
1327 const audio_channel_mask_t expectedChannelMask = AUDIO_CHANNEL_IN_STEREO;
1328 const std::string expectedIOProfile = "primary input";
1329
1330 auto devices = mManager->getAvailableInputDevices();
1331 sp<DeviceDescriptor> mic = nullptr;
1332 for (auto device : devices) {
1333 if (device->type() == AUDIO_DEVICE_IN_BUILTIN_MIC) {
1334 mic = device;
1335 break;
1336 }
1337 }
1338 EXPECT_NE(nullptr, mic);
1339
1340 audio_format_t requestedFormat = AUDIO_FORMAT_PCM_16_BIT;
1341 uint32_t requestedSampleRate = 44100;
1342 audio_channel_mask_t requestedChannelMask = AUDIO_CHANNEL_IN_STEREO;
1343 auto profile = mManager->getInputProfile(
1344 mic, requestedSampleRate, requestedFormat, requestedChannelMask, AUDIO_INPUT_FLAG_NONE);
1345 EXPECT_EQ(expectedIOProfile, profile->getName());
1346 EXPECT_EQ(expectedFormat, requestedFormat);
1347 EXPECT_EQ(expectedSampleRate, requestedSampleRate);
1348 EXPECT_EQ(expectedChannelMask, requestedChannelMask);
1349 }
1350
TEST_F(AudioPolicyManagerTestWithConfigurationFile,MatchesMoreInputFlagsWhenPossible)1351 TEST_F(AudioPolicyManagerTestWithConfigurationFile, MatchesMoreInputFlagsWhenPossible) {
1352 const audio_format_t expectedFormat = AUDIO_FORMAT_PCM_16_BIT;
1353 const uint32_t expectedSampleRate = 48000;
1354 const audio_channel_mask_t expectedChannelMask = AUDIO_CHANNEL_IN_STEREO;
1355 const std::string expectedIOProfile = "mixport_fast_input";
1356
1357 auto devices = mManager->getAvailableInputDevices();
1358 sp<DeviceDescriptor> mic = nullptr;
1359 for (auto device : devices) {
1360 if (device->type() == AUDIO_DEVICE_IN_BUILTIN_MIC) {
1361 mic = device;
1362 break;
1363 }
1364 }
1365 EXPECT_NE(nullptr, mic);
1366
1367 audio_format_t requestedFormat = AUDIO_FORMAT_PCM_24_BIT_PACKED;
1368 uint32_t requestedSampleRate = 48000;
1369 audio_channel_mask_t requestedChannelMask = AUDIO_CHANNEL_IN_STEREO;
1370 auto profile = mManager->getInputProfile(
1371 mic, requestedSampleRate, requestedFormat, requestedChannelMask, AUDIO_INPUT_FLAG_FAST);
1372 EXPECT_EQ(expectedIOProfile, profile->getName());
1373 EXPECT_EQ(expectedFormat, requestedFormat);
1374 EXPECT_EQ(expectedSampleRate, requestedSampleRate);
1375 EXPECT_EQ(expectedChannelMask, requestedChannelMask);
1376 }
1377
1378 class AudioPolicyManagerTestDynamicPolicy : public AudioPolicyManagerTestWithConfigurationFile {
1379 protected:
1380 void TearDown() override;
1381
1382 status_t addPolicyMix(int mixType, int mixFlag, audio_devices_t deviceType,
1383 std::string mixAddress, const audio_config_t& audioConfig,
1384 const std::vector<AudioMixMatchCriterion>& matchCriteria);
1385
1386 status_t addPolicyMix(const AudioMix& mix);
1387
1388 status_t removePolicyMixes(const Vector<AudioMix>& mixes);
1389
1390 std::vector<AudioMix> getRegisteredPolicyMixes();
1391 void clearPolicyMix();
1392 void addPolicyMixAndStartInputForLoopback(
1393 int mixType, int mixFlag, audio_devices_t deviceType, std::string mixAddress,
1394 const audio_config_t& audioConfig,
1395 const std::vector<AudioMixMatchCriterion>& matchCriteria,
1396 audio_session_t session=AUDIO_SESSION_NONE,
1397 audio_config_base_t config=DEFAULT_INPUT_CONFIG,
1398 audio_input_flags_t inputFlags=AUDIO_INPUT_FLAG_NONE);
1399
1400 Vector<AudioMix> mAudioMixes;
1401 const std::string mMixAddress = "remote_submix_media";
1402
1403 audio_port_handle_t mLoopbackInputPortId = AUDIO_PORT_HANDLE_NONE;
1404 std::unique_ptr<RecordingActivityTracker> mTracker;
1405 struct audio_port_v7 mInjectionPort;
1406
1407 constexpr static const audio_config_base_t DEFAULT_INPUT_CONFIG = {
1408 .sample_rate = k48000SamplingRate,
1409 .channel_mask = AUDIO_CHANNEL_IN_STEREO,
1410 .format = AUDIO_FORMAT_PCM_16_BIT
1411 };
1412 };
1413
TearDown()1414 void AudioPolicyManagerTestDynamicPolicy::TearDown() {
1415 clearPolicyMix();
1416 AudioPolicyManagerTestWithConfigurationFile::TearDown();
1417 }
1418
addPolicyMix(int mixType,int mixFlag,audio_devices_t deviceType,std::string mixAddress,const audio_config_t & audioConfig,const std::vector<AudioMixMatchCriterion> & matchCriteria={})1419 status_t AudioPolicyManagerTestDynamicPolicy::addPolicyMix(int mixType, int mixFlag,
1420 audio_devices_t deviceType, std::string mixAddress, const audio_config_t& audioConfig,
1421 const std::vector<AudioMixMatchCriterion>& matchCriteria = {}) {
1422 AudioMix myAudioMix(matchCriteria, mixType, audioConfig, mixFlag,
1423 String8(mixAddress.c_str()), 0);
1424 myAudioMix.mDeviceType = deviceType;
1425 myAudioMix.mToken = sp<BBinder>::make();
1426 // Clear mAudioMix before add new one to make sure we don't add already exist mixes.
1427 mAudioMixes.clear();
1428 return addPolicyMix(myAudioMix);
1429 }
1430
addPolicyMix(const AudioMix & mix)1431 status_t AudioPolicyManagerTestDynamicPolicy::addPolicyMix(const AudioMix& mix) {
1432 mAudioMixes.add(mix);
1433
1434 // As the policy mixes registration may fail at some case,
1435 // caller need to check the returned status.
1436 status_t ret = mManager->registerPolicyMixes(mAudioMixes);
1437 return ret;
1438 }
1439
removePolicyMixes(const Vector<AudioMix> & mixes)1440 status_t AudioPolicyManagerTestDynamicPolicy::removePolicyMixes(const Vector<AudioMix>& mixes) {
1441 status_t ret = mManager->unregisterPolicyMixes(mixes);
1442 return ret;
1443 }
1444
getRegisteredPolicyMixes()1445 std::vector<AudioMix> AudioPolicyManagerTestDynamicPolicy::getRegisteredPolicyMixes() {
1446 std::vector<AudioMix> audioMixes;
1447 if (mManager != nullptr) {
1448 status_t ret = mManager->getRegisteredPolicyMixes(audioMixes);
1449 EXPECT_EQ(NO_ERROR, ret);
1450 }
1451 return audioMixes;
1452 }
1453
clearPolicyMix()1454 void AudioPolicyManagerTestDynamicPolicy::clearPolicyMix() {
1455 if (mManager != nullptr) {
1456 mManager->stopInput(mLoopbackInputPortId);
1457 mManager->unregisterPolicyMixes(mAudioMixes);
1458 }
1459 mAudioMixes.clear();
1460 }
1461
addPolicyMixAndStartInputForLoopback(int mixType,int mixFlag,audio_devices_t deviceType,std::string mixAddress,const audio_config_t & audioConfig,const std::vector<AudioMixMatchCriterion> & matchCriteria,audio_session_t session,audio_config_base_t config,audio_input_flags_t inputFlags)1462 void AudioPolicyManagerTestDynamicPolicy::addPolicyMixAndStartInputForLoopback(
1463 int mixType, int mixFlag, audio_devices_t deviceType, std::string mixAddress,
1464 const audio_config_t& audioConfig,
1465 const std::vector<AudioMixMatchCriterion>& matchCriteria, audio_session_t session,
1466 audio_config_base_t config, audio_input_flags_t inputFlags) {
1467 ASSERT_EQ(NO_ERROR,
1468 addPolicyMix(mixType, mixFlag, deviceType, mixAddress, audioConfig, matchCriteria));
1469 if ((mixFlag & MIX_ROUTE_FLAG_LOOP_BACK) != MIX_ROUTE_FLAG_LOOP_BACK) {
1470 return;
1471 }
1472
1473 mTracker.reset(new RecordingActivityTracker());
1474 struct audio_port_v7 extractionPort;
1475 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SOURCE, AUDIO_DEVICE_IN_REMOTE_SUBMIX,
1476 mixAddress, &extractionPort));
1477 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
1478 audio_source_t source = AUDIO_SOURCE_REMOTE_SUBMIX;
1479 audio_attributes_t attr = {
1480 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_UNKNOWN, source, AUDIO_FLAG_NONE, ""};
1481 std::string tags = "addr=" + mMixAddress;
1482 audio_io_handle_t input = AUDIO_PORT_HANDLE_NONE;
1483 strncpy(attr.tags, tags.c_str(), AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1);
1484 ASSERT_NO_FATAL_FAILURE(
1485 getInputForAttr(attr, &input, session, mTracker->getRiid(),
1486 &selectedDeviceId, config.format, config.channel_mask,
1487 config.sample_rate, inputFlags, &mLoopbackInputPortId));
1488 ASSERT_EQ(NO_ERROR, mManager->startInput(mLoopbackInputPortId));
1489 ASSERT_EQ(extractionPort.id, selectedDeviceId);
1490
1491 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
1492 mMixAddress, &mInjectionPort));
1493 }
1494
TEST_F(AudioPolicyManagerTestDynamicPolicy,InitSuccess)1495 TEST_F(AudioPolicyManagerTestDynamicPolicy, InitSuccess) {
1496 // SetUp must finish with no assertions
1497 }
1498
TEST_F(AudioPolicyManagerTestDynamicPolicy,Dump)1499 TEST_F(AudioPolicyManagerTestDynamicPolicy, Dump) {
1500 dumpToLog();
1501 }
1502
TEST_F(AudioPolicyManagerTestDynamicPolicy,RegisterPolicyMixes)1503 TEST_F(AudioPolicyManagerTestDynamicPolicy, RegisterPolicyMixes) {
1504 status_t ret;
1505 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
1506
1507 // Only capture of playback is allowed in LOOP_BACK &RENDER mode
1508 ret = addPolicyMix(MIX_TYPE_RECORDERS, MIX_ROUTE_FLAG_LOOP_BACK_AND_RENDER,
1509 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, "", audioConfig);
1510 ASSERT_EQ(INVALID_OPERATION, ret);
1511
1512 // Fail due to the device is already connected.
1513 clearPolicyMix();
1514 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,
1515 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, "", audioConfig);
1516 ASSERT_EQ(INVALID_OPERATION, ret);
1517
1518 // The first time to register policy mixes with valid parameter should succeed.
1519 clearPolicyMix();
1520 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1521 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
1522 audioConfig.sample_rate = k48000SamplingRate;
1523 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,
1524 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, mMixAddress, audioConfig);
1525 ASSERT_EQ(NO_ERROR, ret);
1526 // Registering the same policy mixes should fail.
1527 ret = mManager->registerPolicyMixes(mAudioMixes);
1528 ASSERT_EQ(INVALID_OPERATION, ret);
1529
1530 // Registration should fail due to device not found.
1531 // Note that earpiece is not present in the test configuration file.
1532 // This will need to be updated if earpiece is added in the test configuration file.
1533 clearPolicyMix();
1534 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
1535 AUDIO_DEVICE_OUT_EARPIECE, "", audioConfig);
1536 ASSERT_EQ(INVALID_OPERATION, ret);
1537
1538 // Registration should fail due to output not found.
1539 clearPolicyMix();
1540 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
1541 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, "", audioConfig);
1542 ASSERT_EQ(INVALID_OPERATION, ret);
1543
1544 // The first time to register valid loopback policy mix should succeed.
1545 clearPolicyMix();
1546 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,
1547 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, "addr", audioConfig);
1548 ASSERT_EQ(NO_ERROR, ret);
1549 // Registering the render policy for the loopback address should succeed.
1550 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
1551 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, "addr", audioConfig);
1552 ASSERT_EQ(INVALID_OPERATION, ret);
1553 }
1554
TEST_F(AudioPolicyManagerTestDynamicPolicy,UnregisterPolicyMixes)1555 TEST_F(AudioPolicyManagerTestDynamicPolicy, UnregisterPolicyMixes) {
1556 status_t ret;
1557 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
1558
1559 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1560 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
1561 audioConfig.sample_rate = k48000SamplingRate;
1562 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,
1563 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, mMixAddress, audioConfig);
1564 ASSERT_EQ(NO_ERROR, ret);
1565
1566 // After successfully registering policy mixes, it should be able to unregister.
1567 ret = mManager->unregisterPolicyMixes(mAudioMixes);
1568 ASSERT_EQ(NO_ERROR, ret);
1569
1570 // After unregistering policy mixes successfully, it should fail unregistering
1571 // the same policy mixes as they are not registered.
1572 ret = mManager->unregisterPolicyMixes(mAudioMixes);
1573 ASSERT_EQ(INVALID_OPERATION, ret);
1574 }
1575
TEST_F(AudioPolicyManagerTestDynamicPolicy,RegisterPolicyWithConsistentMixSucceeds)1576 TEST_F(AudioPolicyManagerTestDynamicPolicy, RegisterPolicyWithConsistentMixSucceeds) {
1577 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
1578 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1579 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
1580 audioConfig.sample_rate = k48000SamplingRate;
1581
1582 std::vector<AudioMixMatchCriterion> mixMatchCriteria = {
1583 createUidCriterion(/*uid=*/42),
1584 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/true)};
1585 status_t ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,
1586 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, mMixAddress, audioConfig,
1587 mixMatchCriteria);
1588 ASSERT_EQ(NO_ERROR, ret);
1589 }
1590
TEST_F(AudioPolicyManagerTestDynamicPolicy,RegisterPolicyWithInconsistentMixFails)1591 TEST_F(AudioPolicyManagerTestDynamicPolicy, RegisterPolicyWithInconsistentMixFails) {
1592 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
1593 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1594 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
1595 audioConfig.sample_rate = k48000SamplingRate;
1596
1597 std::vector<AudioMixMatchCriterion> mixMatchCriteria = {
1598 createUidCriterion(/*uid=*/42),
1599 createUidCriterion(/*uid=*/1235, /*exclude=*/true),
1600 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/true)};
1601 status_t ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,
1602 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, mMixAddress, audioConfig,
1603 mixMatchCriteria);
1604 ASSERT_EQ(INVALID_OPERATION, ret);
1605 }
1606
TEST_F_WITH_FLAGS(AudioPolicyManagerTestDynamicPolicy,RegisterInvalidMixesDoesNotImpactPriorMixes,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (android::media::audiopolicy,audio_mix_test_api),ACONFIG_FLAG (android::media::audiopolicy,audio_mix_ownership)))1607 TEST_F_WITH_FLAGS(
1608 AudioPolicyManagerTestDynamicPolicy,
1609 RegisterInvalidMixesDoesNotImpactPriorMixes,
1610 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(android::media::audiopolicy, audio_mix_test_api),
1611 ACONFIG_FLAG(android::media::audiopolicy, audio_mix_ownership))
1612 ) {
1613 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
1614 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1615 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
1616 audioConfig.sample_rate = k48000SamplingRate;
1617
1618 std::vector<AudioMixMatchCriterion> validMixMatchCriteria = {
1619 createUidCriterion(/*uid=*/42),
1620 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/true)};
1621 AudioMix validAudioMix(validMixMatchCriteria, MIX_TYPE_PLAYERS, audioConfig,
1622 MIX_ROUTE_FLAG_LOOP_BACK, String8(mMixAddress.c_str()), 0);
1623 validAudioMix.mDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
1624
1625 mAudioMixes.clear();
1626 status_t ret = addPolicyMix(validAudioMix);
1627
1628 ASSERT_EQ(NO_ERROR, ret);
1629
1630 std::vector<AudioMix> registeredMixes = getRegisteredPolicyMixes();
1631 ASSERT_EQ(1, registeredMixes.size());
1632
1633 std::vector<AudioMixMatchCriterion> invalidMixMatchCriteria = {
1634 createUidCriterion(/*uid=*/42),
1635 createUidCriterion(/*uid=*/1235, /*exclude=*/true),
1636 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/true)};
1637
1638 AudioMix invalidAudioMix(invalidMixMatchCriteria, MIX_TYPE_PLAYERS, audioConfig,
1639 MIX_ROUTE_FLAG_LOOP_BACK, String8(mMixAddress.c_str()), 0);
1640 validAudioMix.mDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
1641
1642 ret = addPolicyMix(invalidAudioMix);
1643
1644 ASSERT_EQ(INVALID_OPERATION, ret);
1645
1646 std::vector<AudioMix> remainingMixes = getRegisteredPolicyMixes();
1647 ASSERT_EQ(registeredMixes.size(), remainingMixes.size());
1648 }
1649
TEST_F_WITH_FLAGS(AudioPolicyManagerTestDynamicPolicy,UnregisterInvalidMixesReturnsError,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (android::media::audiopolicy,audio_mix_test_api),ACONFIG_FLAG (android::media::audiopolicy,audio_mix_ownership)))1650 TEST_F_WITH_FLAGS(
1651 AudioPolicyManagerTestDynamicPolicy,
1652 UnregisterInvalidMixesReturnsError,
1653 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(android::media::audiopolicy, audio_mix_test_api),
1654 ACONFIG_FLAG(android::media::audiopolicy, audio_mix_ownership))
1655 ) {
1656 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
1657 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1658 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
1659 audioConfig.sample_rate = k48000SamplingRate;
1660
1661 std::vector<AudioMixMatchCriterion> validMixMatchCriteria = {
1662 createUidCriterion(/*uid=*/42),
1663 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/true)};
1664 AudioMix validAudioMix(validMixMatchCriteria, MIX_TYPE_PLAYERS, audioConfig,
1665 MIX_ROUTE_FLAG_LOOP_BACK, String8(mMixAddress.c_str()), 0);
1666 validAudioMix.mDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
1667
1668 mAudioMixes.clear();
1669 status_t ret = addPolicyMix(validAudioMix);
1670
1671 ASSERT_EQ(NO_ERROR, ret);
1672
1673 std::vector<AudioMix> registeredMixes = getRegisteredPolicyMixes();
1674 ASSERT_EQ(1, registeredMixes.size());
1675
1676 std::vector<AudioMixMatchCriterion> invalidMixMatchCriteria = {
1677 createUidCriterion(/*uid=*/42),
1678 createUidCriterion(/*uid=*/1235, /*exclude=*/true),
1679 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/true)};
1680
1681 AudioMix invalidAudioMix(invalidMixMatchCriteria, MIX_TYPE_PLAYERS, audioConfig,
1682 MIX_ROUTE_FLAG_LOOP_BACK, String8(mMixAddress.c_str()), 0);
1683 invalidAudioMix.mDeviceType = AUDIO_DEVICE_OUT_REMOTE_SUBMIX;
1684
1685 Vector<AudioMix> mixes;
1686 mixes.add(invalidAudioMix);
1687 mixes.add(validAudioMix);
1688 ret = removePolicyMixes(mixes);
1689
1690 ASSERT_EQ(INVALID_OPERATION, ret);
1691
1692 std::vector<AudioMix> remainingMixes = getRegisteredPolicyMixes();
1693 EXPECT_THAT(remainingMixes, IsEmpty());
1694 }
1695
TEST_F_WITH_FLAGS(AudioPolicyManagerTestDynamicPolicy,GetRegisteredPolicyMixes,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (android::media::audiopolicy,audio_mix_test_api)))1696 TEST_F_WITH_FLAGS(
1697 AudioPolicyManagerTestDynamicPolicy,
1698 GetRegisteredPolicyMixes,
1699 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(android::media::audiopolicy, audio_mix_test_api))
1700 ) {
1701 std::vector<AudioMix> mixes = getRegisteredPolicyMixes();
1702 EXPECT_THAT(mixes, IsEmpty());
1703 }
1704
TEST_F_WITH_FLAGS(AudioPolicyManagerTestDynamicPolicy,AddPolicyMixAndVerifyGetRegisteredPolicyMixes,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (android::media::audiopolicy,audio_mix_test_api)))1705 TEST_F_WITH_FLAGS(AudioPolicyManagerTestDynamicPolicy,
1706 AddPolicyMixAndVerifyGetRegisteredPolicyMixes,
1707 REQUIRES_FLAGS_ENABLED(ACONFIG_FLAG(android::media::audiopolicy, audio_mix_test_api))
1708 ) {
1709 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
1710 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1711 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
1712 audioConfig.sample_rate = k48000SamplingRate;
1713
1714 std::vector<AudioMixMatchCriterion> mixMatchCriteria = {
1715 createUidCriterion(/*uid=*/42),
1716 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/true)};
1717 status_t ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,
1718 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, mMixAddress, audioConfig,
1719 mixMatchCriteria);
1720 ASSERT_EQ(NO_ERROR, ret);
1721
1722 std::vector<AudioMix> mixes = getRegisteredPolicyMixes();
1723 ASSERT_EQ(mixes.size(), 1);
1724
1725 const AudioMix& mix = mixes[0];
1726 ASSERT_EQ(mix.mCriteria.size(), mixMatchCriteria.size());
1727 for (uint32_t i = 0; i < mixMatchCriteria.size(); i++) {
1728 EXPECT_EQ(mix.mCriteria[i].mRule, mixMatchCriteria[i].mRule);
1729 EXPECT_EQ(mix.mCriteria[i].mValue.mUsage, mixMatchCriteria[i].mValue.mUsage);
1730 }
1731 EXPECT_EQ(mix.mDeviceType, AUDIO_DEVICE_OUT_REMOTE_SUBMIX);
1732 EXPECT_EQ(mix.mRouteFlags, MIX_ROUTE_FLAG_LOOP_BACK);
1733 EXPECT_EQ(mix.mMixType, MIX_TYPE_PLAYERS);
1734 EXPECT_EQ(mix.mFormat.channel_mask, audioConfig.channel_mask);
1735 EXPECT_EQ(mix.mFormat.format, audioConfig.format);
1736 EXPECT_EQ(mix.mFormat.sample_rate, audioConfig.sample_rate);
1737 EXPECT_EQ(mix.mFormat.frame_count, audioConfig.frame_count);
1738 }
1739
1740 class AudioPolicyManagerTestForHdmi
1741 : public AudioPolicyManagerTestWithConfigurationFile,
1742 public testing::WithParamInterface<audio_format_t> {
1743 protected:
1744 void SetUp() override;
getConfigFile()1745 std::string getConfigFile() override { return sTvConfig; }
1746 std::map<audio_format_t, bool> getSurroundFormatsHelper();
1747 std::vector<audio_format_t> getReportedSurroundFormatsHelper();
1748 std::unordered_set<audio_format_t> getFormatsFromPorts();
1749 void TearDown() override;
1750
1751 static const std::string sTvConfig;
1752
1753 };
1754
1755 const std::string AudioPolicyManagerTestForHdmi::sTvConfig =
1756 AudioPolicyManagerTestForHdmi::sExecutableDir +
1757 "test_settop_box_surround_configuration.xml";
1758
SetUp()1759 void AudioPolicyManagerTestForHdmi::SetUp() {
1760 ASSERT_NO_FATAL_FAILURE(AudioPolicyManagerTest::SetUp());
1761 mClient->addSupportedFormat(AUDIO_FORMAT_AC3);
1762 mClient->addSupportedFormat(AUDIO_FORMAT_E_AC3);
1763 mClient->addSupportedChannelMask(AUDIO_CHANNEL_OUT_STEREO);
1764 mManager->setDeviceConnectionState(
1765 AUDIO_DEVICE_OUT_HDMI, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
1766 "" /*address*/, "" /*name*/, AUDIO_FORMAT_DEFAULT);
1767 }
1768
TearDown()1769 void AudioPolicyManagerTestForHdmi::TearDown() {
1770 mManager->setDeviceConnectionState(
1771 AUDIO_DEVICE_OUT_HDMI, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
1772 "" /*address*/, "" /*name*/, AUDIO_FORMAT_DEFAULT);
1773 AudioPolicyManagerTest::TearDown();
1774 }
1775
1776 std::map<audio_format_t, bool>
getSurroundFormatsHelper()1777 AudioPolicyManagerTestForHdmi::getSurroundFormatsHelper() {
1778 unsigned int numSurroundFormats = 0;
1779 std::map<audio_format_t, bool> surroundFormatsMap;
1780 status_t ret = mManager->getSurroundFormats(
1781 &numSurroundFormats, nullptr /* surroundFormats */,
1782 nullptr /* surroundFormatsEnabled */);
1783 EXPECT_EQ(NO_ERROR, ret);
1784 if (ret != NO_ERROR) {
1785 return surroundFormatsMap;
1786 }
1787 audio_format_t surroundFormats[numSurroundFormats];
1788 memset(surroundFormats, 0, sizeof(audio_format_t) * numSurroundFormats);
1789 bool surroundFormatsEnabled[numSurroundFormats];
1790 memset(surroundFormatsEnabled, 0, sizeof(bool) * numSurroundFormats);
1791 ret = mManager->getSurroundFormats(
1792 &numSurroundFormats, surroundFormats, surroundFormatsEnabled);
1793 EXPECT_EQ(NO_ERROR, ret);
1794 if (ret != NO_ERROR) {
1795 return surroundFormatsMap;
1796 }
1797 for (int i = 0; i< numSurroundFormats; i++) {
1798 surroundFormatsMap[surroundFormats[i]] = surroundFormatsEnabled[i];
1799 }
1800 return surroundFormatsMap;
1801 }
1802
getReportedSurroundFormatsHelper()1803 std::vector<audio_format_t> AudioPolicyManagerTestForHdmi::getReportedSurroundFormatsHelper() {
1804 unsigned int numSurroundFormats = 0;
1805 std::vector<audio_format_t> surroundFormatsVector;
1806 status_t ret = mManager->getReportedSurroundFormats(
1807 &numSurroundFormats, nullptr /* surroundFormats */);
1808 EXPECT_EQ(NO_ERROR, ret);
1809 if (ret != NO_ERROR) {
1810 return surroundFormatsVector;
1811 }
1812 audio_format_t surroundFormats[numSurroundFormats];
1813 memset(surroundFormats, 0, sizeof(audio_format_t) * numSurroundFormats);
1814 ret = mManager->getReportedSurroundFormats(&numSurroundFormats, surroundFormats);
1815 EXPECT_EQ(NO_ERROR, ret);
1816 if (ret != NO_ERROR) {
1817 return surroundFormatsVector;
1818 }
1819 for (const auto &surroundFormat : surroundFormats) {
1820 surroundFormatsVector.push_back(surroundFormat);
1821 }
1822 return surroundFormatsVector;
1823 }
1824
1825 std::unordered_set<audio_format_t>
getFormatsFromPorts()1826 AudioPolicyManagerTestForHdmi::getFormatsFromPorts() {
1827 uint32_t numPorts = 0;
1828 uint32_t generation1;
1829 status_t ret;
1830 std::unordered_set<audio_format_t> formats;
1831 ret = mManager->listAudioPorts(
1832 AUDIO_PORT_ROLE_SINK, AUDIO_PORT_TYPE_DEVICE, &numPorts, nullptr, &generation1);
1833 EXPECT_EQ(NO_ERROR, ret) << "mManager->listAudioPorts returned error";
1834 if (ret != NO_ERROR) {
1835 return formats;
1836 }
1837 struct audio_port_v7 ports[numPorts];
1838 ret = mManager->listAudioPorts(
1839 AUDIO_PORT_ROLE_SINK, AUDIO_PORT_TYPE_DEVICE, &numPorts, ports, &generation1);
1840 EXPECT_EQ(NO_ERROR, ret) << "mManager->listAudioPorts returned error";
1841 if (ret != NO_ERROR) {
1842 return formats;
1843 }
1844 for (const auto &port : ports) {
1845 for (size_t i = 0; i < port.num_audio_profiles; ++i) {
1846 formats.insert(port.audio_profiles[i].format);
1847 }
1848 }
1849 return formats;
1850 }
1851
TEST_P(AudioPolicyManagerTestForHdmi,GetSurroundFormatsReturnsSupportedFormats)1852 TEST_P(AudioPolicyManagerTestForHdmi, GetSurroundFormatsReturnsSupportedFormats) {
1853 mManager->setForceUse(
1854 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND, AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS);
1855 auto surroundFormats = getSurroundFormatsHelper();
1856 ASSERT_EQ(1, surroundFormats.count(GetParam()));
1857 }
1858
TEST_P(AudioPolicyManagerTestForHdmi,GetSurroundFormatsReturnsManipulatedFormats)1859 TEST_P(AudioPolicyManagerTestForHdmi,
1860 GetSurroundFormatsReturnsManipulatedFormats) {
1861 mManager->setForceUse(
1862 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND, AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL);
1863
1864 status_t ret =
1865 mManager->setSurroundFormatEnabled(GetParam(), false /*enabled*/);
1866 ASSERT_EQ(NO_ERROR, ret);
1867 auto surroundFormats = getSurroundFormatsHelper();
1868 ASSERT_EQ(1, surroundFormats.count(GetParam()));
1869 ASSERT_FALSE(surroundFormats[GetParam()]);
1870
1871 ret = mManager->setSurroundFormatEnabled(GetParam(), true /*enabled*/);
1872 ASSERT_EQ(NO_ERROR, ret);
1873 surroundFormats = getSurroundFormatsHelper();
1874 ASSERT_EQ(1, surroundFormats.count(GetParam()));
1875 ASSERT_TRUE(surroundFormats[GetParam()]);
1876
1877 ret = mManager->setSurroundFormatEnabled(GetParam(), false /*enabled*/);
1878 ASSERT_EQ(NO_ERROR, ret);
1879 surroundFormats = getSurroundFormatsHelper();
1880 ASSERT_EQ(1, surroundFormats.count(GetParam()));
1881 ASSERT_FALSE(surroundFormats[GetParam()]);
1882 }
1883
TEST_P(AudioPolicyManagerTestForHdmi,ListAudioPortsReturnManipulatedHdmiFormats)1884 TEST_P(AudioPolicyManagerTestForHdmi,
1885 ListAudioPortsReturnManipulatedHdmiFormats) {
1886 mManager->setForceUse(
1887 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND, AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL);
1888
1889 ASSERT_EQ(NO_ERROR, mManager->setSurroundFormatEnabled(GetParam(), true /*enabled*/));
1890 auto formats = getFormatsFromPorts();
1891 ASSERT_EQ(1, formats.count(GetParam()));
1892
1893 ASSERT_EQ(NO_ERROR, mManager->setSurroundFormatEnabled(GetParam(), false /*enabled*/));
1894 formats = getFormatsFromPorts();
1895 ASSERT_EQ(0, formats.count(GetParam()));
1896 }
1897
TEST_P(AudioPolicyManagerTestForHdmi,GetReportedSurroundFormatsReturnsHdmiReportedFormats)1898 TEST_P(AudioPolicyManagerTestForHdmi,
1899 GetReportedSurroundFormatsReturnsHdmiReportedFormats) {
1900 mManager->setForceUse(
1901 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND, AUDIO_POLICY_FORCE_ENCODED_SURROUND_ALWAYS);
1902 auto surroundFormats = getReportedSurroundFormatsHelper();
1903 ASSERT_EQ(1, std::count(surroundFormats.begin(), surroundFormats.end(), GetParam()));
1904 }
1905
TEST_P(AudioPolicyManagerTestForHdmi,GetReportedSurroundFormatsReturnsNonManipulatedHdmiReportedFormats)1906 TEST_P(AudioPolicyManagerTestForHdmi,
1907 GetReportedSurroundFormatsReturnsNonManipulatedHdmiReportedFormats) {
1908 mManager->setForceUse(
1909 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND, AUDIO_POLICY_FORCE_ENCODED_SURROUND_MANUAL);
1910
1911 status_t ret = mManager->setSurroundFormatEnabled(GetParam(), false /*enabled*/);
1912 ASSERT_EQ(NO_ERROR, ret);
1913 auto surroundFormats = getReportedSurroundFormatsHelper();
1914 ASSERT_EQ(1, std::count(surroundFormats.begin(), surroundFormats.end(), GetParam()));
1915
1916 ret = mManager->setSurroundFormatEnabled(GetParam(), true /*enabled*/);
1917 ASSERT_EQ(NO_ERROR, ret);
1918 surroundFormats = getReportedSurroundFormatsHelper();
1919 ASSERT_EQ(1, std::count(surroundFormats.begin(), surroundFormats.end(), GetParam()));
1920 }
1921
TEST_P(AudioPolicyManagerTestForHdmi,GetSurroundFormatsIgnoresSupportedFormats)1922 TEST_P(AudioPolicyManagerTestForHdmi, GetSurroundFormatsIgnoresSupportedFormats) {
1923 mManager->setForceUse(
1924 AUDIO_POLICY_FORCE_FOR_ENCODED_SURROUND, AUDIO_POLICY_FORCE_ENCODED_SURROUND_NEVER);
1925 auto surroundFormats = getSurroundFormatsHelper();
1926 ASSERT_EQ(1, surroundFormats.count(GetParam()));
1927 ASSERT_FALSE(surroundFormats[GetParam()]);
1928 }
1929
1930 INSTANTIATE_TEST_SUITE_P(SurroundFormatSupport, AudioPolicyManagerTestForHdmi,
1931 testing::Values(AUDIO_FORMAT_AC3, AUDIO_FORMAT_E_AC3),
__anon9f2131310402(const ::testing::TestParamInfo<AudioPolicyManagerTestForHdmi::ParamType>& info) 1932 [](const ::testing::TestParamInfo<AudioPolicyManagerTestForHdmi::ParamType>& info) {
1933 return audio_format_to_string(info.param);
1934 });
1935
1936 class AudioPolicyManagerTestDPNoRemoteSubmixModule : public AudioPolicyManagerTestDynamicPolicy {
1937 protected:
getConfigFile()1938 std::string getConfigFile() override { return sPrimaryOnlyConfig; }
1939
1940 static const std::string sPrimaryOnlyConfig;
1941 };
1942
1943 const std::string AudioPolicyManagerTestDPNoRemoteSubmixModule::sPrimaryOnlyConfig =
1944 sExecutableDir + "test_audio_policy_primary_only_configuration.xml";
1945
TEST_F(AudioPolicyManagerTestDPNoRemoteSubmixModule,InitSuccess)1946 TEST_F(AudioPolicyManagerTestDPNoRemoteSubmixModule, InitSuccess) {
1947 // SetUp must finish with no assertions.
1948 }
1949
TEST_F(AudioPolicyManagerTestDPNoRemoteSubmixModule,Dump)1950 TEST_F(AudioPolicyManagerTestDPNoRemoteSubmixModule, Dump) {
1951 dumpToLog();
1952 }
1953
TEST_F(AudioPolicyManagerTestDPNoRemoteSubmixModule,RegistrationFailure)1954 TEST_F(AudioPolicyManagerTestDPNoRemoteSubmixModule, RegistrationFailure) {
1955 // Registration/Unregistration should fail due to module for remote submix not found.
1956 status_t ret;
1957 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
1958 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
1959 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
1960 audioConfig.sample_rate = k48000SamplingRate;
1961 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,
1962 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, "", audioConfig);
1963 ASSERT_EQ(INVALID_OPERATION, ret);
1964
1965 ret = mManager->unregisterPolicyMixes(mAudioMixes);
1966 ASSERT_EQ(INVALID_OPERATION, ret);
1967 }
1968
1969 struct DPTestParam {
DPTestParamDPTestParam1970 DPTestParam(const std::vector<AudioMixMatchCriterion>& mixCriteria,
1971 bool expected_match = false)
1972 : mixCriteria(mixCriteria), attributes(defaultAttr), session(AUDIO_SESSION_NONE),
1973 expected_match(expected_match) {}
1974
withUsageDPTestParam1975 DPTestParam& withUsage(audio_usage_t usage) {
1976 attributes.usage = usage;
1977 return *this;
1978 }
1979
withTagsDPTestParam1980 DPTestParam& withTags(const char *tags) {
1981 std::strncpy(attributes.tags, tags, sizeof(attributes.tags));
1982 return *this;
1983 }
1984
withSourceDPTestParam1985 DPTestParam& withSource(audio_source_t source) {
1986 attributes.source = source;
1987 return *this;
1988 }
1989
withSessionIdDPTestParam1990 DPTestParam& withSessionId(audio_session_t sessionId) {
1991 session = sessionId;
1992 return *this;
1993 }
1994
1995 std::vector<AudioMixMatchCriterion> mixCriteria;
1996 audio_attributes_t attributes;
1997 audio_session_t session;
1998 bool expected_match;
1999 };
2000
2001 class AudioPolicyManagerTestDPPlaybackReRouting : public AudioPolicyManagerTestDynamicPolicy,
2002 public testing::WithParamInterface<DPTestParam> {
2003 protected:
2004 void SetUp() override;
2005 };
2006
SetUp()2007 void AudioPolicyManagerTestDPPlaybackReRouting::SetUp() {
2008 ASSERT_NO_FATAL_FAILURE(AudioPolicyManagerTestDynamicPolicy::SetUp());
2009
2010 mTracker.reset(new RecordingActivityTracker());
2011
2012 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
2013 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2014 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
2015 audioConfig.sample_rate = k48000SamplingRate;
2016
2017 DPTestParam param = GetParam();
2018 ASSERT_NO_FATAL_FAILURE(
2019 addPolicyMixAndStartInputForLoopback(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_LOOP_BACK,
2020 AUDIO_DEVICE_OUT_REMOTE_SUBMIX, mMixAddress, audioConfig, param.mixCriteria,
2021 param.session));
2022 }
2023
TEST_P(AudioPolicyManagerTestDPPlaybackReRouting,PlaybackReRouting)2024 TEST_P(AudioPolicyManagerTestDPPlaybackReRouting, PlaybackReRouting) {
2025 const DPTestParam param = GetParam();
2026 const audio_attributes_t& attr = param.attributes;
2027
2028 DeviceIdVector playbackRoutedPortIds;
2029 getOutputForAttr(&playbackRoutedPortIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
2030 k48000SamplingRate, AUDIO_OUTPUT_FLAG_NONE, nullptr /*output*/, nullptr /*portId*/,
2031 attr, param.session);
2032 if (param.expected_match) {
2033 ASSERT_EQ(mInjectionPort.id, playbackRoutedPortIds[0]);
2034 } else {
2035 ASSERT_GT(playbackRoutedPortIds.size(), 0);
2036 ASSERT_NE(mInjectionPort.id, playbackRoutedPortIds[0]);
2037 }
2038 }
2039
2040 const std::vector<AudioMixMatchCriterion> USAGE_MEDIA_ALARM_CRITERIA = {
2041 createUsageCriterion(AUDIO_USAGE_MEDIA),
2042 createUsageCriterion(AUDIO_USAGE_ALARM)
2043 };
2044
2045 INSTANTIATE_TEST_SUITE_P(
2046 PlaybackReroutingUsageMatch,
2047 AudioPolicyManagerTestDPPlaybackReRouting,
2048 testing::Values(
2049 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2050 .withUsage(AUDIO_USAGE_MEDIA),
2051 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2052 .withUsage(AUDIO_USAGE_MEDIA).withTags("addr=other"),
2053 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2054 .withUsage(AUDIO_USAGE_ALARM),
2055 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2056 .withUsage(AUDIO_USAGE_VOICE_COMMUNICATION),
2057 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2058 .withUsage(AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING),
2059 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2060 .withUsage(AUDIO_USAGE_NOTIFICATION),
2061 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2062 .withUsage(AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE),
2063 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2064 .withUsage(AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST),
2065 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2066 .withUsage(AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT),
2067 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2068 .withUsage(AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED),
2069 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2070 .withUsage(AUDIO_USAGE_NOTIFICATION_EVENT),
2071 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2072 .withUsage(AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY),
2073 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2074 .withUsage(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE),
2075 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2076 .withUsage(AUDIO_USAGE_ASSISTANCE_SONIFICATION),
2077 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2078 .withUsage(AUDIO_USAGE_GAME),
2079 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ false)
2080 .withUsage(AUDIO_USAGE_ASSISTANT)));
2081
2082 INSTANTIATE_TEST_SUITE_P(
2083 PlaybackReroutingAddressPriorityMatch,
2084 AudioPolicyManagerTestDPPlaybackReRouting,
2085 testing::Values(
2086 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2087 .withUsage(AUDIO_USAGE_MEDIA).withTags("addr=remote_submix_media"),
2088 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2089 .withUsage(AUDIO_USAGE_VOICE_COMMUNICATION).withTags("addr=remote_submix_media"),
2090 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2091 .withUsage(AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING)
2092 .withTags("addr=remote_submix_media"),
2093 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2094 .withUsage(AUDIO_USAGE_ALARM)
2095 .withTags("addr=remote_submix_media"),
2096 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2097 .withUsage(AUDIO_USAGE_NOTIFICATION)
2098 .withTags("addr=remote_submix_media"),
2099 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2100 .withUsage(AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE)
2101 .withTags("addr=remote_submix_media"),
2102 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2103 .withUsage(AUDIO_USAGE_NOTIFICATION_COMMUNICATION_REQUEST)
2104 .withTags("addr=remote_submix_media"),
2105 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2106 .withUsage(AUDIO_USAGE_NOTIFICATION_COMMUNICATION_INSTANT)
2107 .withTags("addr=remote_submix_media"),
2108 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2109 .withUsage(AUDIO_USAGE_NOTIFICATION_COMMUNICATION_DELAYED)
2110 .withTags("addr=remote_submix_media"),
2111 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2112 .withUsage(AUDIO_USAGE_NOTIFICATION_EVENT)
2113 .withTags("addr=remote_submix_media"),
2114 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2115 .withUsage(AUDIO_USAGE_ASSISTANCE_ACCESSIBILITY)
2116 .withTags("addr=remote_submix_media"),
2117 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2118 .withUsage(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE)
2119 .withTags("addr=remote_submix_media"),
2120 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2121 .withUsage(AUDIO_USAGE_ASSISTANCE_SONIFICATION)
2122 .withTags("addr=remote_submix_media"),
2123 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2124 .withUsage(AUDIO_USAGE_GAME)
2125 .withTags("addr=remote_submix_media"),
2126 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2127 .withUsage(AUDIO_USAGE_VIRTUAL_SOURCE)
2128 .withTags("addr=remote_submix_media"),
2129 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2130 .withUsage(AUDIO_USAGE_ASSISTANT)
2131 .withTags("addr=remote_submix_media"),
2132 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2133 .withUsage(AUDIO_USAGE_ASSISTANT)
2134 .withTags("sometag;addr=remote_submix_media;othertag=somevalue"),
2135 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2136 .withUsage(AUDIO_USAGE_ASSISTANT)
2137 .withTags("addr=remote_submix_media;othertag"),
2138 DPTestParam(USAGE_MEDIA_ALARM_CRITERIA, /*expected_match=*/ true)
2139 .withUsage(AUDIO_USAGE_ASSISTANT)
2140 .withTags("sometag;othertag;addr=remote_submix_media")));
2141
2142 static constexpr audio_session_t TEST_SESSION_ID = static_cast<audio_session_t>(42);
2143 static constexpr audio_session_t OTHER_SESSION_ID = static_cast<audio_session_t>(77);
2144
2145 INSTANTIATE_TEST_SUITE_P(
2146 PlaybackReRoutingWithSessionId,
2147 AudioPolicyManagerTestDPPlaybackReRouting,
2148 testing::Values(
2149 // Mix is matched because the session id matches the one specified by the mix rule.
2150 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID)},
2151 /*expected_match=*/ true)
2152 .withSessionId(TEST_SESSION_ID),
2153 // Mix is not matched because the session id doesn't match the one specified
2154 // by the mix rule.
2155 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID)},
2156 /*expected_match=*/ false)
2157 .withSessionId(OTHER_SESSION_ID),
2158 // Mix is matched, the session id doesn't match the one specified by rule,
2159 // but there's address specified in the tags which takes precedence.
2160 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID)},
2161 /*expected_match=*/ true)
2162 .withSessionId(OTHER_SESSION_ID).withTags("addr=remote_submix_media"),
2163 // Mix is matched, both the session id and the usage match ones specified by mix rule.
2164 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID),
2165 createUsageCriterion(AUDIO_USAGE_MEDIA)},
2166 /*expected_match=*/ true)
2167 .withSessionId(TEST_SESSION_ID).withUsage(AUDIO_USAGE_MEDIA),
2168 // Mix is not matched, the session id matches the one specified by mix rule,
2169 // but usage does not.
2170 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID),
2171 createUsageCriterion(AUDIO_USAGE_MEDIA)},
2172 /*expected_match=*/ false)
2173 .withSessionId(TEST_SESSION_ID).withUsage(AUDIO_USAGE_GAME),
2174 // Mix is not matched, the usage matches the one specified by mix rule,
2175 // but the session id is excluded.
2176 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID, /*exclude=*/ true),
2177 createUsageCriterion(AUDIO_USAGE_MEDIA)},
2178 /*expected_match=*/ false)
2179 .withSessionId(TEST_SESSION_ID).withUsage(AUDIO_USAGE_MEDIA)));
2180
2181 struct DPMmapTestParam {
DPMmapTestParamDPMmapTestParam2182 DPMmapTestParam(int mixRouteFlags, audio_devices_t deviceType, const std::string& deviceAddress)
2183 : mixRouteFlags(mixRouteFlags), deviceType(deviceType), deviceAddress(deviceAddress) {}
2184
2185 int mixRouteFlags;
2186 audio_devices_t deviceType;
2187 std::string deviceAddress;
2188 };
2189
2190 class AudioPolicyManagerTestMMapPlaybackRerouting
2191 : public AudioPolicyManagerTestDynamicPolicy,
2192 public ::testing::WithParamInterface<DPMmapTestParam> {
2193 protected:
SetUp()2194 void SetUp() override {
2195 AudioPolicyManagerTestDynamicPolicy::SetUp();
2196 audioConfig = AUDIO_CONFIG_INITIALIZER;
2197 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2198 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
2199 audioConfig.sample_rate = k48000SamplingRate;
2200 }
2201
2202 audio_config_t audioConfig;
2203 audio_io_handle_t mOutput;
2204 audio_stream_type_t mStream = AUDIO_STREAM_DEFAULT;
2205 DeviceIdVector mSelectedDeviceIds;
2206 audio_port_handle_t mPortId = AUDIO_PORT_HANDLE_NONE;
2207 AudioPolicyInterface::output_type_t mOutputType;
2208 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
2209 bool mIsSpatialized;
2210 bool mIsBitPerfect;
2211 float mVolume;
2212 bool mMuted;
2213 };
2214
TEST_P(AudioPolicyManagerTestMMapPlaybackRerouting,MmapPlaybackStreamMatchingLoopbackDapMixFails)2215 TEST_P(AudioPolicyManagerTestMMapPlaybackRerouting, MmapPlaybackStreamMatchingLoopbackDapMixFails) {
2216 // Add mix matching the test uid.
2217 const int testUid = 12345;
2218 const auto param = GetParam();
2219 ASSERT_NO_FATAL_FAILURE(
2220 addPolicyMixAndStartInputForLoopback(MIX_TYPE_PLAYERS, param.mixRouteFlags,
2221 param.deviceType, param.deviceAddress, audioConfig,
2222 {createUidCriterion(testUid)}));
2223
2224 // Getting output for matching uid and mmap-ed stream should fail.
2225 audio_output_flags_t outputFlags =
2226 (audio_output_flags_t) (AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
2227 ASSERT_EQ(INVALID_OPERATION,
2228 mManager->getOutputForAttr(&attr, &mOutput, AUDIO_SESSION_NONE, &mStream,
2229 createAttributionSourceState(testUid), &audioConfig,
2230 &outputFlags, &mSelectedDeviceIds, &mPortId, {},
2231 &mOutputType, &mIsSpatialized, &mIsBitPerfect, &mVolume,
2232 &mMuted));
2233 }
2234
TEST_P(AudioPolicyManagerTestMMapPlaybackRerouting,NonMmapPlaybackStreamMatchingLoopbackDapMixSucceeds)2235 TEST_P(AudioPolicyManagerTestMMapPlaybackRerouting,
2236 NonMmapPlaybackStreamMatchingLoopbackDapMixSucceeds) {
2237 // Add mix matching the test uid.
2238 const int testUid = 12345;
2239 const auto param = GetParam();
2240 ASSERT_NO_FATAL_FAILURE(
2241 addPolicyMixAndStartInputForLoopback(MIX_TYPE_PLAYERS, param.mixRouteFlags,
2242 param.deviceType,param.deviceAddress, audioConfig,
2243 {createUidCriterion(testUid)}));
2244
2245 // Getting output for matching uid should succeed for non-mmaped stream.
2246 audio_output_flags_t outputFlags = AUDIO_OUTPUT_FLAG_NONE;
2247 ASSERT_EQ(NO_ERROR,
2248 mManager->getOutputForAttr(&attr, &mOutput, AUDIO_SESSION_NONE, &mStream,
2249 createAttributionSourceState(testUid), &audioConfig,
2250 &outputFlags, &mSelectedDeviceIds, &mPortId, {},
2251 &mOutputType, &mIsSpatialized, &mIsBitPerfect, &mVolume,
2252 &mMuted));
2253 }
2254
TEST_F(AudioPolicyManagerTestMMapPlaybackRerouting,MmapPlaybackStreamMatchingRenderDapMixSupportingMmapSucceeds)2255 TEST_F(AudioPolicyManagerTestMMapPlaybackRerouting,
2256 MmapPlaybackStreamMatchingRenderDapMixSupportingMmapSucceeds) {
2257 const std::string usbAddress = "card=1;device=0";
2258 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
2259 AUDIO_DEVICE_OUT_USB_DEVICE, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2260 usbAddress.c_str(), "", AUDIO_FORMAT_DEFAULT));
2261 audio_port_v7 usbDevicePort;
2262 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_USB_DEVICE,
2263 usbAddress, &usbDevicePort));
2264
2265 // Add render-only mix matching the test uid.
2266 const int testUid = 12345;
2267 // test_audio_policy_configuration.xml declares mmap-capable mix port
2268 // for AUDIO_DEVICE_OUT_USB_DEVICE.
2269 ASSERT_EQ(NO_ERROR,
2270 addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2271 AUDIO_DEVICE_OUT_USB_DEVICE, /*mixAddress=*/"",
2272 audioConfig, {createUidCriterion(testUid)}));
2273
2274 static const audio_output_flags_t mmapDirectFlags =
2275 (audio_output_flags_t) (AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
2276 // Getting output for matching uid should succeed for mmaped stream, because matched mix
2277 // redirects to mmap capable device.
2278 audio_output_flags_t outputFlags = mmapDirectFlags;
2279 ASSERT_EQ(NO_ERROR,
2280 mManager->getOutputForAttr(&attr, &mOutput, AUDIO_SESSION_NONE, &mStream,
2281 createAttributionSourceState(testUid), &audioConfig,
2282 &outputFlags, &mSelectedDeviceIds, &mPortId, {},
2283 &mOutputType, &mIsSpatialized, &mIsBitPerfect, &mVolume,
2284 &mMuted));
2285 auto outputDesc = mManager->getOutputs().valueFor(mOutput);
2286 ASSERT_NE(nullptr, outputDesc);
2287 ASSERT_EQ(mmapDirectFlags, outputDesc->getFlags().output);
2288
2289 // After releasing the client, the output is closed. APM should reselect output for the policy
2290 // mix.
2291 mManager->releaseOutput(mPortId);
2292 ASSERT_EQ(nullptr, mManager->getOutputs().valueFor(mOutput));
2293 outputFlags = AUDIO_OUTPUT_FLAG_NONE;
2294 mPortId = AUDIO_PORT_HANDLE_NONE;
2295 ASSERT_EQ(NO_ERROR,
2296 mManager->getOutputForAttr(&attr, &mOutput, AUDIO_SESSION_NONE, &mStream,
2297 createAttributionSourceState(testUid), &audioConfig,
2298 &outputFlags, &mSelectedDeviceIds, &mPortId, {},
2299 &mOutputType, &mIsSpatialized, &mIsBitPerfect, &mVolume,
2300 &mMuted));
2301 ASSERT_EQ(usbDevicePort.id, mSelectedDeviceIds[0]);
2302 outputDesc = mManager->getOutputs().valueFor(mOutput);
2303 ASSERT_NE(nullptr, outputDesc);
2304 ASSERT_NE(mmapDirectFlags, outputDesc->getFlags().output);
2305
2306 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
2307 AUDIO_DEVICE_OUT_USB_DEVICE, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
2308 usbAddress.c_str(), "", AUDIO_FORMAT_DEFAULT));
2309 }
2310
TEST_F(AudioPolicyManagerTestMMapPlaybackRerouting,MmapPlaybackStreamMatchingRenderDapMixNotSupportingMmapFails)2311 TEST_F(AudioPolicyManagerTestMMapPlaybackRerouting,
2312 MmapPlaybackStreamMatchingRenderDapMixNotSupportingMmapFails) {
2313 // Add render-only mix matching the test uid.
2314 const int testUid = 12345;
2315 // Per test_audio_policy_configuration.xml AUDIO_DEVICE_OUT_SPEAKER doesn't support mmap.
2316 ASSERT_EQ(NO_ERROR,
2317 addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2318 AUDIO_DEVICE_OUT_SPEAKER, /*mixAddress=*/"", audioConfig,
2319 {createUidCriterion(testUid)}));
2320
2321 // Getting output for matching uid should fail for mmaped stream, because
2322 // matched mix redirects to device which doesn't support mmap.
2323 audio_output_flags_t outputFlags =
2324 (audio_output_flags_t) (AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT);
2325 ASSERT_EQ(INVALID_OPERATION,
2326 mManager->getOutputForAttr(&attr, &mOutput, AUDIO_SESSION_NONE, &mStream,
2327 createAttributionSourceState(testUid), &audioConfig,
2328 &outputFlags, &mSelectedDeviceIds, &mPortId, {},
2329 &mOutputType, &mIsSpatialized, &mIsBitPerfect, &mVolume,
2330 &mMuted));
2331 }
2332
2333 INSTANTIATE_TEST_SUITE_P(
2334 MmapPlaybackRerouting, AudioPolicyManagerTestMMapPlaybackRerouting,
2335 testing::Values(DPMmapTestParam(MIX_ROUTE_FLAG_LOOP_BACK, AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2336 /*deviceAddress=*/"remote_submix_media"),
2337 DPMmapTestParam(MIX_ROUTE_FLAG_LOOP_BACK_AND_RENDER,
2338 AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2339 /*deviceAddress=*/"remote_submix_media"),
2340 DPMmapTestParam(MIX_ROUTE_FLAG_RENDER, AUDIO_DEVICE_OUT_SPEAKER,
2341 /*deviceAddress=*/"")));
2342
2343 class AudioPolicyManagerTestDPMixRecordInjection : public AudioPolicyManagerTestDynamicPolicy,
2344 public testing::WithParamInterface<DPTestParam> {
2345 protected:
2346 void SetUp() override;
2347 void TearDown() override;
2348
2349 std::unique_ptr<RecordingActivityTracker> mTracker;
2350 struct audio_port_v7 mExtractionPort;
2351 audio_port_handle_t mPortId = AUDIO_PORT_HANDLE_NONE;
2352 };
2353
SetUp()2354 void AudioPolicyManagerTestDPMixRecordInjection::SetUp() {
2355 ASSERT_NO_FATAL_FAILURE(AudioPolicyManagerTestDynamicPolicy::SetUp());
2356
2357 mTracker.reset(new RecordingActivityTracker());
2358
2359 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
2360 audioConfig.channel_mask = AUDIO_CHANNEL_IN_STEREO;
2361 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
2362 audioConfig.sample_rate = k48000SamplingRate;
2363
2364 DPTestParam param = GetParam();
2365 status_t ret = addPolicyMix(MIX_TYPE_RECORDERS, MIX_ROUTE_FLAG_LOOP_BACK,
2366 AUDIO_DEVICE_IN_REMOTE_SUBMIX, mMixAddress, audioConfig, param.mixCriteria);
2367 ASSERT_EQ(NO_ERROR, ret);
2368
2369 struct audio_port_v7 injectionPort;
2370 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_REMOTE_SUBMIX,
2371 mMixAddress, &injectionPort));
2372
2373 DeviceIdVector selectedDeviceIds;
2374 audio_usage_t usage = AUDIO_USAGE_VIRTUAL_SOURCE;
2375 audio_attributes_t attr =
2376 {AUDIO_CONTENT_TYPE_UNKNOWN, usage, AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
2377 std::string tags = std::string("addr=") + mMixAddress;
2378 strncpy(attr.tags, tags.c_str(), AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1);
2379 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
2380 k48000SamplingRate, AUDIO_OUTPUT_FLAG_NONE, nullptr /*output*/, &mPortId, attr);
2381 ASSERT_EQ(NO_ERROR, mManager->startOutput(mPortId));
2382 ASSERT_EQ(injectionPort.id, getDeviceIdFromPatch(mClient->getLastAddedPatch()));
2383
2384 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SOURCE, AUDIO_DEVICE_IN_REMOTE_SUBMIX,
2385 mMixAddress, &mExtractionPort));
2386 }
2387
TearDown()2388 void AudioPolicyManagerTestDPMixRecordInjection::TearDown() {
2389 mManager->stopOutput(mPortId);
2390 AudioPolicyManagerTestDynamicPolicy::TearDown();
2391 }
2392
TEST_P(AudioPolicyManagerTestDPMixRecordInjection,RecordingInjection)2393 TEST_P(AudioPolicyManagerTestDPMixRecordInjection, RecordingInjection) {
2394 const DPTestParam param = GetParam();
2395
2396 audio_port_handle_t captureRoutedPortId = AUDIO_PORT_HANDLE_NONE;
2397 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
2398 audio_io_handle_t input = AUDIO_PORT_HANDLE_NONE;
2399 getInputForAttr(param.attributes, &input, param.session, mTracker->getRiid(),
2400 &captureRoutedPortId, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
2401 k48000SamplingRate, AUDIO_INPUT_FLAG_NONE, &portId);
2402 if (param.expected_match) {
2403 EXPECT_EQ(mExtractionPort.id, captureRoutedPortId);
2404 } else {
2405 EXPECT_NE(mExtractionPort.id, captureRoutedPortId);
2406 }
2407 }
2408
2409 const std::vector<AudioMixMatchCriterion> SOURCE_CAM_MIC_VOICE_CRITERIA = {
2410 createCapturePresetCriterion(AUDIO_SOURCE_CAMCORDER),
2411 createCapturePresetCriterion(AUDIO_SOURCE_MIC),
2412 createCapturePresetCriterion(AUDIO_SOURCE_VOICE_COMMUNICATION)
2413 };
2414
2415 // No address priority rule for remote recording, address is a "don't care"
2416 INSTANTIATE_TEST_CASE_P(
2417 RecordInjectionSource,
2418 AudioPolicyManagerTestDPMixRecordInjection,
2419 testing::Values(
2420 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ true)
2421 .withSource(AUDIO_SOURCE_CAMCORDER),
2422 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ true)
2423 .withSource(AUDIO_SOURCE_CAMCORDER)
2424 .withTags("addr=remote_submix_media"),
2425 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ true)
2426 .withSource(AUDIO_SOURCE_MIC),
2427 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ true)
2428 .withSource(AUDIO_SOURCE_MIC)
2429 .withTags("addr=remote_submix_media"),
2430 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ true)
2431 .withSource(AUDIO_SOURCE_VOICE_COMMUNICATION),
2432 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ true)
2433 .withSource(AUDIO_SOURCE_VOICE_COMMUNICATION)
2434 .withTags("addr=remote_submix_media"),
2435 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ false)
2436 .withSource(AUDIO_SOURCE_VOICE_RECOGNITION),
2437 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ false)
2438 .withSource(AUDIO_SOURCE_VOICE_RECOGNITION)
2439 .withTags("addr=remote_submix_media"),
2440 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ false)
2441 .withSource(AUDIO_SOURCE_HOTWORD),
2442 DPTestParam(SOURCE_CAM_MIC_VOICE_CRITERIA, /*expected_match=*/ false)
2443 .withSource(AUDIO_SOURCE_HOTWORD)
2444 .withTags("addr=remote_submix_media")));
2445
2446 INSTANTIATE_TEST_CASE_P(
2447 RecordInjectionWithSessionId,
2448 AudioPolicyManagerTestDPMixRecordInjection,
2449 testing::Values(
2450 // Mix is matched because the session id matches the one specified by the mix rule.
2451 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID)},
2452 /*expected_match=*/ true)
2453 .withSessionId(TEST_SESSION_ID),
2454 // Mix is not matched because the session id doesn't match the one specified
2455 // by the mix rule.
2456 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID)},
2457 /*expected_match=*/ false)
2458 .withSessionId(OTHER_SESSION_ID),
2459 // Mix is not matched, the session id doesn't match the one specified by rule,
2460 // but tand address specified in the tags is ignored for recorder mix.
2461 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID)},
2462 /*expected_match=*/ false)
2463 .withSessionId(OTHER_SESSION_ID).withTags("addr=remote_submix_media"),
2464 // Mix is matched, both the session id and the source match ones specified by mix rule
2465 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID),
2466 createCapturePresetCriterion(AUDIO_SOURCE_CAMCORDER)},
2467 /*expected_match=*/ true)
2468 .withSessionId(TEST_SESSION_ID).withSource(AUDIO_SOURCE_CAMCORDER),
2469 // Mix is not matched, the session id matches the one specified by mix rule,
2470 // but source does not.
2471 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID),
2472 createCapturePresetCriterion(AUDIO_SOURCE_CAMCORDER)},
2473 /*expected_match=*/ false)
2474 .withSessionId(TEST_SESSION_ID).withSource(AUDIO_SOURCE_MIC),
2475 // Mix is not matched, the source matches the one specified by mix rule,
2476 // but the session id is excluded.
2477 DPTestParam(/*mixCriteria=*/ {createSessionIdCriterion(TEST_SESSION_ID,
2478 /*exclude=*/ true),
2479 createCapturePresetCriterion(AUDIO_SOURCE_MIC)},
2480 /*expected_match=*/ false)
2481 .withSessionId(TEST_SESSION_ID).withSource(AUDIO_SOURCE_MIC)));
2482
2483 using DeviceConnectionTestParams =
2484 std::tuple<audio_devices_t /*type*/, std::string /*name*/, std::string /*address*/>;
2485
2486 class AudioPolicyManagerTestDeviceConnection : public AudioPolicyManagerTestWithConfigurationFile,
2487 public testing::WithParamInterface<DeviceConnectionTestParams> {
2488 };
2489
TEST_F(AudioPolicyManagerTestDeviceConnection,InitSuccess)2490 TEST_F(AudioPolicyManagerTestDeviceConnection, InitSuccess) {
2491 // SetUp must finish with no assertions.
2492 }
2493
TEST_F(AudioPolicyManagerTestDeviceConnection,Dump)2494 TEST_F(AudioPolicyManagerTestDeviceConnection, Dump) {
2495 dumpToLog();
2496 }
2497
TEST_F(AudioPolicyManagerTestDeviceConnection,RoutingUpdate)2498 TEST_F(AudioPolicyManagerTestDeviceConnection, RoutingUpdate) {
2499 mClient->resetRoutingUpdatedCounter();
2500 // Connecting a valid output device with valid parameters should trigger a routing update
2501 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
2502 AUDIO_DEVICE_OUT_BLUETOOTH_SCO, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2503 "00:11:22:33:44:55", "b", AUDIO_FORMAT_DEFAULT));
2504 ASSERT_EQ(1, mClient->getRoutingUpdatedCounter());
2505
2506 // Disconnecting a connected device should succeed and trigger a routing update
2507 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
2508 AUDIO_DEVICE_OUT_BLUETOOTH_SCO, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
2509 "00:11:22:33:44:55", "b", AUDIO_FORMAT_DEFAULT));
2510 ASSERT_EQ(2, mClient->getRoutingUpdatedCounter());
2511
2512 // Disconnecting a disconnected device should fail and not trigger a routing update
2513 ASSERT_EQ(INVALID_OPERATION, mManager->setDeviceConnectionState(
2514 AUDIO_DEVICE_OUT_BLUETOOTH_SCO, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
2515 "00:11:22:33:44:55", "b", AUDIO_FORMAT_DEFAULT));
2516 ASSERT_EQ(2, mClient->getRoutingUpdatedCounter());
2517
2518 // Changing force use should trigger an update
2519 auto config = mManager->getForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA);
2520 auto newConfig = config == AUDIO_POLICY_FORCE_BT_A2DP ?
2521 AUDIO_POLICY_FORCE_NONE : AUDIO_POLICY_FORCE_BT_A2DP;
2522 mManager->setForceUse(AUDIO_POLICY_FORCE_FOR_MEDIA, newConfig);
2523 ASSERT_EQ(3, mClient->getRoutingUpdatedCounter());
2524 }
2525
TEST_P(AudioPolicyManagerTestDeviceConnection,SetDeviceConnectionState)2526 TEST_P(AudioPolicyManagerTestDeviceConnection, SetDeviceConnectionState) {
2527 const audio_devices_t type = std::get<0>(GetParam());
2528 const std::string name = std::get<1>(GetParam());
2529 const std::string address = std::get<2>(GetParam());
2530
2531 if (type == AUDIO_DEVICE_OUT_HDMI) {
2532 // Set device connection state failed due to no device descriptor found
2533 // For HDMI case, it is easier to simulate device descriptor not found error
2534 // by using an encoded format which isn't listed in the 'encodedFormats'
2535 // attribute for this devicePort.
2536 ASSERT_EQ(INVALID_OPERATION, mManager->setDeviceConnectionState(
2537 type, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2538 address.c_str(), name.c_str(), AUDIO_FORMAT_MAT_2_1));
2539 }
2540 // Connect with valid parameters should succeed
2541 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
2542 type, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2543 address.c_str(), name.c_str(), AUDIO_FORMAT_DEFAULT));
2544 // Try to connect with the same device again should fail
2545 ASSERT_EQ(INVALID_OPERATION, mManager->setDeviceConnectionState(
2546 type, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2547 address.c_str(), name.c_str(), AUDIO_FORMAT_DEFAULT));
2548 // Disconnect the connected device should succeed
2549 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
2550 type, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
2551 address.c_str(), name.c_str(), AUDIO_FORMAT_DEFAULT));
2552 // Disconnect device that is not connected should fail
2553 ASSERT_EQ(INVALID_OPERATION, mManager->setDeviceConnectionState(
2554 type, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
2555 address.c_str(), name.c_str(), AUDIO_FORMAT_DEFAULT));
2556 // Try to set device connection state with a invalid connection state should fail
2557 ASSERT_EQ(BAD_VALUE, mManager->setDeviceConnectionState(
2558 type, AUDIO_POLICY_DEVICE_STATE_CNT,
2559 "", "", AUDIO_FORMAT_DEFAULT));
2560 }
2561
TEST_P(AudioPolicyManagerTestDeviceConnection,ExplicitlyRoutingAfterConnection)2562 TEST_P(AudioPolicyManagerTestDeviceConnection, ExplicitlyRoutingAfterConnection) {
2563 const audio_devices_t type = std::get<0>(GetParam());
2564 const std::string name = std::get<1>(GetParam());
2565 const std::string address = std::get<2>(GetParam());
2566
2567 // Connect device to do explicitly routing test
2568 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
2569 type, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2570 address.c_str(), name.c_str(), AUDIO_FORMAT_DEFAULT));
2571
2572 audio_port_v7 devicePort;
2573 const audio_port_role_t role = audio_is_output_device(type)
2574 ? AUDIO_PORT_ROLE_SINK : AUDIO_PORT_ROLE_SOURCE;
2575 ASSERT_TRUE(findDevicePort(role, type, address, &devicePort));
2576
2577 // Try start input or output according to the device type
2578 if (audio_is_output_devices(type)) {
2579 DeviceIdVector routedPortIds = { devicePort.id };
2580 getOutputForAttr(&routedPortIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
2581 k48000SamplingRate, AUDIO_OUTPUT_FLAG_NONE);
2582 ASSERT_EQ(devicePort.id, routedPortIds[0]);
2583 } else if (audio_is_input_device(type)) {
2584 audio_port_handle_t routedPortId = devicePort.id;
2585 RecordingActivityTracker tracker;
2586 audio_io_handle_t input = AUDIO_PORT_HANDLE_NONE;
2587 getInputForAttr({}, &input, AUDIO_SESSION_NONE, tracker.getRiid(), &routedPortId,
2588 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO, k48000SamplingRate,
2589 AUDIO_INPUT_FLAG_NONE);
2590 ASSERT_EQ(devicePort.id, routedPortId);
2591 }
2592
2593 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
2594 type, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
2595 address.c_str(), name.c_str(), AUDIO_FORMAT_DEFAULT));
2596 }
2597
make_ExtraAudioDescriptor(android::media::audio::common::AudioStandard audioStandard,android::media::audio::common::AudioEncapsulationType audioEncapsulationType)2598 android::media::audio::common::ExtraAudioDescriptor make_ExtraAudioDescriptor(
2599 android::media::audio::common::AudioStandard audioStandard,
2600 android::media::audio::common::AudioEncapsulationType audioEncapsulationType) {
2601 android::media::audio::common::ExtraAudioDescriptor result;
2602 result.standard = audioStandard;
2603 result.audioDescriptor = {0xb4, 0xaf, 0x98, 0x1a};
2604 result.encapsulationType = audioEncapsulationType;
2605 return result;
2606 }
2607
TEST_P(AudioPolicyManagerTestDeviceConnection,PassingExtraAudioDescriptors)2608 TEST_P(AudioPolicyManagerTestDeviceConnection, PassingExtraAudioDescriptors) {
2609 const audio_devices_t type = std::get<0>(GetParam());
2610 if (!audio_device_is_digital(type)) {
2611 // EADs are used only for HDMI devices.
2612 GTEST_SKIP() << "Not a digital device type: " << audio_device_to_string(type);
2613 }
2614 const std::string name = std::get<1>(GetParam());
2615 const std::string address = std::get<2>(GetParam());
2616 android::media::AudioPortFw audioPort;
2617 ASSERT_EQ(NO_ERROR,
2618 mManager->deviceToAudioPort(type, address.c_str(), name.c_str(), &audioPort));
2619 android::media::audio::common::AudioPort& port = audioPort.hal;
2620 port.extraAudioDescriptors.push_back(make_ExtraAudioDescriptor(
2621 android::media::audio::common::AudioStandard::EDID,
2622 android::media::audio::common::AudioEncapsulationType::IEC61937));
2623 const size_t lastConnectedDevicePortCount = mClient->getConnectedDevicePortCount();
2624 const size_t lastDisconnectedDevicePortCount = mClient->getDisconnectedDevicePortCount();
2625 EXPECT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
2626 AUDIO_POLICY_DEVICE_STATE_AVAILABLE, port, AUDIO_FORMAT_DEFAULT));
2627 EXPECT_EQ(lastConnectedDevicePortCount + 1, mClient->getConnectedDevicePortCount());
2628 EXPECT_EQ(lastDisconnectedDevicePortCount, mClient->getDisconnectedDevicePortCount());
2629 const audio_port_v7* devicePort = mClient->getLastConnectedDevicePort();
2630 EXPECT_EQ(port.extraAudioDescriptors.size(), devicePort->num_extra_audio_descriptors);
2631 EXPECT_EQ(AUDIO_STANDARD_EDID, devicePort->extra_audio_descriptors[0].standard);
2632 EXPECT_EQ(AUDIO_ENCAPSULATION_TYPE_IEC61937,
2633 devicePort->extra_audio_descriptors[0].encapsulation_type);
2634 EXPECT_NE(0, devicePort->extra_audio_descriptors[0].descriptor[0]);
2635 }
2636
2637 INSTANTIATE_TEST_CASE_P(
2638 DeviceConnectionState,
2639 AudioPolicyManagerTestDeviceConnection,
2640 testing::Values(
2641 DeviceConnectionTestParams({AUDIO_DEVICE_IN_HDMI, "test_in_hdmi",
2642 "audio_policy_test_in_hdmi"}),
2643 DeviceConnectionTestParams({AUDIO_DEVICE_OUT_HDMI, "test_out_hdmi",
2644 "audio_policy_test_out_hdmi"}),
2645 DeviceConnectionTestParams({AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, "bt_hfp_in",
2646 "00:11:22:33:44:55"}),
2647 DeviceConnectionTestParams({AUDIO_DEVICE_OUT_BLUETOOTH_SCO, "bt_hfp_out",
2648 "00:11:22:33:44:55"})
2649 )
2650 );
2651
2652 namespace {
2653
2654 class AudioPolicyManagerTestClientOpenFails : public AudioPolicyManagerTestClient {
2655 public:
openOutput(audio_module_handle_t module,audio_io_handle_t * output,audio_config_t * halConfig,audio_config_base_t * mixerConfig,const sp<DeviceDescriptorBase> & device,uint32_t * latencyMs,audio_output_flags_t * flags,audio_attributes_t attributes)2656 status_t openOutput(audio_module_handle_t module,
2657 audio_io_handle_t *output,
2658 audio_config_t * halConfig,
2659 audio_config_base_t * mixerConfig,
2660 const sp<DeviceDescriptorBase>& device,
2661 uint32_t * latencyMs,
2662 audio_output_flags_t *flags,
2663 audio_attributes_t attributes) override {
2664 return mSimulateFailure ? BAD_VALUE :
2665 AudioPolicyManagerTestClient::openOutput(
2666 module, output, halConfig, mixerConfig, device, latencyMs, flags,
2667 attributes);
2668 }
2669
openInput(audio_module_handle_t module,audio_io_handle_t * input,audio_config_t * config,audio_devices_t * device,const String8 & address,audio_source_t source,audio_input_flags_t flags)2670 status_t openInput(audio_module_handle_t module,
2671 audio_io_handle_t *input,
2672 audio_config_t * config,
2673 audio_devices_t * device,
2674 const String8 & address,
2675 audio_source_t source,
2676 audio_input_flags_t flags) override {
2677 return mSimulateFailure ? BAD_VALUE :
2678 AudioPolicyManagerTestClient::openInput(
2679 module, input, config, device, address, source, flags);
2680 }
2681
setSimulateFailure(bool simulateFailure)2682 void setSimulateFailure(bool simulateFailure) { mSimulateFailure = simulateFailure; }
2683
setSimulateBroadcastDeviceStatus(audio_devices_t device,status_t status)2684 void setSimulateBroadcastDeviceStatus(audio_devices_t device, status_t status) {
2685 if (status != NO_ERROR) {
2686 // simulate device connect status
2687 mSimulateBroadcastDeviceStatus[device] = status;
2688 } else {
2689 // remove device connection fixed status
2690 mSimulateBroadcastDeviceStatus.erase(device);
2691 }
2692 }
2693
setDeviceConnectedState(const struct audio_port_v7 * port,media::DeviceConnectedState state)2694 status_t setDeviceConnectedState(const struct audio_port_v7* port,
2695 media::DeviceConnectedState state) override {
2696 if (mSimulateBroadcastDeviceStatus.find(port->ext.device.type) !=
2697 mSimulateBroadcastDeviceStatus.end()) {
2698 // If a simulated status exists, return a status value
2699 return mSimulateBroadcastDeviceStatus[port->ext.device.type];
2700 }
2701 return AudioPolicyManagerTestClient::setDeviceConnectedState(port, state);
2702 }
2703
2704 private:
2705 bool mSimulateFailure = false;
2706 std::map<audio_devices_t, status_t> mSimulateBroadcastDeviceStatus;
2707 };
2708
2709 } // namespace
2710
2711 using DeviceConnectionWithFormatTestParams =
2712 std::tuple<audio_devices_t /*type*/, std::string /*name*/, std::string /*address*/,
2713 audio_format_t /*format*/>;
2714
2715 class AudioPolicyManagerTestDeviceConnectionFailed :
2716 public AudioPolicyManagerTestWithConfigurationFile,
2717 public testing::WithParamInterface<DeviceConnectionWithFormatTestParams> {
2718 protected:
getConfigFile()2719 std::string getConfigFile() override { return sBluetoothConfig; }
getClient()2720 AudioPolicyManagerTestClient* getClient() override {
2721 mFullClient = new AudioPolicyManagerTestClientOpenFails;
2722 return mFullClient;
2723 }
setSimulateOpenFailure(bool simulateFailure)2724 void setSimulateOpenFailure(bool simulateFailure) {
2725 mFullClient->setSimulateFailure(simulateFailure); }
2726
setSimulateBroadcastDeviceStatus(audio_devices_t device,status_t status)2727 void setSimulateBroadcastDeviceStatus(audio_devices_t device, status_t status) {
2728 mFullClient->setSimulateBroadcastDeviceStatus(device, status); }
2729
2730 static const std::string sBluetoothConfig;
2731
2732 private:
2733 AudioPolicyManagerTestClientOpenFails* mFullClient;
2734 };
2735
2736 const std::string AudioPolicyManagerTestDeviceConnectionFailed::sBluetoothConfig =
2737 AudioPolicyManagerTestDeviceConnectionFailed::sExecutableDir +
2738 "test_audio_policy_configuration_bluetooth.xml";
2739
TEST_P(AudioPolicyManagerTestDeviceConnectionFailed,SetDeviceConnectedStateHasAddress)2740 TEST_P(AudioPolicyManagerTestDeviceConnectionFailed, SetDeviceConnectedStateHasAddress) {
2741 const audio_devices_t type = std::get<0>(GetParam());
2742 const std::string name = std::get<1>(GetParam());
2743 const std::string address = std::get<2>(GetParam());
2744 const audio_format_t format = std::get<3>(GetParam());
2745
2746 EXPECT_EQ(0, mClient->getConnectedDevicePortCount());
2747 EXPECT_EQ(0, mClient->getDisconnectedDevicePortCount());
2748
2749 setSimulateOpenFailure(true);
2750 ASSERT_EQ(INVALID_OPERATION, mManager->setDeviceConnectionState(
2751 type, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2752 address.c_str(), name.c_str(), format));
2753
2754 // Since the failure happens when opening input/output, the device must be connected
2755 // first and then disconnected.
2756 EXPECT_EQ(1, mClient->getConnectedDevicePortCount());
2757 EXPECT_EQ(1, mClient->getDisconnectedDevicePortCount());
2758
2759 if (mClient->getConnectedDevicePortCount() > 0) {
2760 auto port = mClient->getLastConnectedDevicePort();
2761 EXPECT_EQ(type, port->ext.device.type);
2762 EXPECT_EQ(0, strncmp(port->ext.device.address, address.c_str(),
2763 AUDIO_DEVICE_MAX_ADDRESS_LEN)) << "\"" << port->ext.device.address << "\"";
2764 }
2765 if (mClient->getDisconnectedDevicePortCount() > 0) {
2766 auto port = mClient->getLastDisconnectedDevicePort();
2767 EXPECT_EQ(type, port->ext.device.type);
2768 EXPECT_EQ(0, strncmp(port->ext.device.address, address.c_str(),
2769 AUDIO_DEVICE_MAX_ADDRESS_LEN)) << "\"" << port->ext.device.address << "\"";
2770 }
2771 }
2772
TEST_P(AudioPolicyManagerTestDeviceConnectionFailed,BroadcastDeviceFailure)2773 TEST_P(AudioPolicyManagerTestDeviceConnectionFailed, BroadcastDeviceFailure) {
2774 const audio_devices_t type = std::get<0>(GetParam());
2775 const std::string name = std::get<1>(GetParam());
2776 const std::string address = std::get<2>(GetParam());
2777 const audio_format_t format = std::get<3>(GetParam());
2778
2779 // simulate broadcastDeviceConnectionState return failure
2780 setSimulateBroadcastDeviceStatus(type, INVALID_OPERATION);
2781 ASSERT_EQ(INVALID_OPERATION, mManager->setDeviceConnectionState(
2782 type, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
2783 address.c_str(), name.c_str(), format));
2784
2785 // if broadcast is fail, device should not be added to available devices list
2786 if (audio_is_output_device(type)) {
2787 auto availableDevices = mManager->getAvailableOutputDevices();
2788 EXPECT_FALSE(availableDevices.containsDeviceWithType(type));
2789 } else if (audio_is_input_device(type)) {
2790 auto availableDevices = mManager->getAvailableInputDevices();
2791 EXPECT_FALSE(availableDevices.containsDeviceWithType(type));
2792 }
2793
2794 setSimulateBroadcastDeviceStatus(type, NO_ERROR);
2795 }
2796
2797 INSTANTIATE_TEST_CASE_P(
2798 DeviceConnectionFailure,
2799 AudioPolicyManagerTestDeviceConnectionFailed,
2800 testing::Values(
2801 DeviceConnectionWithFormatTestParams({AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET,
2802 "bt_hfp_in", "00:11:22:33:44:55", AUDIO_FORMAT_DEFAULT}),
2803 DeviceConnectionWithFormatTestParams({AUDIO_DEVICE_OUT_BLUETOOTH_SCO,
2804 "bt_hfp_out", "00:11:22:33:44:55", AUDIO_FORMAT_DEFAULT}),
2805 DeviceConnectionWithFormatTestParams({AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
2806 "bt_a2dp_out", "00:11:22:33:44:55", AUDIO_FORMAT_DEFAULT}),
2807 DeviceConnectionWithFormatTestParams({AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,
2808 "bt_a2dp_out", "00:11:22:33:44:66", AUDIO_FORMAT_LDAC})
2809 )
2810 );
2811
2812 class AudioPolicyManagerCarTest : public AudioPolicyManagerTestDynamicPolicy {
2813 protected:
getConfigFile()2814 std::string getConfigFile() override { return sCarConfig; }
2815
2816 static const std::string sCarConfig;
2817 static const std::string sCarBusMediaOutput;
2818 static const std::string sCarBusNavigationOutput;
2819 static const std::string sCarRearZoneOneOutput;
2820 static const std::string sCarRearZoneTwoOutput;
2821 static const std::string sCarBusMmapOutput;
2822 };
2823
2824 const std::string AudioPolicyManagerCarTest::sCarConfig =
2825 AudioPolicyManagerCarTest::sExecutableDir + "test_car_ap_atmos_offload_configuration.xml";
2826
2827 const std::string AudioPolicyManagerCarTest::sCarBusMediaOutput = "bus0_media_out";
2828
2829 const std::string AudioPolicyManagerCarTest::sCarBusNavigationOutput = "bus1_navigation_out";
2830
2831 const std::string AudioPolicyManagerCarTest::sCarRearZoneOneOutput = "bus100_audio_zone_1";
2832
2833 const std::string AudioPolicyManagerCarTest::sCarRearZoneTwoOutput = "bus200_audio_zone_2";
2834
2835 const std::string AudioPolicyManagerCarTest::sCarBusMmapOutput = "bus8_mmap_out";
2836
TEST_F(AudioPolicyManagerCarTest,InitSuccess)2837 TEST_F(AudioPolicyManagerCarTest, InitSuccess) {
2838 // SetUp must finish with no assertions.
2839 }
2840
TEST_F(AudioPolicyManagerCarTest,Dump)2841 TEST_F(AudioPolicyManagerCarTest, Dump) {
2842 dumpToLog();
2843 }
2844
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrAtmosOutputAfterRegisteringPolicyMix)2845 TEST_F(AudioPolicyManagerCarTest, GetOutputForAttrAtmosOutputAfterRegisteringPolicyMix) {
2846 status_t ret;
2847 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
2848 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2849 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig);
2850 ASSERT_EQ(NO_ERROR, ret);
2851
2852 DeviceIdVector selectedDeviceIds;
2853 audio_io_handle_t output;
2854 audio_port_handle_t portId;
2855 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_E_AC3_JOC, AUDIO_CHANNEL_OUT_5POINT1,
2856 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId);
2857 ASSERT_GT(selectedDeviceIds.size(), 0);
2858 sp<SwAudioOutputDescriptor> outDesc = mManager->getOutputs().valueFor(output);
2859 ASSERT_NE(nullptr, outDesc.get());
2860 ASSERT_EQ(AUDIO_FORMAT_E_AC3_JOC, outDesc->getFormat());
2861 ASSERT_EQ(AUDIO_CHANNEL_OUT_5POINT1, outDesc->getChannelMask());
2862 ASSERT_EQ(k48000SamplingRate, outDesc->getSamplingRate());
2863
2864 selectedDeviceIds.clear();
2865 output = AUDIO_IO_HANDLE_NONE;
2866 portId = AUDIO_PORT_HANDLE_NONE;
2867 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_7POINT1POINT4,
2868 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId);
2869 ASSERT_GT(selectedDeviceIds.size(), 0);
2870 outDesc = mManager->getOutputs().valueFor(output);
2871 ASSERT_NE(nullptr, outDesc.get());
2872 ASSERT_EQ(AUDIO_FORMAT_PCM_16_BIT, outDesc->getFormat());
2873 ASSERT_EQ(AUDIO_CHANNEL_OUT_7POINT1POINT4, outDesc->getChannelMask());
2874 ASSERT_EQ(k48000SamplingRate, outDesc->getSamplingRate());
2875 }
2876
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrAfterRegisteringPolicyMix)2877 TEST_F(AudioPolicyManagerCarTest, GetOutputForAttrAfterRegisteringPolicyMix) {
2878 status_t ret;
2879 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
2880 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2881 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
2882 audioConfig.sample_rate = k48000SamplingRate;
2883 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
2884 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
2885 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2886 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
2887 ASSERT_EQ(NO_ERROR, ret);
2888 std::vector<AudioMixMatchCriterion> navMatchCriteria = {
2889 createUsageCriterion(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
2890 /*exclude=*/ false)};
2891 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2892 AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput, audioConfig, navMatchCriteria);
2893 ASSERT_EQ(NO_ERROR, ret);
2894 audio_port_v7 mediaDevicePort;
2895 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
2896 sCarBusMediaOutput, &mediaDevicePort));
2897 DeviceIdVector selectedDeviceIds;
2898 audio_io_handle_t output;
2899 audio_port_handle_t portId;
2900 const audio_attributes_t mediaAttribute = {
2901 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_MEDIA,
2902 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
2903
2904 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
2905 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, mediaAttribute);
2906
2907 ASSERT_EQ(mediaDevicePort.id, selectedDeviceIds[0]);
2908 }
2909
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithSelectedOutputAfterRegisteringPolicyMix)2910 TEST_F(AudioPolicyManagerCarTest, GetOutputForAttrWithSelectedOutputAfterRegisteringPolicyMix) {
2911 status_t ret;
2912 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
2913 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2914 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
2915 audioConfig.sample_rate = k48000SamplingRate;
2916 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
2917 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
2918 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2919 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
2920 ASSERT_EQ(NO_ERROR, ret);
2921 std::vector<AudioMixMatchCriterion> navMatchCriteria = {
2922 createUsageCriterion(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
2923 /*exclude=*/ false)};
2924 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2925 AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput, audioConfig, navMatchCriteria);
2926 ASSERT_EQ(NO_ERROR, ret);
2927 audio_port_v7 navDevicePort;
2928 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
2929 sCarBusNavigationOutput, &navDevicePort));
2930 DeviceIdVector selectedDeviceIds = { navDevicePort.id };
2931 audio_io_handle_t output;
2932 audio_port_handle_t portId;
2933 const audio_attributes_t mediaAttribute = {
2934 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_MEDIA,
2935 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
2936
2937 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
2938 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, mediaAttribute);
2939
2940 ASSERT_EQ(navDevicePort.id, selectedDeviceIds[0]);
2941 }
2942
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithSelectedOutputAfterUserAffinities)2943 TEST_F(AudioPolicyManagerCarTest, GetOutputForAttrWithSelectedOutputAfterUserAffinities) {
2944 status_t ret;
2945 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
2946 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2947 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
2948 audioConfig.sample_rate = k48000SamplingRate;
2949 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
2950 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
2951 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2952 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
2953 ASSERT_EQ(NO_ERROR, ret);
2954 std::vector<AudioMixMatchCriterion> navMatchCriteria = {
2955 createUsageCriterion(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
2956 /*exclude=*/ false)};
2957 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2958 AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput, audioConfig, navMatchCriteria);
2959 ASSERT_EQ(NO_ERROR, ret);
2960 const AudioDeviceTypeAddr mediaOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput);
2961 const AudioDeviceTypeAddrVector outputDevices = {mediaOutputDevice};
2962 mManager->setUserIdDeviceAffinities(/* userId */ 0, outputDevices);
2963 audio_port_v7 navDevicePort;
2964 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
2965 sCarBusNavigationOutput, &navDevicePort));
2966 DeviceIdVector selectedDeviceIds = { navDevicePort.id };
2967 audio_io_handle_t output;
2968 audio_port_handle_t portId;
2969 const audio_attributes_t mediaAttribute = {
2970 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_MEDIA,
2971 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
2972
2973 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
2974 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, mediaAttribute);
2975
2976 ASSERT_GT(selectedDeviceIds.size(), 0);
2977 ASSERT_NE(navDevicePort.id, selectedDeviceIds[0]);
2978 }
2979
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithExcludeUserIdCriteria)2980 TEST_F(AudioPolicyManagerCarTest, GetOutputForAttrWithExcludeUserIdCriteria) {
2981 status_t ret;
2982 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
2983 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
2984 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
2985 audioConfig.sample_rate = k48000SamplingRate;
2986 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
2987 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
2988 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2989 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
2990 ASSERT_EQ(NO_ERROR, ret);
2991 std::vector<AudioMixMatchCriterion> navMatchCriteria = {
2992 createUsageCriterion(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
2993 /*exclude=*/ false),
2994 createUserIdCriterion(/* userId */ 0, /* exclude */ true)};
2995 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
2996 AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput, audioConfig, navMatchCriteria);
2997 ASSERT_EQ(NO_ERROR, ret);
2998 audio_port_v7 navDevicePort;
2999 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
3000 sCarBusNavigationOutput, &navDevicePort));
3001 audio_io_handle_t output;
3002 audio_port_handle_t portId;
3003 const audio_attributes_t navigationAttribute = {
3004 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
3005 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
3006 DeviceIdVector selectedDeviceIds;
3007
3008 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3009 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, navigationAttribute);
3010
3011 ASSERT_GT(selectedDeviceIds.size(), 0);
3012 ASSERT_NE(navDevicePort.id, selectedDeviceIds[0]);
3013 }
3014
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithSelectedOutputExcludeUserIdCriteria)3015 TEST_F(AudioPolicyManagerCarTest, GetOutputForAttrWithSelectedOutputExcludeUserIdCriteria) {
3016 status_t ret;
3017 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
3018 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3019 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
3020 audioConfig.sample_rate = k48000SamplingRate;
3021 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
3022 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
3023 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3024 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
3025 ASSERT_EQ(NO_ERROR, ret);
3026 std::vector<AudioMixMatchCriterion> navMatchCriteria = {
3027 createUsageCriterion(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
3028 /*exclude=*/ false),
3029 createUserIdCriterion(0 /* userId */, /* exclude */ true)};
3030 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3031 AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput, audioConfig, navMatchCriteria);
3032 ASSERT_EQ(NO_ERROR, ret);
3033 audio_port_v7 navDevicePort;
3034 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
3035 sCarBusNavigationOutput, &navDevicePort));
3036 DeviceIdVector selectedDeviceIds = { navDevicePort.id };
3037 audio_io_handle_t output;
3038 audio_port_handle_t portId;
3039 const audio_attributes_t mediaAttribute = {
3040 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_MEDIA,
3041 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
3042
3043 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3044 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, mediaAttribute);
3045
3046 ASSERT_EQ(navDevicePort.id, selectedDeviceIds[0]);
3047 }
3048
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithMatchingMixAndSelectedOutputAfterUserAffinities)3049 TEST_F(AudioPolicyManagerCarTest,
3050 GetOutputForAttrWithMatchingMixAndSelectedOutputAfterUserAffinities) {
3051 status_t ret;
3052 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
3053 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3054 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
3055 audioConfig.sample_rate = k48000SamplingRate;
3056 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
3057 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
3058 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3059 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
3060 ASSERT_EQ(NO_ERROR, ret);
3061 std::vector<AudioMixMatchCriterion> navMatchCriteria = {
3062 createUsageCriterion(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
3063 /*exclude=*/ false)};
3064 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3065 AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput, audioConfig, navMatchCriteria);
3066 ASSERT_EQ(NO_ERROR, ret);
3067 const AudioDeviceTypeAddr mediaOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput);
3068 const AudioDeviceTypeAddr navOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput);
3069 const AudioDeviceTypeAddrVector outputDevices = {mediaOutputDevice, navOutputDevice};
3070 mManager->setUserIdDeviceAffinities(/* userId */ 0, outputDevices);
3071 audio_port_v7 navDevicePort;
3072 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
3073 sCarBusNavigationOutput, &navDevicePort));
3074 DeviceIdVector selectedDeviceIds = { navDevicePort.id };
3075 audio_io_handle_t output;
3076 audio_port_handle_t portId;
3077 const audio_attributes_t mediaAttribute = {
3078 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_MEDIA,
3079 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
3080
3081 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3082 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, mediaAttribute);
3083
3084 ASSERT_EQ(navDevicePort.id, selectedDeviceIds[0]);
3085 }
3086
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithNoMatchingMaxAndSelectedOutputAfterUserAffinities)3087 TEST_F(AudioPolicyManagerCarTest,
3088 GetOutputForAttrWithNoMatchingMaxAndSelectedOutputAfterUserAffinities) {
3089 status_t ret;
3090 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
3091 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3092 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
3093 audioConfig.sample_rate = k48000SamplingRate;
3094 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
3095 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
3096 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3097 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
3098 ASSERT_EQ(NO_ERROR, ret);
3099 std::vector<AudioMixMatchCriterion> navMatchCriteria = {
3100 createUsageCriterion(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
3101 /*exclude=*/ false)};
3102 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3103 AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput, audioConfig, navMatchCriteria);
3104 ASSERT_EQ(NO_ERROR, ret);
3105 const AudioDeviceTypeAddr mediaOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput);
3106 const AudioDeviceTypeAddr navOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput);
3107 const AudioDeviceTypeAddrVector outputDevices = {mediaOutputDevice, navOutputDevice};
3108 mManager->setUserIdDeviceAffinities(/* userId */ 0, outputDevices);
3109 audio_port_v7 navDevicePort;
3110 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
3111 sCarBusNavigationOutput, &navDevicePort));
3112 DeviceIdVector selectedDeviceIds = { navDevicePort.id };
3113 audio_io_handle_t output;
3114 audio_port_handle_t portId;
3115 const audio_attributes_t alarmAttribute = {
3116 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_ALARM,
3117 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
3118
3119 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3120 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, alarmAttribute);
3121
3122 ASSERT_EQ(navDevicePort.id, selectedDeviceIds[0]);
3123 }
3124
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithMatMixAfterUserAffinitiesForOneUser)3125 TEST_F(AudioPolicyManagerCarTest,
3126 GetOutputForAttrWithMatMixAfterUserAffinitiesForOneUser) {
3127 status_t ret;
3128 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
3129 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3130 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
3131 audioConfig.sample_rate = k48000SamplingRate;
3132 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
3133 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
3134 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3135 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
3136 ASSERT_EQ(NO_ERROR, ret);
3137 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3138 AUDIO_DEVICE_OUT_BUS, sCarRearZoneOneOutput, audioConfig, mediaMatchCriteria);
3139 ASSERT_EQ(NO_ERROR, ret);
3140 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3141 AUDIO_DEVICE_OUT_BUS, sCarRearZoneTwoOutput, audioConfig, mediaMatchCriteria);
3142 ASSERT_EQ(NO_ERROR, ret);
3143 const AudioDeviceTypeAddr mediaOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput);
3144 const AudioDeviceTypeAddrVector primaryZoneDevices = {mediaOutputDevice};
3145 mManager->setUserIdDeviceAffinities(/* userId */ 0, primaryZoneDevices);
3146 audio_port_v7 primaryZoneDevicePort;
3147 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
3148 sCarBusMediaOutput, &primaryZoneDevicePort));
3149 DeviceIdVector selectedDeviceIds;
3150 audio_io_handle_t output;
3151 audio_port_handle_t portId;
3152 const audio_attributes_t mediaAttribute = {
3153 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_MEDIA,
3154 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
3155 uid_t user11AppUid = multiuser_get_uid(/* user_id */ 11, /* app_id */ 12345);
3156
3157 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3158 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, mediaAttribute,
3159 AUDIO_SESSION_NONE, user11AppUid);
3160
3161 ASSERT_EQ(primaryZoneDevicePort.id, selectedDeviceIds[0]);
3162 }
3163
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithMatMixAfterUserAffinitiesForTwoUsers)3164 TEST_F(AudioPolicyManagerCarTest,
3165 GetOutputForAttrWithMatMixAfterUserAffinitiesForTwoUsers) {
3166 status_t ret;
3167 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
3168 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3169 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
3170 audioConfig.sample_rate = k48000SamplingRate;
3171 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
3172 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
3173 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3174 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
3175 ASSERT_EQ(NO_ERROR, ret);
3176 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3177 AUDIO_DEVICE_OUT_BUS, sCarRearZoneOneOutput, audioConfig, mediaMatchCriteria);
3178 ASSERT_EQ(NO_ERROR, ret);
3179 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3180 AUDIO_DEVICE_OUT_BUS, sCarRearZoneTwoOutput, audioConfig, mediaMatchCriteria);
3181 ASSERT_EQ(NO_ERROR, ret);
3182 const AudioDeviceTypeAddr mediaOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput);
3183 const AudioDeviceTypeAddrVector primaryZoneDevices = {mediaOutputDevice};
3184 mManager->setUserIdDeviceAffinities(/* userId */ 0, primaryZoneDevices);
3185 const AudioDeviceTypeAddr secondaryOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarRearZoneOneOutput);
3186 const AudioDeviceTypeAddrVector secondaryZoneDevices = {secondaryOutputDevice};
3187 mManager->setUserIdDeviceAffinities(/* userId */ 11, secondaryZoneDevices);
3188 audio_port_v7 secondaryZoneDevicePort;
3189 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
3190 sCarRearZoneOneOutput, &secondaryZoneDevicePort));
3191 DeviceIdVector selectedDeviceIds;
3192 audio_io_handle_t output;
3193 audio_port_handle_t portId;
3194 const audio_attributes_t mediaAttribute = {
3195 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_MEDIA,
3196 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
3197 uid_t user11AppUid = multiuser_get_uid(/* user_id */ 11, /* app_id */ 12345);
3198
3199 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3200 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, mediaAttribute,
3201 AUDIO_SESSION_NONE, user11AppUid);
3202
3203 ASSERT_EQ(secondaryZoneDevicePort.id, selectedDeviceIds[0]);
3204 }
3205
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithMatMixAfterUserAffinitiesForThreeUsers)3206 TEST_F(AudioPolicyManagerCarTest,
3207 GetOutputForAttrWithMatMixAfterUserAffinitiesForThreeUsers) {
3208 status_t ret;
3209 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
3210 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3211 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
3212 audioConfig.sample_rate = k48000SamplingRate;
3213 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
3214 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
3215 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3216 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
3217 ASSERT_EQ(NO_ERROR, ret);
3218 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3219 AUDIO_DEVICE_OUT_BUS, sCarRearZoneOneOutput, audioConfig, mediaMatchCriteria);
3220 ASSERT_EQ(NO_ERROR, ret);
3221 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3222 AUDIO_DEVICE_OUT_BUS, sCarRearZoneTwoOutput, audioConfig, mediaMatchCriteria);
3223 ASSERT_EQ(NO_ERROR, ret);
3224 const AudioDeviceTypeAddr mediaOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput);
3225 const AudioDeviceTypeAddrVector primaryZoneDevices = {mediaOutputDevice};
3226 mManager->setUserIdDeviceAffinities(/* userId */ 0, primaryZoneDevices);
3227 const AudioDeviceTypeAddr secondaryOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarRearZoneOneOutput);
3228 const AudioDeviceTypeAddrVector secondaryZoneDevices = {secondaryOutputDevice};
3229 mManager->setUserIdDeviceAffinities(/* userId */ 11, secondaryZoneDevices);
3230 const AudioDeviceTypeAddr tertiaryOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarRearZoneTwoOutput);
3231 const AudioDeviceTypeAddrVector tertiaryZoneDevices = {tertiaryOutputDevice};
3232 mManager->setUserIdDeviceAffinities(/* userId */ 15, tertiaryZoneDevices);
3233 audio_port_v7 tertiaryZoneDevicePort;
3234 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
3235 sCarRearZoneTwoOutput, &tertiaryZoneDevicePort));
3236 DeviceIdVector selectedDeviceIds;
3237 audio_io_handle_t output;
3238 audio_port_handle_t portId;
3239 const audio_attributes_t mediaAttribute = {
3240 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_MEDIA,
3241 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
3242 uid_t user15AppUid = multiuser_get_uid(/* user_id */ 15, /* app_id */ 12345);
3243
3244 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3245 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, mediaAttribute,
3246 AUDIO_SESSION_NONE, user15AppUid);
3247
3248 ASSERT_EQ(tertiaryZoneDevicePort.id, selectedDeviceIds[0]);
3249 }
3250
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrWithNoMatchingMix)3251 TEST_F(AudioPolicyManagerCarTest, GetOutputForAttrWithNoMatchingMix) {
3252 status_t ret;
3253 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
3254 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3255 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
3256 audioConfig.sample_rate = k48000SamplingRate;
3257 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
3258 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
3259 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3260 AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput, audioConfig, mediaMatchCriteria);
3261 ASSERT_EQ(NO_ERROR, ret);
3262 std::vector<AudioMixMatchCriterion> navMatchCriteria = {
3263 createUsageCriterion(AUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
3264 /*exclude=*/ false)};
3265 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3266 AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput, audioConfig, navMatchCriteria);
3267 ASSERT_EQ(NO_ERROR, ret);
3268 const AudioDeviceTypeAddr mediaOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusMediaOutput);
3269 const AudioDeviceTypeAddr navOutputDevice(AUDIO_DEVICE_OUT_BUS, sCarBusNavigationOutput);
3270 const AudioDeviceTypeAddrVector outputDevices = {mediaOutputDevice, navOutputDevice};
3271 mManager->setUserIdDeviceAffinities(/* userId */ 0, outputDevices);
3272 audio_port_v7 navDevicePort;
3273 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
3274 sCarBusNavigationOutput, &navDevicePort));
3275 DeviceIdVector selectedDeviceIds = { navDevicePort.id };
3276 audio_io_handle_t output;
3277 audio_port_handle_t portId;
3278 const audio_attributes_t alarmAttribute = {
3279 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_ALARM,
3280 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
3281
3282 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3283 k48000SamplingRate, AUDIO_OUTPUT_FLAG_DIRECT, &output, &portId, alarmAttribute);
3284
3285 ASSERT_EQ(navDevicePort.id, selectedDeviceIds[0]);
3286 }
3287
TEST_F(AudioPolicyManagerCarTest,GetOutputForAttrForMMapWithPolicyMatched)3288 TEST_F(AudioPolicyManagerCarTest, GetOutputForAttrForMMapWithPolicyMatched) {
3289 status_t ret;
3290 audio_config_t audioConfig = AUDIO_CONFIG_INITIALIZER;
3291 audioConfig.channel_mask = AUDIO_CHANNEL_OUT_STEREO;
3292 audioConfig.format = AUDIO_FORMAT_PCM_16_BIT;
3293 audioConfig.sample_rate = k48000SamplingRate;
3294 std::vector<AudioMixMatchCriterion> mediaMatchCriteria = {
3295 createUsageCriterion(AUDIO_USAGE_MEDIA, /*exclude=*/ false)};
3296 ret = addPolicyMix(MIX_TYPE_PLAYERS, MIX_ROUTE_FLAG_RENDER,
3297 AUDIO_DEVICE_OUT_BUS, sCarBusMmapOutput, audioConfig, mediaMatchCriteria);
3298 ASSERT_EQ(NO_ERROR, ret);
3299 ASSERT_EQ(NO_ERROR, ret);
3300 audio_port_v7 mmapDevicePort;
3301 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SINK, AUDIO_DEVICE_OUT_BUS,
3302 sCarBusMmapOutput, &mmapDevicePort));
3303 DeviceIdVector selectedDeviceIds;
3304 audio_io_handle_t output;
3305 audio_port_handle_t portId;
3306 const audio_attributes_t mediaAttribute = {
3307 AUDIO_CONTENT_TYPE_UNKNOWN, AUDIO_USAGE_MEDIA,
3308 AUDIO_SOURCE_DEFAULT, AUDIO_FLAG_NONE, ""};
3309
3310 getOutputForAttr(
3311 &selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3312 k48000SamplingRate,
3313 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_MMAP_NOIRQ | AUDIO_OUTPUT_FLAG_DIRECT),
3314 &output, &portId, mediaAttribute);
3315
3316 ASSERT_EQ(mmapDevicePort.id, selectedDeviceIds[0]);
3317
3318 }
3319
3320 class AudioPolicyManagerTVTest : public AudioPolicyManagerTestWithConfigurationFile {
3321 protected:
getConfigFile()3322 std::string getConfigFile() override { return sTvConfig; }
3323 void testHDMIPortSelection(audio_output_flags_t flags, const char* expectedMixPortName);
3324
3325 static const std::string sTvConfig;
3326 };
3327
3328 const std::string AudioPolicyManagerTVTest::sTvConfig =
3329 AudioPolicyManagerTVTest::sExecutableDir + "test_tv_apm_configuration.xml";
3330
3331 // SwAudioOutputDescriptor doesn't populate flags so check against the port name.
testHDMIPortSelection(audio_output_flags_t flags,const char * expectedMixPortName)3332 void AudioPolicyManagerTVTest::testHDMIPortSelection(
3333 audio_output_flags_t flags, const char* expectedMixPortName) {
3334 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
3335 AUDIO_DEVICE_OUT_AUX_DIGITAL, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
3336 "" /*address*/, "" /*name*/, AUDIO_FORMAT_DEFAULT));
3337 DeviceIdVector selectedDeviceIds;
3338 audio_io_handle_t output;
3339 audio_port_handle_t portId;
3340 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
3341 k48000SamplingRate, flags, &output, &portId);
3342 sp<SwAudioOutputDescriptor> outDesc = mManager->getOutputs().valueFor(output);
3343 ASSERT_NE(nullptr, outDesc.get());
3344 audio_port_v7 port = {};
3345 outDesc->toAudioPort(&port);
3346 mManager->releaseOutput(portId);
3347 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
3348 AUDIO_DEVICE_OUT_AUX_DIGITAL, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
3349 "" /*address*/, "" /*name*/, AUDIO_FORMAT_DEFAULT));
3350 ASSERT_EQ(AUDIO_PORT_TYPE_MIX, port.type);
3351 ASSERT_EQ(AUDIO_PORT_ROLE_SOURCE, port.role);
3352 ASSERT_STREQ(expectedMixPortName, port.name);
3353 }
3354
TEST_F(AudioPolicyManagerTVTest,InitSuccess)3355 TEST_F(AudioPolicyManagerTVTest, InitSuccess) {
3356 // SetUp must finish with no assertions.
3357 }
3358
TEST_F(AudioPolicyManagerTVTest,Dump)3359 TEST_F(AudioPolicyManagerTVTest, Dump) {
3360 dumpToLog();
3361 }
3362
TEST_F(AudioPolicyManagerTVTest,MatchNoFlags)3363 TEST_F(AudioPolicyManagerTVTest, MatchNoFlags) {
3364 testHDMIPortSelection(AUDIO_OUTPUT_FLAG_NONE, "primary output");
3365 }
3366
TEST_F(AudioPolicyManagerTVTest,MatchOutputDirectNoHwAvSync)3367 TEST_F(AudioPolicyManagerTVTest, MatchOutputDirectNoHwAvSync) {
3368 // b/140447125: The selected port must not have HW AV Sync flag (see the config file).
3369 testHDMIPortSelection(AUDIO_OUTPUT_FLAG_DIRECT, "direct");
3370 }
3371
TEST_F(AudioPolicyManagerTVTest,MatchOutputDirectHwAvSync)3372 TEST_F(AudioPolicyManagerTVTest, MatchOutputDirectHwAvSync) {
3373 testHDMIPortSelection(static_cast<audio_output_flags_t>(
3374 AUDIO_OUTPUT_FLAG_DIRECT|AUDIO_OUTPUT_FLAG_HW_AV_SYNC),
3375 "tunnel");
3376 }
3377
TEST_F(AudioPolicyManagerTVTest,MatchOutputDirectMMapNoIrq)3378 TEST_F(AudioPolicyManagerTVTest, MatchOutputDirectMMapNoIrq) {
3379 testHDMIPortSelection(static_cast<audio_output_flags_t>(
3380 AUDIO_OUTPUT_FLAG_DIRECT|AUDIO_OUTPUT_FLAG_MMAP_NOIRQ),
3381 "low latency");
3382 }
3383
3384 class AudioPolicyManagerPhoneTest : public AudioPolicyManagerTestWithConfigurationFile {
3385 protected:
getConfigFile()3386 std::string getConfigFile() override { return sPhoneConfig; }
3387 void testOutputMixPortSelectionForAttr(audio_output_flags_t flags, audio_format_t format,
3388 int samplingRate, bool isMusic, const char* expectedMixPortName);
3389 void testOutputMixPortSelectionForStream(
3390 audio_stream_type_t stream, const char* expectedMixPortName);
3391 void verifyMixPortNameAndFlags(audio_io_handle_t output, const char* expectedMixPortName);
3392
3393 static const std::string sPhoneConfig;
3394 static const std::map<std::string, audio_output_flags_t> sMixPortFlags;
3395 };
3396
3397 const std::string AudioPolicyManagerPhoneTest::sPhoneConfig =
3398 AudioPolicyManagerPhoneTest::sExecutableDir + "test_phone_apm_configuration.xml";
3399
3400 // Must be in sync with the contents of the sPhoneConfig file.
3401 const std::map<std::string, audio_output_flags_t> AudioPolicyManagerPhoneTest::sMixPortFlags = {
3402 {"primary output",
3403 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_PRIMARY | AUDIO_OUTPUT_FLAG_FAST)},
3404 {"direct", AUDIO_OUTPUT_FLAG_DIRECT},
3405 {"deep buffer", AUDIO_OUTPUT_FLAG_DEEP_BUFFER},
3406 {"compressed_offload",
3407 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_DIRECT | AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD |
3408 AUDIO_OUTPUT_FLAG_NON_BLOCKING |
3409 AUDIO_OUTPUT_FLAG_GAPLESS_OFFLOAD)},
3410 {"raw", (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_RAW | AUDIO_OUTPUT_FLAG_FAST)},
3411 {"mmap_no_irq_out",
3412 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_DIRECT|AUDIO_OUTPUT_FLAG_MMAP_NOIRQ)},
3413 {"voip_rx", AUDIO_OUTPUT_FLAG_VOIP_RX},
3414 };
3415
testOutputMixPortSelectionForAttr(audio_output_flags_t flags,audio_format_t format,int samplingRate,bool isMusic,const char * expectedMixPortName)3416 void AudioPolicyManagerPhoneTest::testOutputMixPortSelectionForAttr(
3417 audio_output_flags_t flags, audio_format_t format, int samplingRate, bool isMusic,
3418 const char* expectedMixPortName) {
3419 DeviceIdVector selectedDeviceIds;
3420 audio_io_handle_t output;
3421 audio_port_handle_t portId;
3422 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
3423 if (isMusic) {
3424 attr.content_type = AUDIO_CONTENT_TYPE_MUSIC;
3425 attr.usage = AUDIO_USAGE_MEDIA;
3426 }
3427 getOutputForAttr(&selectedDeviceIds, format, AUDIO_CHANNEL_OUT_STEREO, samplingRate, flags,
3428 &output, &portId, attr);
3429 EXPECT_NO_FATAL_FAILURE(verifyMixPortNameAndFlags(output, expectedMixPortName));
3430 mManager->releaseOutput(portId);
3431 }
3432
testOutputMixPortSelectionForStream(audio_stream_type_t stream,const char * expectedMixPortName)3433 void AudioPolicyManagerPhoneTest::testOutputMixPortSelectionForStream(
3434 audio_stream_type_t stream, const char* expectedMixPortName) {
3435 audio_io_handle_t output = mManager->getOutput(stream);
3436 EXPECT_NO_FATAL_FAILURE(verifyMixPortNameAndFlags(output, expectedMixPortName));
3437 }
3438
verifyMixPortNameAndFlags(audio_io_handle_t output,const char * expectedMixPortName)3439 void AudioPolicyManagerPhoneTest::verifyMixPortNameAndFlags(audio_io_handle_t output,
3440 const char* expectedMixPortName) {
3441 ALOGI("%s: checking output %d", __func__, output);
3442 sp<SwAudioOutputDescriptor> outDesc = mManager->getOutputs().valueFor(output);
3443 ASSERT_NE(nullptr, outDesc.get());
3444 audio_port_v7 port = {};
3445 outDesc->toAudioPort(&port);
3446 EXPECT_EQ(AUDIO_PORT_TYPE_MIX, port.type);
3447 EXPECT_EQ(AUDIO_PORT_ROLE_SOURCE, port.role);
3448 ASSERT_STREQ(expectedMixPortName, port.name);
3449
3450 auto iter = sMixPortFlags.find(port.name);
3451 ASSERT_NE(iter, sMixPortFlags.end()) << "\"" << port.name << "\" is not in sMixPortFlags";
3452 auto actualFlags = mClient->getOpenOutputFlags(output);
3453 ASSERT_TRUE(actualFlags.has_value()) << "\"" << port.name << "\" was not opened via client";
3454 EXPECT_EQ(*actualFlags, iter->second);
3455 }
3456
TEST_F(AudioPolicyManagerPhoneTest,InitSuccess)3457 TEST_F(AudioPolicyManagerPhoneTest, InitSuccess) {
3458 // SetUp must finish with no assertions.
3459 }
3460
TEST_F(AudioPolicyManagerPhoneTest,Dump)3461 TEST_F(AudioPolicyManagerPhoneTest, Dump) {
3462 dumpToLog();
3463 }
3464
TEST_F(AudioPolicyManagerPhoneTest,NoPatchChangesDuringAlarmPlayback)3465 TEST_F(AudioPolicyManagerPhoneTest, NoPatchChangesDuringAlarmPlayback) {
3466 audio_port_handle_t alarmPortId = AUDIO_PORT_HANDLE_NONE;
3467 audio_io_handle_t alarmOutput = AUDIO_IO_HANDLE_NONE;
3468 {
3469 // Uses STRATEGY_SONIFICATION, routed to AUDIO_DEVICE_OUT_SPEAKER_SAFE.
3470 audio_attributes_t attr = {
3471 .content_type = AUDIO_CONTENT_TYPE_UNKNOWN,
3472 .usage = AUDIO_USAGE_ALARM,
3473 };
3474 DeviceIdVector selectedDeviceIds;
3475 ASSERT_NO_FATAL_FAILURE(getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT,
3476 AUDIO_CHANNEL_OUT_STEREO, 48000,
3477 AUDIO_OUTPUT_FLAG_NONE,
3478 &alarmOutput, &alarmPortId, attr));
3479 EXPECT_EQ(NO_ERROR, mManager->startOutput(alarmPortId));
3480 }
3481 const audio_patch lastPatchBefore = *(mClient->getLastAddedPatch());
3482
3483 {
3484 // Uses STRATEGY_MEDIA, routed to AUDIO_DEVICE_OUT_SPEAKER.
3485 audio_attributes_t attr = {
3486 .content_type = AUDIO_CONTENT_TYPE_UNKNOWN,
3487 .usage = AUDIO_USAGE_MEDIA,
3488 };
3489 DeviceIdVector selectedDeviceIds;
3490 audio_port_handle_t notifPortId = AUDIO_PORT_HANDLE_NONE;
3491 audio_io_handle_t notifOutput = AUDIO_IO_HANDLE_NONE;
3492 ASSERT_NO_FATAL_FAILURE(getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT,
3493 AUDIO_CHANNEL_OUT_STEREO, 48000,
3494 AUDIO_OUTPUT_FLAG_NONE,
3495 ¬ifOutput, ¬ifPortId, attr));
3496 EXPECT_EQ(NO_ERROR, mManager->startOutput(notifPortId));
3497 }
3498 dumpToLog();
3499 const audio_patch lastPatchAfter = *(mClient->getLastAddedPatch());
3500 EXPECT_TRUE(audio_patches_are_equal(&lastPatchBefore, &lastPatchAfter)) <<
3501 "Unexpected change in patches detected";
3502 }
3503
3504 enum {
3505 MIX_PORT_ATTR_EXPECTED_NAME_PARAMETER,
3506 MIX_PORT_ATTR_EXPECTED_NAME_WITH_DBFM_PARAMETER,
3507 MIX_PORT_ATTR_FLAGS_PARAMETER,
3508 MIX_PORT_ATTR_FORMAT_PARAMETER,
3509 MIX_PORT_ATTR_SAMPLING_RATE_PARAMETER,
3510 };
3511 using MixPortSelectionForAttr =
3512 std::tuple<const char*, const char*, audio_output_flags_t, audio_format_t, int>;
3513
3514 class AudioPolicyManagerOutputMixPortForAttrSelectionTest
3515 : public AudioPolicyManagerPhoneTest,
3516 public testing::WithParamInterface<MixPortSelectionForAttr> {
3517 };
3518
3519 // There is no easy way to create a flat tuple from tuples via ::testing::Combine.
3520 // Instead, just run the same selection twice while altering the deep buffer for media setting.
TEST_P(AudioPolicyManagerOutputMixPortForAttrSelectionTest,SelectPortByFlags)3521 TEST_P(AudioPolicyManagerOutputMixPortForAttrSelectionTest, SelectPortByFlags) {
3522 mConfig->setUseDeepBufferForMediaOverrideForTests(false);
3523 ASSERT_NO_FATAL_FAILURE(testOutputMixPortSelectionForAttr(
3524 std::get<MIX_PORT_ATTR_FLAGS_PARAMETER>(GetParam()),
3525 std::get<MIX_PORT_ATTR_FORMAT_PARAMETER>(GetParam()),
3526 std::get<MIX_PORT_ATTR_SAMPLING_RATE_PARAMETER>(GetParam()),
3527 false /*isMusic*/,
3528 std::get<MIX_PORT_ATTR_EXPECTED_NAME_PARAMETER>(GetParam())));
3529 }
TEST_P(AudioPolicyManagerOutputMixPortForAttrSelectionTest,SelectPortByFlags_Music)3530 TEST_P(AudioPolicyManagerOutputMixPortForAttrSelectionTest, SelectPortByFlags_Music) {
3531 mConfig->setUseDeepBufferForMediaOverrideForTests(false);
3532 ASSERT_NO_FATAL_FAILURE(testOutputMixPortSelectionForAttr(
3533 std::get<MIX_PORT_ATTR_FLAGS_PARAMETER>(GetParam()),
3534 std::get<MIX_PORT_ATTR_FORMAT_PARAMETER>(GetParam()),
3535 std::get<MIX_PORT_ATTR_SAMPLING_RATE_PARAMETER>(GetParam()),
3536 true /*isMusic*/,
3537 std::get<MIX_PORT_ATTR_EXPECTED_NAME_PARAMETER>(GetParam())));
3538 }
TEST_P(AudioPolicyManagerOutputMixPortForAttrSelectionTest,SelectPortByFlags_DeepMedia)3539 TEST_P(AudioPolicyManagerOutputMixPortForAttrSelectionTest, SelectPortByFlags_DeepMedia) {
3540 mConfig->setUseDeepBufferForMediaOverrideForTests(true);
3541 const char* fallbackName = std::get<MIX_PORT_ATTR_EXPECTED_NAME_PARAMETER>(GetParam());
3542 ASSERT_NO_FATAL_FAILURE(
3543 testOutputMixPortSelectionForAttr(std::get<MIX_PORT_ATTR_FLAGS_PARAMETER>(GetParam()),
3544 std::get<MIX_PORT_ATTR_FORMAT_PARAMETER>(GetParam()),
3545 std::get<MIX_PORT_ATTR_SAMPLING_RATE_PARAMETER>(GetParam()),
3546 false /*isMusic*/,
3547 std::get<MIX_PORT_ATTR_EXPECTED_NAME_WITH_DBFM_PARAMETER>(
3548 GetParam()) ?: fallbackName));
3549 }
TEST_P(AudioPolicyManagerOutputMixPortForAttrSelectionTest,SelectPortByFlags_DeepMedia_Music)3550 TEST_P(AudioPolicyManagerOutputMixPortForAttrSelectionTest, SelectPortByFlags_DeepMedia_Music) {
3551 mConfig->setUseDeepBufferForMediaOverrideForTests(true);
3552 const char* fallbackName = std::get<MIX_PORT_ATTR_EXPECTED_NAME_PARAMETER>(GetParam());
3553 ASSERT_NO_FATAL_FAILURE(
3554 testOutputMixPortSelectionForAttr(std::get<MIX_PORT_ATTR_FLAGS_PARAMETER>(GetParam()),
3555 std::get<MIX_PORT_ATTR_FORMAT_PARAMETER>(GetParam()),
3556 std::get<MIX_PORT_ATTR_SAMPLING_RATE_PARAMETER>(GetParam()),
3557 true /*isMusic*/,
3558 std::get<MIX_PORT_ATTR_EXPECTED_NAME_WITH_DBFM_PARAMETER>(
3559 GetParam()) ?: fallbackName));
3560 }
3561
3562 INSTANTIATE_TEST_CASE_P(AudioPolicyManagerOutputMixPortForAttrSelection,
3563 AudioPolicyManagerOutputMixPortForAttrSelectionTest,
3564 ::testing::Values(
3565 std::make_tuple("primary output", "deep buffer", AUDIO_OUTPUT_FLAG_NONE,
3566 AUDIO_FORMAT_PCM_16_BIT, AudioPolicyManagerTest::k48000SamplingRate),
3567 std::make_tuple("primary output", "deep buffer", AUDIO_OUTPUT_FLAG_NONE,
3568 AUDIO_FORMAT_PCM_FLOAT, AudioPolicyManagerTest::k48000SamplingRate),
3569 // Note: this goes to "direct" because 384000 > SAMPLE_RATE_HZ_MAX (192000)
3570 std::make_tuple("direct", "deep buffer", AUDIO_OUTPUT_FLAG_NONE,
3571 AUDIO_FORMAT_PCM_FLOAT, AudioPolicyManagerTest::k384000SamplingRate),
3572 std::make_tuple("primary output", nullptr, AUDIO_OUTPUT_FLAG_FAST,
3573 AUDIO_FORMAT_PCM_16_BIT, AudioPolicyManagerTest::k48000SamplingRate),
3574 std::make_tuple("direct", nullptr, AUDIO_OUTPUT_FLAG_DIRECT,
3575 AUDIO_FORMAT_PCM_FLOAT, AudioPolicyManagerTest::k96000SamplingRate),
3576 std::make_tuple("direct", nullptr, AUDIO_OUTPUT_FLAG_DIRECT,
3577 AUDIO_FORMAT_PCM_FLOAT, AudioPolicyManagerTest::k384000SamplingRate),
3578 std::make_tuple("deep buffer", nullptr, AUDIO_OUTPUT_FLAG_DEEP_BUFFER,
3579 AUDIO_FORMAT_PCM_16_BIT, AudioPolicyManagerTest::k48000SamplingRate),
3580 std::make_tuple("deep buffer", nullptr, AUDIO_OUTPUT_FLAG_DEEP_BUFFER,
3581 AUDIO_FORMAT_PCM_FLOAT, AudioPolicyManagerTest::k384000SamplingRate),
3582 std::make_tuple("compressed_offload", nullptr,
3583 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD |
3584 AUDIO_OUTPUT_FLAG_NON_BLOCKING),
3585 AUDIO_FORMAT_MP3, AudioPolicyManagerTest::k48000SamplingRate),
3586 std::make_tuple("raw", nullptr,
3587 AUDIO_OUTPUT_FLAG_RAW, AUDIO_FORMAT_PCM_32_BIT,
3588 AudioPolicyManagerTest::k48000SamplingRate),
3589 std::make_tuple("mmap_no_irq_out", nullptr,
3590 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_DIRECT |
3591 AUDIO_OUTPUT_FLAG_MMAP_NOIRQ),
3592 AUDIO_FORMAT_PCM_FLOAT, AudioPolicyManagerTest::k48000SamplingRate),
3593 std::make_tuple("mmap_no_irq_out", nullptr,
3594 (audio_output_flags_t)(AUDIO_OUTPUT_FLAG_DIRECT |
3595 AUDIO_OUTPUT_FLAG_MMAP_NOIRQ),
3596 AUDIO_FORMAT_PCM_FLOAT, AudioPolicyManagerTest::k384000SamplingRate),
3597 std::make_tuple("voip_rx", nullptr, AUDIO_OUTPUT_FLAG_VOIP_RX,
3598 AUDIO_FORMAT_PCM_16_BIT, AudioPolicyManagerTest::k48000SamplingRate)),
__anon9f2131310702(const ::testing::TestParamInfo<MixPortSelectionForAttr>& info) 3599 [](const ::testing::TestParamInfo<MixPortSelectionForAttr>& info) {
3600 static const std::string flagPrefix = "AUDIO_OUTPUT_FLAG_";
3601 static const std::string formatPrefix = "AUDIO_FORMAT_";
3602 std::string flags;
3603 TypeConverter<OutputFlagTraits>::maskToString(
3604 std::get<MIX_PORT_ATTR_FLAGS_PARAMETER>(info.param), flags, "__");
3605 size_t index = 0;
3606 while (true) {
3607 index = flags.rfind(flagPrefix);
3608 if (index == std::string::npos) break;
3609 flags.erase(index, flagPrefix.length());
3610 }
3611 std::string format;
3612 TypeConverter<FormatTraits>::toString(
3613 std::get<MIX_PORT_ATTR_FORMAT_PARAMETER>(info.param), format);
3614 if (size_t index = format.find(formatPrefix); index != std::string::npos) {
3615 format.erase(index, formatPrefix.length());
3616 }
3617 return flags + "__" + format + "__" +
3618 std::to_string(std::get<MIX_PORT_ATTR_SAMPLING_RATE_PARAMETER>(info.param));
3619 }
3620 );
3621
3622
3623 enum {
3624 MIX_PORT_STRM_EXPECTED_NAME_PARAMETER,
3625 MIX_PORT_STRM_EXPECTED_NAME_WITH_DBFM_PARAMETER,
3626 MIX_PORT_STRM_STREAM_PARAMETER,
3627 };
3628 using MixPortSelectionForStream =
3629 std::tuple<const char*, const char*, audio_stream_type_t>;
3630
3631 class AudioPolicyManagerOutputMixPortForStreamSelectionTest
3632 : public AudioPolicyManagerPhoneTest,
3633 public testing::WithParamInterface<MixPortSelectionForStream> {
3634 };
3635
3636 // There is no easy way to create a flat tuple from tuples via ::testing::Combine.
3637 // Instead, just run the same selection twice while altering the deep buffer for media setting.
TEST_P(AudioPolicyManagerOutputMixPortForStreamSelectionTest,SelectPort_NoDBFM)3638 TEST_P(AudioPolicyManagerOutputMixPortForStreamSelectionTest, SelectPort_NoDBFM) {
3639 mConfig->setUseDeepBufferForMediaOverrideForTests(false);
3640 ASSERT_NO_FATAL_FAILURE(testOutputMixPortSelectionForStream(
3641 std::get<MIX_PORT_STRM_STREAM_PARAMETER>(GetParam()),
3642 std::get<MIX_PORT_STRM_EXPECTED_NAME_PARAMETER>(GetParam())));
3643 }
TEST_P(AudioPolicyManagerOutputMixPortForStreamSelectionTest,SelectPort_WithDBFM)3644 TEST_P(AudioPolicyManagerOutputMixPortForStreamSelectionTest, SelectPort_WithDBFM) {
3645 mConfig->setUseDeepBufferForMediaOverrideForTests(true);
3646 const char* fallbackName = std::get<MIX_PORT_STRM_EXPECTED_NAME_PARAMETER>(GetParam());
3647 ASSERT_NO_FATAL_FAILURE(testOutputMixPortSelectionForStream(
3648 std::get<MIX_PORT_STRM_STREAM_PARAMETER>(GetParam()),
3649 std::get<MIX_PORT_STRM_EXPECTED_NAME_WITH_DBFM_PARAMETER>(
3650 GetParam()) ?: fallbackName));
3651 }
3652
3653 INSTANTIATE_TEST_CASE_P(
3654 AudioPolicyManagerOutputMixPortForStreamSelection,
3655 AudioPolicyManagerOutputMixPortForStreamSelectionTest,
3656 ::testing::Values(std::make_tuple("primary output", nullptr, AUDIO_STREAM_DEFAULT),
3657 std::make_tuple("primary output", nullptr, AUDIO_STREAM_SYSTEM),
3658 std::make_tuple("primary output", nullptr, AUDIO_STREAM_RING),
3659 std::make_tuple("primary output", "deep buffer", AUDIO_STREAM_MUSIC),
3660 std::make_tuple("primary output", nullptr, AUDIO_STREAM_ALARM),
3661 std::make_tuple("primary output", nullptr, AUDIO_STREAM_NOTIFICATION),
3662 std::make_tuple("primary output", nullptr, AUDIO_STREAM_BLUETOOTH_SCO),
3663 std::make_tuple("primary output", nullptr, AUDIO_STREAM_ENFORCED_AUDIBLE),
3664 std::make_tuple("primary output", nullptr, AUDIO_STREAM_DTMF),
3665 std::make_tuple("primary output", nullptr, AUDIO_STREAM_TTS),
3666 std::make_tuple("primary output", nullptr, AUDIO_STREAM_ACCESSIBILITY),
3667 std::make_tuple("primary output", nullptr, AUDIO_STREAM_ASSISTANT)),
__anon9f2131310902(const ::testing::TestParamInfo<MixPortSelectionForStream>& info) 3668 [](const ::testing::TestParamInfo<MixPortSelectionForStream>& info) {
3669 static const std::string streamPrefix = "AUDIO_STREAM_";
3670 std::string stream;
3671 TypeConverter<StreamTraits>::toString(
3672 std::get<MIX_PORT_STRM_STREAM_PARAMETER>(info.param), stream);
3673 if (size_t index = stream.find(streamPrefix); index != std::string::npos) {
3674 stream.erase(index, streamPrefix.length());
3675 }
3676 return stream;
3677 }
3678 );
3679
3680 class AudioPolicyManagerDynamicHwModulesTest : public AudioPolicyManagerTestWithConfigurationFile {
3681 protected:
3682 void SetUpManagerConfig() override;
3683 };
3684
SetUpManagerConfig()3685 void AudioPolicyManagerDynamicHwModulesTest::SetUpManagerConfig() {
3686 ASSERT_NO_FATAL_FAILURE(AudioPolicyManagerTestWithConfigurationFile::SetUpManagerConfig());
3687 // Only allow successful opening of "primary" hw module during APM initialization.
3688 mClient->swapAllowedModuleNames({"primary"});
3689 }
3690
TEST_F(AudioPolicyManagerDynamicHwModulesTest,InitSuccess)3691 TEST_F(AudioPolicyManagerDynamicHwModulesTest, InitSuccess) {
3692 // SetUp must finish with no assertions.
3693 }
3694
TEST_F(AudioPolicyManagerDynamicHwModulesTest,DynamicAddition)3695 TEST_F(AudioPolicyManagerDynamicHwModulesTest, DynamicAddition) {
3696 const auto handleBefore = mClient->peekNextModuleHandle();
3697 mManager->onNewAudioModulesAvailable();
3698 ASSERT_EQ(handleBefore, mClient->peekNextModuleHandle());
3699 // Reset module loading restrictions.
3700 mClient->swapAllowedModuleNames();
3701 mManager->onNewAudioModulesAvailable();
3702 const auto handleAfter = mClient->peekNextModuleHandle();
3703 ASSERT_GT(handleAfter, handleBefore);
3704 mManager->onNewAudioModulesAvailable();
3705 ASSERT_EQ(handleAfter, mClient->peekNextModuleHandle());
3706 }
3707
TEST_F(AudioPolicyManagerDynamicHwModulesTest,AddedDeviceAvailable)3708 TEST_F(AudioPolicyManagerDynamicHwModulesTest, AddedDeviceAvailable) {
3709 ASSERT_EQ(AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE, mManager->getDeviceConnectionState(
3710 AUDIO_DEVICE_IN_REMOTE_SUBMIX, "0"));
3711 mClient->swapAllowedModuleNames({"primary", "r_submix"});
3712 mManager->onNewAudioModulesAvailable();
3713 ASSERT_EQ(AUDIO_POLICY_DEVICE_STATE_AVAILABLE, mManager->getDeviceConnectionState(
3714 AUDIO_DEVICE_IN_REMOTE_SUBMIX, "0"));
3715 }
3716
TEST_F(AudioPolicyManagerDynamicHwModulesTest,ListAddedAudioPorts)3717 TEST_F(AudioPolicyManagerDynamicHwModulesTest, ListAddedAudioPorts) {
3718 ASSERT_FALSE(
3719 findDevicePort(AUDIO_PORT_ROLE_SOURCE, AUDIO_DEVICE_IN_REMOTE_SUBMIX, "0", nullptr));
3720 mClient->swapAllowedModuleNames({"primary", "r_submix"});
3721 mManager->onNewAudioModulesAvailable();
3722 struct audio_port_v7 port;
3723 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SOURCE, AUDIO_DEVICE_IN_REMOTE_SUBMIX, "0", &port));
3724 }
3725
TEST_F(AudioPolicyManagerDynamicHwModulesTest,ClientIsUpdated)3726 TEST_F(AudioPolicyManagerDynamicHwModulesTest, ClientIsUpdated) {
3727 const size_t prevAudioPortListUpdateCount = mClient->getAudioPortListUpdateCount();
3728 const uint32_t prevAudioPortGeneration = mManager->getAudioPortGeneration();
3729 mClient->swapAllowedModuleNames({"primary", "r_submix"});
3730 mManager->onNewAudioModulesAvailable();
3731 EXPECT_GT(mClient->getAudioPortListUpdateCount(), prevAudioPortListUpdateCount);
3732 EXPECT_GT(mManager->getAudioPortGeneration(), prevAudioPortGeneration);
3733 }
3734
3735 using DevicesRoleForCapturePresetParam = std::tuple<audio_source_t, device_role_t>;
3736
3737 class AudioPolicyManagerDevicesRoleForCapturePresetTest
3738 : public AudioPolicyManagerTestWithConfigurationFile,
3739 public testing::WithParamInterface<DevicesRoleForCapturePresetParam> {
3740 protected:
3741 // The `inputDevice` and `inputDevice2` indicate the audio devices type to be used for setting
3742 // device role. They must be declared in the test_audio_policy_configuration.xml
3743 AudioDeviceTypeAddr inputDevice = AudioDeviceTypeAddr(AUDIO_DEVICE_IN_BUILTIN_MIC, "");
3744 AudioDeviceTypeAddr inputDevice2 = AudioDeviceTypeAddr(AUDIO_DEVICE_IN_HDMI, "");
3745 };
3746
TEST_P(AudioPolicyManagerDevicesRoleForCapturePresetTest,DevicesRoleForCapturePreset)3747 TEST_P(AudioPolicyManagerDevicesRoleForCapturePresetTest, DevicesRoleForCapturePreset) {
3748 const audio_source_t audioSource = std::get<0>(GetParam());
3749 const device_role_t role = std::get<1>(GetParam());
3750
3751 // Test invalid device when setting
3752 const AudioDeviceTypeAddr outputDevice(AUDIO_DEVICE_OUT_SPEAKER, "");
3753 const AudioDeviceTypeAddrVector outputDevices = {outputDevice};
3754 ASSERT_EQ(BAD_VALUE,
3755 mManager->setDevicesRoleForCapturePreset(audioSource, role, outputDevices));
3756 ASSERT_EQ(BAD_VALUE,
3757 mManager->addDevicesRoleForCapturePreset(audioSource, role, outputDevices));
3758 AudioDeviceTypeAddrVector devices;
3759 ASSERT_EQ(NAME_NOT_FOUND,
3760 mManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices));
3761 ASSERT_TRUE(devices.empty());
3762 ASSERT_EQ(BAD_VALUE,
3763 mManager->removeDevicesRoleForCapturePreset(audioSource, role, outputDevices));
3764
3765 // Without setting, call get/remove/clear must fail
3766 ASSERT_EQ(NAME_NOT_FOUND,
3767 mManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices));
3768 ASSERT_EQ(NAME_NOT_FOUND,
3769 mManager->removeDevicesRoleForCapturePreset(audioSource, role, devices));
3770 ASSERT_EQ(NAME_NOT_FOUND,
3771 mManager->clearDevicesRoleForCapturePreset(audioSource, role));
3772
3773 // Test set/get devices role
3774 const AudioDeviceTypeAddrVector inputDevices = {inputDevice};
3775 ASSERT_EQ(NO_ERROR,
3776 mManager->setDevicesRoleForCapturePreset(audioSource, role, inputDevices));
3777 ASSERT_EQ(NO_ERROR, mManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices));
3778 EXPECT_THAT(devices, UnorderedElementsAre(inputDevice));
3779
3780 // Test setting will change the previously set devices
3781 const AudioDeviceTypeAddrVector inputDevices2 = {inputDevice2};
3782 ASSERT_EQ(NO_ERROR,
3783 mManager->setDevicesRoleForCapturePreset(audioSource, role, inputDevices2));
3784 devices.clear();
3785 ASSERT_EQ(NO_ERROR, mManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices));
3786 EXPECT_THAT(devices, UnorderedElementsAre(inputDevice2));
3787
3788 // Test add devices
3789 ASSERT_EQ(NO_ERROR,
3790 mManager->addDevicesRoleForCapturePreset(audioSource, role, inputDevices));
3791 devices.clear();
3792 ASSERT_EQ(NO_ERROR, mManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices));
3793 EXPECT_THAT(devices, UnorderedElementsAre(inputDevice, inputDevice2));
3794
3795 // Test remove devices
3796 ASSERT_EQ(NO_ERROR,
3797 mManager->removeDevicesRoleForCapturePreset(audioSource, role, inputDevices));
3798 devices.clear();
3799 ASSERT_EQ(NO_ERROR, mManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices));
3800 EXPECT_THAT(devices, UnorderedElementsAre(inputDevice2));
3801
3802 // Test remove devices that are not set as the device role
3803 ASSERT_EQ(BAD_VALUE,
3804 mManager->removeDevicesRoleForCapturePreset(audioSource, role, inputDevices));
3805
3806 // Test clear devices
3807 ASSERT_EQ(NO_ERROR,
3808 mManager->clearDevicesRoleForCapturePreset(audioSource, role));
3809 devices.clear();
3810 ASSERT_EQ(NAME_NOT_FOUND,
3811 mManager->getDevicesForRoleAndCapturePreset(audioSource, role, devices));
3812 }
3813
TEST_F(AudioPolicyManagerDevicesRoleForCapturePresetTest,PreferredDeviceUsedForInput)3814 TEST_F(AudioPolicyManagerDevicesRoleForCapturePresetTest, PreferredDeviceUsedForInput) {
3815 const audio_source_t source = AUDIO_SOURCE_MIC;
3816 const device_role_t role = DEVICE_ROLE_PREFERRED;
3817 const std::string address = "card=1;device=0";
3818 const std::string deviceName = "randomName";
3819
3820 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
3821 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
3822 address.c_str(), deviceName.c_str(), AUDIO_FORMAT_DEFAULT));
3823 auto availableDevices = mManager->getAvailableInputDevices();
3824 ASSERT_GT(availableDevices.size(), 1);
3825
3826 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
3827 attr.source = source;
3828 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
3829 audio_io_handle_t input = AUDIO_PORT_HANDLE_NONE;
3830 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input, AUDIO_SESSION_NONE, 1, &selectedDeviceId,
3831 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
3832 k48000SamplingRate));
3833 auto selectedDevice = availableDevices.getDeviceFromId(selectedDeviceId);
3834 ASSERT_NE(nullptr, selectedDevice);
3835
3836 sp<DeviceDescriptor> preferredDevice = nullptr;
3837 for (const auto& device : availableDevices) {
3838 if (device != selectedDevice) {
3839 preferredDevice = device;
3840 break;
3841 }
3842 }
3843 ASSERT_NE(nullptr, preferredDevice);
3844 // After setting preferred device for capture preset, the selected device for input should be
3845 // the preferred device.
3846 ASSERT_EQ(NO_ERROR,
3847 mManager->setDevicesRoleForCapturePreset(source, role,
3848 {preferredDevice->getDeviceTypeAddr()}));
3849 selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
3850 input = AUDIO_PORT_HANDLE_NONE;
3851 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input, AUDIO_SESSION_NONE, 1, &selectedDeviceId,
3852 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
3853 k48000SamplingRate));
3854 ASSERT_EQ(preferredDevice, availableDevices.getDeviceFromId(selectedDeviceId));
3855
3856 // After clearing preferred device for capture preset, the selected device for input should be
3857 // the same as original one.
3858 ASSERT_EQ(NO_ERROR,
3859 mManager->clearDevicesRoleForCapturePreset(source, role));
3860 selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
3861 input = AUDIO_PORT_HANDLE_NONE;
3862 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input, AUDIO_SESSION_NONE, 1, &selectedDeviceId,
3863 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
3864 k48000SamplingRate));
3865 ASSERT_EQ(selectedDevice, availableDevices.getDeviceFromId(selectedDeviceId));
3866
3867 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
3868 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
3869 address.c_str(), deviceName.c_str(), AUDIO_FORMAT_DEFAULT));
3870 }
3871
TEST_F(AudioPolicyManagerDevicesRoleForCapturePresetTest,DisabledDeviceNotUsedForInput)3872 TEST_F(AudioPolicyManagerDevicesRoleForCapturePresetTest, DisabledDeviceNotUsedForInput) {
3873 const audio_source_t source = AUDIO_SOURCE_MIC;
3874 const device_role_t role = DEVICE_ROLE_DISABLED;
3875 const std::string address = "card=1;device=0";
3876 const std::string deviceName = "randomName";
3877
3878 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
3879 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
3880 address.c_str(), deviceName.c_str(), AUDIO_FORMAT_DEFAULT));
3881 auto availableDevices = mManager->getAvailableInputDevices();
3882 ASSERT_GT(availableDevices.size(), 1);
3883
3884 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
3885 attr.source = source;
3886 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
3887 audio_io_handle_t input = AUDIO_PORT_HANDLE_NONE;
3888 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input, AUDIO_SESSION_NONE, 1, &selectedDeviceId,
3889 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
3890 k48000SamplingRate));
3891 auto selectedDevice = availableDevices.getDeviceFromId(selectedDeviceId);
3892 ASSERT_NE(nullptr, selectedDevice);
3893
3894 // After setting disabled device for capture preset, the disabled device must not be
3895 // selected for input.
3896 ASSERT_EQ(NO_ERROR,
3897 mManager->setDevicesRoleForCapturePreset(source, role,
3898 {selectedDevice->getDeviceTypeAddr()}));
3899 selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
3900 input = AUDIO_PORT_HANDLE_NONE;
3901 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input, AUDIO_SESSION_NONE, 1,
3902 &selectedDeviceId, AUDIO_FORMAT_PCM_16_BIT,
3903 AUDIO_CHANNEL_IN_STEREO, k48000SamplingRate));
3904 ASSERT_NE(selectedDevice, availableDevices.getDeviceFromId(selectedDeviceId));
3905
3906 // After clearing disabled device for capture preset, the selected device for input should be
3907 // the original one.
3908 ASSERT_EQ(NO_ERROR,
3909 mManager->clearDevicesRoleForCapturePreset(source, role));
3910 selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
3911 input = AUDIO_PORT_HANDLE_NONE;
3912 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input, AUDIO_SESSION_NONE, 1, &selectedDeviceId,
3913 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
3914 k48000SamplingRate));
3915 ASSERT_EQ(selectedDevice, availableDevices.getDeviceFromId(selectedDeviceId));
3916
3917 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
3918 AUDIO_DEVICE_IN_USB_DEVICE, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
3919 address.c_str(), deviceName.c_str(), AUDIO_FORMAT_DEFAULT));
3920 }
3921
3922 INSTANTIATE_TEST_CASE_P(
3923 DevicesRoleForCapturePresetOperation,
3924 AudioPolicyManagerDevicesRoleForCapturePresetTest,
3925 testing::Values(
3926 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_MIC, DEVICE_ROLE_PREFERRED}),
3927 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_VOICE_UPLINK,
3928 DEVICE_ROLE_PREFERRED}),
3929 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_VOICE_DOWNLINK,
3930 DEVICE_ROLE_PREFERRED}),
3931 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_VOICE_CALL, DEVICE_ROLE_PREFERRED}),
3932 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_CAMCORDER, DEVICE_ROLE_PREFERRED}),
3933 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_VOICE_RECOGNITION,
3934 DEVICE_ROLE_PREFERRED}),
3935 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_VOICE_COMMUNICATION,
3936 DEVICE_ROLE_PREFERRED}),
3937 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_REMOTE_SUBMIX,
3938 DEVICE_ROLE_PREFERRED}),
3939 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_UNPROCESSED, DEVICE_ROLE_PREFERRED}),
3940 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_VOICE_PERFORMANCE,
3941 DEVICE_ROLE_PREFERRED}),
3942 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_ECHO_REFERENCE,
3943 DEVICE_ROLE_PREFERRED}),
3944 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_FM_TUNER, DEVICE_ROLE_PREFERRED}),
3945 DevicesRoleForCapturePresetParam({AUDIO_SOURCE_HOTWORD, DEVICE_ROLE_PREFERRED})
3946 )
3947 );
3948
3949
3950 const effect_descriptor_t TEST_EFFECT_DESC = {
3951 {0xf2a4bb20, 0x0c3c, 0x11e3, 0x8b07, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // type
3952 {0xff93e360, 0x0c3c, 0x11e3, 0x8a97, {0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b}}, // uuid
3953 EFFECT_CONTROL_API_VERSION,
3954 EFFECT_FLAG_TYPE_PRE_PROC,
3955 0,
3956 1,
3957 "APM test Effect",
3958 "The Android Open Source Project",
3959 };
3960
3961 class AudioPolicyManagerPreProcEffectTest : public AudioPolicyManagerTestWithConfigurationFile {
3962 };
3963
TEST_F(AudioPolicyManagerPreProcEffectTest,DeviceDisconnectWhileClientActive)3964 TEST_F(AudioPolicyManagerPreProcEffectTest, DeviceDisconnectWhileClientActive) {
3965 const audio_source_t source = AUDIO_SOURCE_MIC;
3966 const std::string address = "BUS00_MIC";
3967 const std::string deviceName = "randomName";
3968 audio_port_handle_t portId;
3969 audio_devices_t type = AUDIO_DEVICE_IN_BUS;
3970
3971 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(type,
3972 AUDIO_POLICY_DEVICE_STATE_AVAILABLE, address.c_str(), deviceName.c_str(),
3973 AUDIO_FORMAT_DEFAULT));
3974 auto availableDevices = mManager->getAvailableInputDevices();
3975 ASSERT_GT(availableDevices.size(), 1);
3976
3977 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
3978 attr.source = source;
3979 audio_session_t session = TEST_SESSION_ID;
3980 audio_io_handle_t inputClientHandle = 777;
3981 int effectId = 666;
3982 audio_port_v7 devicePort;
3983 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SOURCE, type, address, &devicePort));
3984
3985 audio_port_handle_t routedPortId = devicePort.id;
3986 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &inputClientHandle, session, 1, &routedPortId,
3987 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
3988 48000, AUDIO_INPUT_FLAG_NONE, &portId));
3989 ASSERT_EQ(devicePort.id, routedPortId);
3990 auto selectedDevice = availableDevices.getDeviceFromId(routedPortId);
3991 ASSERT_NE(nullptr, selectedDevice);
3992
3993 // Add a pre processing effect on the input client session
3994 ASSERT_EQ(NO_ERROR, mManager->registerEffect(&TEST_EFFECT_DESC, inputClientHandle,
3995 PRODUCT_STRATEGY_NONE, session, effectId));
3996
3997 ASSERT_EQ(NO_ERROR, mManager->startInput(portId));
3998
3999 // Force a device disconnection to close the input, no crash expected of APM
4000 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
4001 type, AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
4002 address.c_str(), deviceName.c_str(), AUDIO_FORMAT_DEFAULT));
4003
4004 // Reconnect the device
4005 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(
4006 type, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
4007 address.c_str(), deviceName.c_str(), AUDIO_FORMAT_DEFAULT));
4008
4009 inputClientHandle += 1;
4010 ASSERT_TRUE(findDevicePort(AUDIO_PORT_ROLE_SOURCE, type, address, &devicePort));
4011 routedPortId = devicePort.id;
4012
4013 // Reconnect the client changing voluntarily the io, but keeping the session to get the
4014 // effect attached again
4015 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &inputClientHandle, session, 1, &routedPortId,
4016 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
4017 k48000SamplingRate));
4018
4019 // unregister effect should succeed since effect shall have been restore on the client session
4020 ASSERT_EQ(NO_ERROR, mManager->unregisterEffect(effectId));
4021 }
4022
4023 class AudioPolicyManagerTestBitPerfectBase : public AudioPolicyManagerTestWithConfigurationFile {
4024 protected:
4025 void SetUp() override;
4026 void TearDown() override;
4027
4028 void startBitPerfectOutput();
4029 void reset();
4030 void getBitPerfectOutput(status_t expected);
4031
4032 const audio_format_t mBitPerfectFormat = AUDIO_FORMAT_PCM_16_BIT;
4033 const audio_channel_mask_t mBitPerfectChannelMask = AUDIO_CHANNEL_OUT_STEREO;
4034 const uint32_t mBitPerfectSampleRate = k48000SamplingRate;
4035 const uid_t mUid = 1234;
4036 audio_port_handle_t mUsbPortId = AUDIO_PORT_HANDLE_NONE;
4037
4038 audio_io_handle_t mBitPerfectOutput = AUDIO_IO_HANDLE_NONE;
4039 DeviceIdVector mSelectedDeviceIds;
4040 audio_port_handle_t mBitPerfectPortId = AUDIO_PORT_HANDLE_NONE;
4041
4042 static constexpr audio_attributes_t sMediaAttr = {
4043 .content_type = AUDIO_CONTENT_TYPE_MUSIC,
4044 .usage = AUDIO_USAGE_MEDIA,
4045 };
4046 };
4047
SetUp()4048 void AudioPolicyManagerTestBitPerfectBase::SetUp() {
4049 ASSERT_NO_FATAL_FAILURE(AudioPolicyManagerTestWithConfigurationFile::SetUp());
4050
4051 mClient->addSupportedFormat(mBitPerfectFormat);
4052 mClient->addSupportedChannelMask(mBitPerfectChannelMask);
4053 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
4054 AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
4055 "", "", AUDIO_FORMAT_DEFAULT));
4056 auto devices = mManager->getAvailableOutputDevices();
4057 mUsbPortId = AUDIO_PORT_HANDLE_NONE;
4058 for (auto device : devices) {
4059 if (device->type() == AUDIO_DEVICE_OUT_USB_DEVICE) {
4060 mUsbPortId = device->getId();
4061 break;
4062 }
4063 }
4064 EXPECT_NE(AUDIO_PORT_HANDLE_NONE, mUsbPortId);
4065
4066 std::vector<audio_mixer_attributes_t> mixerAttributes;
4067 EXPECT_EQ(NO_ERROR, mManager->getSupportedMixerAttributes(mUsbPortId, mixerAttributes));
4068 EXPECT_GT(mixerAttributes.size(), 0);
4069 size_t bitPerfectIndex = 0;
4070 for (; bitPerfectIndex < mixerAttributes.size(); ++bitPerfectIndex) {
4071 if (mixerAttributes[bitPerfectIndex].mixer_behavior == AUDIO_MIXER_BEHAVIOR_BIT_PERFECT) {
4072 break;
4073 }
4074 }
4075 EXPECT_LT(bitPerfectIndex, mixerAttributes.size());
4076 EXPECT_EQ(mBitPerfectFormat, mixerAttributes[bitPerfectIndex].config.format);
4077 EXPECT_EQ(mBitPerfectChannelMask, mixerAttributes[bitPerfectIndex].config.channel_mask);
4078 EXPECT_EQ(mBitPerfectSampleRate, mixerAttributes[bitPerfectIndex].config.sample_rate);
4079 EXPECT_EQ(NO_ERROR,
4080 mManager->setPreferredMixerAttributes(
4081 &sMediaAttr, mUsbPortId, mUid, &mixerAttributes[bitPerfectIndex]));
4082 }
4083
TearDown()4084 void AudioPolicyManagerTestBitPerfectBase::TearDown() {
4085 EXPECT_EQ(NO_ERROR,
4086 mManager->clearPreferredMixerAttributes(&sMediaAttr, mUsbPortId, mUid));
4087 ASSERT_EQ(NO_ERROR, mManager->setDeviceConnectionState(AUDIO_DEVICE_OUT_USB_DEVICE,
4088 AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE,
4089 "", "", AUDIO_FORMAT_LDAC));
4090
4091 ASSERT_NO_FATAL_FAILURE(AudioPolicyManagerTestWithConfigurationFile::TearDown());
4092 }
4093
startBitPerfectOutput()4094 void AudioPolicyManagerTestBitPerfectBase::startBitPerfectOutput() {
4095 reset();
4096 bool isBitPerfect;
4097
4098 getOutputForAttr(&mSelectedDeviceIds, mBitPerfectFormat, mBitPerfectChannelMask,
4099 mBitPerfectSampleRate, AUDIO_OUTPUT_FLAG_NONE, &mBitPerfectOutput,
4100 &mBitPerfectPortId, sMediaAttr, AUDIO_SESSION_NONE, mUid, &isBitPerfect);
4101 status_t status = mManager->startOutput(mBitPerfectPortId);
4102 if (status == DEAD_OBJECT) {
4103 getOutputForAttr(&mSelectedDeviceIds, mBitPerfectFormat, mBitPerfectChannelMask,
4104 mBitPerfectSampleRate, AUDIO_OUTPUT_FLAG_NONE, &mBitPerfectOutput,
4105 &mBitPerfectPortId, sMediaAttr, AUDIO_SESSION_NONE, mUid, &isBitPerfect);
4106 status = mManager->startOutput(mBitPerfectPortId);
4107 }
4108 EXPECT_EQ(NO_ERROR, status);
4109 EXPECT_TRUE(isBitPerfect);
4110 EXPECT_NE(AUDIO_IO_HANDLE_NONE, mBitPerfectOutput);
4111 const auto bitPerfectOutputDesc = mManager->getOutputs().valueFor(mBitPerfectOutput);
4112 EXPECT_NE(nullptr, bitPerfectOutputDesc);
4113 EXPECT_EQ(AUDIO_OUTPUT_FLAG_BIT_PERFECT,
4114 bitPerfectOutputDesc->mFlags & AUDIO_OUTPUT_FLAG_BIT_PERFECT);
4115 };
4116
reset()4117 void AudioPolicyManagerTestBitPerfectBase::reset() {
4118 mBitPerfectOutput = AUDIO_IO_HANDLE_NONE;
4119 mBitPerfectPortId = AUDIO_PORT_HANDLE_NONE;
4120 mSelectedDeviceIds.clear();
4121 }
4122
getBitPerfectOutput(status_t expected)4123 void AudioPolicyManagerTestBitPerfectBase::getBitPerfectOutput(status_t expected) {
4124 reset();
4125 audio_stream_type_t stream = AUDIO_STREAM_DEFAULT;
4126 AttributionSourceState attributionSource = createAttributionSourceState(mUid);
4127 audio_config_t config = AUDIO_CONFIG_INITIALIZER;
4128 config.sample_rate = mBitPerfectSampleRate;
4129 config.channel_mask = mBitPerfectChannelMask;
4130 config.format = mBitPerfectFormat;
4131 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_BIT_PERFECT;
4132 AudioPolicyInterface::output_type_t outputType;
4133 bool isSpatialized;
4134 bool isBitPerfect;
4135 float volume;
4136 bool muted;
4137 EXPECT_EQ(expected,
4138 mManager->getOutputForAttr(&sMediaAttr, &mBitPerfectOutput, AUDIO_SESSION_NONE,
4139 &stream, attributionSource, &config, &flags,
4140 &mSelectedDeviceIds, &mBitPerfectPortId, {}, &outputType,
4141 &isSpatialized, &isBitPerfect, &volume, &muted));
4142 }
4143
4144 class AudioPolicyManagerTestBitPerfect : public AudioPolicyManagerTestBitPerfectBase {
4145 };
4146
TEST_F(AudioPolicyManagerTestBitPerfect,UseBitPerfectOutput)4147 TEST_F(AudioPolicyManagerTestBitPerfect, UseBitPerfectOutput) {
4148 const uid_t anotherUid = 5678;
4149 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
4150 DeviceIdVector selectedDeviceIds;
4151 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
4152 bool isBitPerfect;
4153
4154 // When there is no active bit-perfect playback, the output selection will follow default
4155 // routing strategy.
4156 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_QUAD,
4157 48000, AUDIO_OUTPUT_FLAG_NONE, &output, &portId, sMediaAttr,
4158 AUDIO_SESSION_NONE, mUid, &isBitPerfect);
4159 EXPECT_FALSE(isBitPerfect);
4160 EXPECT_NE(AUDIO_IO_HANDLE_NONE, output);
4161 const auto outputDesc = mManager->getOutputs().valueFor(output);
4162 EXPECT_NE(nullptr, outputDesc);
4163 EXPECT_NE(AUDIO_OUTPUT_FLAG_BIT_PERFECT, outputDesc->mFlags & AUDIO_OUTPUT_FLAG_BIT_PERFECT);
4164
4165 // Start bit-perfect playback
4166 ASSERT_NO_FATAL_FAILURE(startBitPerfectOutput());
4167
4168 // If the playback is from preferred mixer attributes owner but the request doesn't match
4169 // preferred mixer attributes, it will not be bit-perfect.
4170 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_QUAD,
4171 48000, AUDIO_OUTPUT_FLAG_NONE, &output, &portId, sMediaAttr,
4172 AUDIO_SESSION_NONE, mUid, &isBitPerfect);
4173 EXPECT_FALSE(isBitPerfect);
4174 EXPECT_EQ(mBitPerfectOutput, output);
4175
4176 // When bit-perfect playback is active, all other playback will be routed to bit-perfect output.
4177 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
4178 48000, AUDIO_OUTPUT_FLAG_NONE, &output, &portId, sMediaAttr,
4179 AUDIO_SESSION_NONE, anotherUid, &isBitPerfect);
4180 EXPECT_FALSE(isBitPerfect);
4181 EXPECT_EQ(mBitPerfectOutput, output);
4182
4183 // When bit-pefect playback is active, dtmf will also be routed to bit-perfect output.
4184 const audio_attributes_t dtmfAttr = {
4185 .content_type = AUDIO_CONTENT_TYPE_UNKNOWN,
4186 .usage = AUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING,
4187 };
4188 audio_io_handle_t dtmfOutput = AUDIO_IO_HANDLE_NONE;
4189 selectedDeviceIds.clear();
4190 portId = AUDIO_PORT_HANDLE_NONE;
4191 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
4192 48000, AUDIO_OUTPUT_FLAG_NONE, &dtmfOutput, &portId, dtmfAttr,
4193 AUDIO_SESSION_NONE, anotherUid, &isBitPerfect);
4194 EXPECT_FALSE(isBitPerfect);
4195 EXPECT_EQ(mBitPerfectOutput, dtmfOutput);
4196
4197 // When configuration matches preferred mixer attributes, which is bit-perfect, but the client
4198 // is not the owner of preferred mixer attributes, the playback will not be bit-perfect.
4199 getOutputForAttr(&selectedDeviceIds, mBitPerfectFormat, mBitPerfectChannelMask,
4200 mBitPerfectSampleRate, AUDIO_OUTPUT_FLAG_NONE, &output, &portId, sMediaAttr,
4201 AUDIO_SESSION_NONE, anotherUid, &isBitPerfect);
4202 EXPECT_FALSE(isBitPerfect);
4203 EXPECT_EQ(mBitPerfectOutput, output);
4204 }
4205
TEST_F_WITH_FLAGS(AudioPolicyManagerTestBitPerfect,InternalMuteWhenBitPerfectCLientIsActive,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (com::android::media::audioserver,fix_concurrent_playback_behavior_with_bit_perfect_client)))4206 TEST_F_WITH_FLAGS(
4207 AudioPolicyManagerTestBitPerfect,
4208 InternalMuteWhenBitPerfectCLientIsActive,
4209 REQUIRES_FLAGS_ENABLED(
4210 ACONFIG_FLAG(com::android::media::audioserver,
4211 fix_concurrent_playback_behavior_with_bit_perfect_client))
4212 ) {
4213 ASSERT_NO_FATAL_FAILURE(startBitPerfectOutput());
4214
4215 // When bit-perfect playback is active, the system sound will be routed to bit-perfect output.
4216 // The system sound will be muted internally in this case. The bit-perfect client will be
4217 // played normally.
4218 const uint32_t anotherSampleRate = 44100;
4219 audio_port_handle_t systemSoundPortId = AUDIO_PORT_HANDLE_NONE;
4220 audio_io_handle_t systemSoundOutput = AUDIO_IO_HANDLE_NONE;
4221 const audio_attributes_t systemSoundAttr = {
4222 .content_type = AUDIO_CONTENT_TYPE_SONIFICATION,
4223 .usage = AUDIO_USAGE_ASSISTANCE_SONIFICATION,
4224 };
4225 DeviceIdVector selectedDeviceIds;
4226 bool isBitPerfect;
4227 getOutputForAttr(&selectedDeviceIds, mBitPerfectFormat, mBitPerfectChannelMask,
4228 anotherSampleRate, AUDIO_OUTPUT_FLAG_NONE, &systemSoundOutput,
4229 &systemSoundPortId, systemSoundAttr, AUDIO_SESSION_NONE, mUid, &isBitPerfect);
4230 EXPECT_FALSE(isBitPerfect);
4231 EXPECT_EQ(mBitPerfectOutput, systemSoundOutput);
4232 EXPECT_EQ(NO_ERROR, mManager->startOutput(systemSoundPortId));
4233 EXPECT_TRUE(mClient->getTrackInternalMute(systemSoundPortId));
4234 EXPECT_FALSE(mClient->getTrackInternalMute(mBitPerfectPortId));
4235 EXPECT_EQ(NO_ERROR, mManager->stopOutput(systemSoundPortId));
4236 EXPECT_FALSE(mClient->getTrackInternalMute(mBitPerfectPortId));
4237
4238 // When bit-perfect playback is active, the notification will be routed to bit-perfect output.
4239 // The notification sound will be played normally while the bit-perfect client will be muted
4240 // internally.
4241 audio_port_handle_t notificationPortId = AUDIO_PORT_HANDLE_NONE;
4242 audio_io_handle_t notificationOutput = AUDIO_IO_HANDLE_NONE;
4243 const audio_attributes_t notificationAttr = {
4244 .content_type = AUDIO_CONTENT_TYPE_SONIFICATION,
4245 .usage = AUDIO_USAGE_NOTIFICATION,
4246 };
4247 getOutputForAttr(&selectedDeviceIds, mBitPerfectFormat, mBitPerfectChannelMask,
4248 anotherSampleRate, AUDIO_OUTPUT_FLAG_NONE, ¬ificationOutput,
4249 ¬ificationPortId, notificationAttr, AUDIO_SESSION_NONE, mUid,
4250 &isBitPerfect);
4251 EXPECT_FALSE(isBitPerfect);
4252 EXPECT_EQ(mBitPerfectOutput, notificationOutput);
4253 EXPECT_EQ(NO_ERROR, mManager->startOutput(notificationPortId));
4254 EXPECT_FALSE(mClient->getTrackInternalMute(notificationPortId));
4255 EXPECT_TRUE(mClient->getTrackInternalMute(mBitPerfectPortId));
4256 EXPECT_EQ(NO_ERROR, mManager->stopOutput(notificationPortId));
4257 EXPECT_FALSE(mClient->getTrackInternalMute(mBitPerfectPortId));
4258
4259 EXPECT_EQ(NO_ERROR, mManager->stopOutput(mBitPerfectPortId));
4260 }
4261
4262 class AudioPolicyManagerTestBitPerfectPhoneMode : public AudioPolicyManagerTestBitPerfectBase,
4263 public testing::WithParamInterface<audio_mode_t> {
4264 };
4265
TEST_P(AudioPolicyManagerTestBitPerfectPhoneMode,RejectBitPerfectWhenPhoneModeIsNotNormal)4266 TEST_P(AudioPolicyManagerTestBitPerfectPhoneMode, RejectBitPerfectWhenPhoneModeIsNotNormal) {
4267 if (!com::android::media::audioserver::
4268 fix_concurrent_playback_behavior_with_bit_perfect_client()) {
4269 GTEST_SKIP()
4270 << "Flag fix_concurrent_playback_behavior_with_bit_perfect_client is not enabled";
4271 }
4272
4273 ASSERT_NO_FATAL_FAILURE(startBitPerfectOutput());
4274
4275 audio_mode_t mode = GetParam();
4276 mManager->setPhoneState(mode);
4277 // When the phone mode is not normal, the bit-perfect output will be reopned
4278 EXPECT_EQ(nullptr, mManager->getOutputs().valueFor(mBitPerfectOutput));
4279
4280 // When the phone mode is not normal, the bit-perfect output will be closed.
4281 ASSERT_NO_FATAL_FAILURE(getBitPerfectOutput(INVALID_OPERATION));
4282
4283 mManager->setPhoneState(AUDIO_MODE_NORMAL);
4284 }
4285
4286 INSTANTIATE_TEST_CASE_P(
4287 PhoneMode,
4288 AudioPolicyManagerTestBitPerfectPhoneMode,
4289 testing::Values(AUDIO_MODE_IN_CALL,
4290 AUDIO_MODE_RINGTONE,
4291 AUDIO_MODE_IN_COMMUNICATION,
4292 AUDIO_MODE_CALL_SCREEN)
4293 );
4294
4295 class AudioPolicyManagerTestBitPerfectHigherPriorityUseCaseActive :
4296 public AudioPolicyManagerTestBitPerfectBase,
4297 public testing::WithParamInterface<audio_usage_t> {
4298 };
4299
TEST_P(AudioPolicyManagerTestBitPerfectHigherPriorityUseCaseActive,RejectBitPerfectWhenHigherPriorityUseCaseIsActive)4300 TEST_P(AudioPolicyManagerTestBitPerfectHigherPriorityUseCaseActive,
4301 RejectBitPerfectWhenHigherPriorityUseCaseIsActive) {
4302 if (!com::android::media::audioserver::
4303 fix_concurrent_playback_behavior_with_bit_perfect_client()) {
4304 GTEST_SKIP()
4305 << "Flag fix_concurrent_playback_behavior_with_bit_perfect_client is not enabled";
4306 }
4307
4308 ASSERT_NO_FATAL_FAILURE(startBitPerfectOutput());
4309
4310 audio_attributes_t attr = {
4311 .content_type = AUDIO_CONTENT_TYPE_UNKNOWN,
4312 .usage = GetParam(),
4313 };
4314 DeviceIdVector selectedDeviceIds;
4315 audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE;
4316 audio_io_handle_t output = AUDIO_IO_HANDLE_NONE;
4317 ASSERT_NO_FATAL_FAILURE(
4318 getOutputForAttr(&selectedDeviceIds, AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_OUT_STEREO,
4319 48000, AUDIO_OUTPUT_FLAG_NONE, &output, &portId, attr));
4320 EXPECT_NE(mBitPerfectOutput, output);
4321 EXPECT_EQ(NO_ERROR, mManager->startOutput(portId));
4322 // When a high priority use case is active, the bit-perfect output will be closed.
4323 EXPECT_EQ(nullptr, mManager->getOutputs().valueFor(mBitPerfectOutput));
4324
4325 // When any higher priority use case is active, the bit-perfect request will be rejected.
4326 ASSERT_NO_FATAL_FAILURE(getBitPerfectOutput(INVALID_OPERATION));
4327 }
4328
4329 INSTANTIATE_TEST_CASE_P(
4330 HigherPriorityUseCases,
4331 AudioPolicyManagerTestBitPerfectHigherPriorityUseCaseActive,
4332 testing::Values(AUDIO_USAGE_NOTIFICATION_TELEPHONY_RINGTONE,
4333 AUDIO_USAGE_ALARM)
4334 );
4335
4336 class AudioPolicyManagerInputPreemptionTest : public AudioPolicyManagerTestWithConfigurationFile {
4337 };
4338
TEST_F_WITH_FLAGS(AudioPolicyManagerInputPreemptionTest,SameSessionReusesInput,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (com::android::media::audioserver,fix_input_sharing_logic)))4339 TEST_F_WITH_FLAGS(
4340 AudioPolicyManagerInputPreemptionTest,
4341 SameSessionReusesInput,
4342 REQUIRES_FLAGS_ENABLED(
4343 ACONFIG_FLAG(com::android::media::audioserver, fix_input_sharing_logic))
4344 ) {
4345 mClient->resetInputApiCallsCounters();
4346
4347 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
4348 attr.source = AUDIO_SOURCE_MIC;
4349 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
4350 audio_io_handle_t input1 = AUDIO_PORT_HANDLE_NONE;
4351 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input1, TEST_SESSION_ID, 1, &selectedDeviceId,
4352 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
4353 k48000SamplingRate));
4354
4355 EXPECT_EQ(1, mClient->getOpenInputCallsCount());
4356
4357 audio_io_handle_t input2 = AUDIO_PORT_HANDLE_NONE;
4358 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input2, TEST_SESSION_ID, 1, &selectedDeviceId,
4359 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
4360 k48000SamplingRate));
4361
4362 EXPECT_EQ(1, mClient->getOpenInputCallsCount());
4363 EXPECT_EQ(0, mClient->getCloseInputCallsCount());
4364 EXPECT_EQ(input1, input2);
4365 }
4366
TEST_F_WITH_FLAGS(AudioPolicyManagerInputPreemptionTest,LesserPriorityReusesInput,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (com::android::media::audioserver,fix_input_sharing_logic)))4367 TEST_F_WITH_FLAGS(
4368 AudioPolicyManagerInputPreemptionTest,
4369 LesserPriorityReusesInput,
4370 REQUIRES_FLAGS_ENABLED(
4371 ACONFIG_FLAG(com::android::media::audioserver, fix_input_sharing_logic))
4372 ) {
4373 mClient->resetInputApiCallsCounters();
4374
4375 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
4376 attr.source = AUDIO_SOURCE_MIC;
4377 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
4378 audio_io_handle_t input1 = AUDIO_PORT_HANDLE_NONE;
4379 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input1, TEST_SESSION_ID, 1, &selectedDeviceId,
4380 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
4381 k48000SamplingRate));
4382
4383 EXPECT_EQ(1, mClient->getOpenInputCallsCount());
4384
4385 audio_io_handle_t input2 = AUDIO_PORT_HANDLE_NONE;
4386 attr.source = AUDIO_SOURCE_VOICE_RECOGNITION;
4387 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input2, OTHER_SESSION_ID, 1, &selectedDeviceId,
4388 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
4389 k48000SamplingRate));
4390
4391 EXPECT_EQ(1, mClient->getOpenInputCallsCount());
4392 EXPECT_EQ(0, mClient->getCloseInputCallsCount());
4393 EXPECT_EQ(input1, input2);
4394 }
4395
TEST_F_WITH_FLAGS(AudioPolicyManagerInputPreemptionTest,HigherPriorityPreemptsInput,REQUIRES_FLAGS_ENABLED (ACONFIG_FLAG (com::android::media::audioserver,fix_input_sharing_logic)))4396 TEST_F_WITH_FLAGS(
4397 AudioPolicyManagerInputPreemptionTest,
4398 HigherPriorityPreemptsInput,
4399 REQUIRES_FLAGS_ENABLED(
4400 ACONFIG_FLAG(com::android::media::audioserver, fix_input_sharing_logic))
4401 ) {
4402 mClient->resetInputApiCallsCounters();
4403
4404 audio_attributes_t attr = AUDIO_ATTRIBUTES_INITIALIZER;
4405 attr.source = AUDIO_SOURCE_MIC;
4406 audio_port_handle_t selectedDeviceId = AUDIO_PORT_HANDLE_NONE;
4407 audio_io_handle_t input1 = AUDIO_PORT_HANDLE_NONE;
4408 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input1, TEST_SESSION_ID, 1, &selectedDeviceId,
4409 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
4410 k48000SamplingRate));
4411
4412 EXPECT_EQ(1, mClient->getOpenInputCallsCount());
4413
4414 audio_io_handle_t input2 = AUDIO_PORT_HANDLE_NONE;
4415 attr.source = AUDIO_SOURCE_CAMCORDER;
4416 ASSERT_NO_FATAL_FAILURE(getInputForAttr(attr, &input2, OTHER_SESSION_ID, 1, &selectedDeviceId,
4417 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_STEREO,
4418 k48000SamplingRate));
4419
4420 EXPECT_EQ(2, mClient->getOpenInputCallsCount());
4421 EXPECT_EQ(1, mClient->getCloseInputCallsCount());
4422 EXPECT_NE(input1, input2);
4423 }
4424
main(int argc,char ** argv)4425 int main(int argc, char** argv) {
4426 ::testing::InitGoogleTest(&argc, argv);
4427 ::testing::UnitTest::GetInstance()->listeners().Append(new TestExecutionTracer());
4428 return RUN_ALL_TESTS();
4429 }
4430