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 #define LOG_TAG "AAudioService"
18 //#define LOG_NDEBUG 0
19 #include <utils/Log.h>
20
21 #include <assert.h>
22 #include <map>
23 #include <mutex>
24
25 #include "AAudioEndpointManager.h"
26
27 using namespace android;
28 using namespace aaudio;
29
30 ANDROID_SINGLETON_STATIC_INSTANCE(AAudioEndpointManager);
31
AAudioEndpointManager()32 AAudioEndpointManager::AAudioEndpointManager()
33 : Singleton<AAudioEndpointManager>()
34 , mInputs()
35 , mOutputs() {
36 }
37
openEndpoint(AAudioService & audioService,int32_t deviceId,aaudio_direction_t direction)38 AAudioServiceEndpoint *AAudioEndpointManager::openEndpoint(AAudioService &audioService, int32_t deviceId,
39 aaudio_direction_t direction) {
40 AAudioServiceEndpoint *endpoint = nullptr;
41 std::lock_guard<std::mutex> lock(mLock);
42
43 // Try to find an existing endpoint.
44 switch (direction) {
45 case AAUDIO_DIRECTION_INPUT:
46 endpoint = mInputs[deviceId];
47 break;
48 case AAUDIO_DIRECTION_OUTPUT:
49 endpoint = mOutputs[deviceId];
50 break;
51 default:
52 assert(false); // There are only two possible directions.
53 break;
54 }
55 ALOGD("AAudioEndpointManager::openEndpoint(), found %p for device = %d, dir = %d",
56 endpoint, deviceId, (int)direction);
57
58 // If we can't find an existing one then open a new one.
59 if (endpoint == nullptr) {
60 if (direction == AAUDIO_DIRECTION_INPUT) {
61 AAudioServiceEndpointCapture *capture = new AAudioServiceEndpointCapture(audioService);
62 if (capture->open(deviceId) != AAUDIO_OK) {
63 ALOGE("AAudioEndpointManager::openEndpoint(), open failed");
64 delete capture;
65 } else {
66 mInputs[deviceId] = capture;
67 endpoint = capture;
68 }
69 } else if (direction == AAUDIO_DIRECTION_OUTPUT) {
70 AAudioServiceEndpointPlay *player = new AAudioServiceEndpointPlay(audioService);
71 if (player->open(deviceId) != AAUDIO_OK) {
72 ALOGE("AAudioEndpointManager::openEndpoint(), open failed");
73 delete player;
74 } else {
75 mOutputs[deviceId] = player;
76 endpoint = player;
77 }
78 }
79
80 }
81
82 if (endpoint != nullptr) {
83 // Increment the reference count under this lock.
84 endpoint->setReferenceCount(endpoint->getReferenceCount() + 1);
85 }
86 return endpoint;
87 }
88
closeEndpoint(AAudioServiceEndpoint * serviceEndpoint)89 void AAudioEndpointManager::closeEndpoint(AAudioServiceEndpoint *serviceEndpoint) {
90 std::lock_guard<std::mutex> lock(mLock);
91 if (serviceEndpoint == nullptr) {
92 return;
93 }
94
95 // Decrement the reference count under this lock.
96 int32_t newRefCount = serviceEndpoint->getReferenceCount() - 1;
97 serviceEndpoint->setReferenceCount(newRefCount);
98 if (newRefCount <= 0) {
99 aaudio_direction_t direction = serviceEndpoint->getDirection();
100 int32_t deviceId = serviceEndpoint->getDeviceId();
101
102 switch (direction) {
103 case AAUDIO_DIRECTION_INPUT:
104 mInputs.erase(deviceId);
105 break;
106 case AAUDIO_DIRECTION_OUTPUT:
107 mOutputs.erase(deviceId);
108 break;
109 }
110
111 serviceEndpoint->close();
112 delete serviceEndpoint;
113 }
114 }
115