1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <aaudio/AAudio.h>
18
19 #include "binding/AudioEndpointParcelable.h"
20 #include "binding/AAudioStreamRequest.h"
21 #include "binding/AAudioServiceDefinitions.h"
22 #include "binding/AAudioStreamConfiguration.h"
23 #include "binding/IAAudioService.h"
24 #include "utility/AAudioUtilities.h"
25
26 namespace android {
27
28 using aaudio::aaudio_handle_t;
29
30 /**
31 * This is used by the AAudio Client to talk to the AAudio Service.
32 *
33 * The order of parameters in the Parcels must match with code in AAudioService.cpp.
34 */
35 class BpAAudioService : public BpInterface<IAAudioService>
36 {
37 public:
BpAAudioService(const sp<IBinder> & impl)38 explicit BpAAudioService(const sp<IBinder>& impl)
39 : BpInterface<IAAudioService>(impl)
40 {
41 }
42
openStream(const aaudio::AAudioStreamRequest & request,aaudio::AAudioStreamConfiguration & configurationOutput)43 virtual aaudio_handle_t openStream(const aaudio::AAudioStreamRequest &request,
44 aaudio::AAudioStreamConfiguration &configurationOutput) override {
45 Parcel data, reply;
46 // send command
47 data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
48 ALOGV("BpAAudioService::client openStream --------------------");
49 // request.dump();
50 request.writeToParcel(&data);
51 status_t err = remote()->transact(OPEN_STREAM, data, &reply);
52 ALOGV("BpAAudioService::client openStream returned %d", err);
53 if (err != NO_ERROR) {
54 ALOGE("BpAAudioService::client openStream transact failed %d", err);
55 return AAudioConvert_androidToAAudioResult(err);
56 }
57 // parse reply
58 aaudio_handle_t stream;
59 err = reply.readInt32(&stream);
60 if (err != NO_ERROR) {
61 ALOGE("BpAAudioService::client transact(OPEN_STREAM) readInt %d", err);
62 return AAudioConvert_androidToAAudioResult(err);
63 } else if (stream < 0) {
64 ALOGE("BpAAudioService::client OPEN_STREAM passed stream %d", stream);
65 return stream;
66 }
67 err = configurationOutput.readFromParcel(&reply);
68 if (err != NO_ERROR) {
69 ALOGE("BpAAudioService::client openStream readFromParcel failed %d", err);
70 closeStream(stream);
71 return AAudioConvert_androidToAAudioResult(err);
72 }
73 return stream;
74 }
75
closeStream(aaudio_handle_t streamHandle)76 virtual aaudio_result_t closeStream(aaudio_handle_t streamHandle) override {
77 Parcel data, reply;
78 // send command
79 data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
80 data.writeInt32(streamHandle);
81 status_t err = remote()->transact(CLOSE_STREAM, data, &reply);
82 if (err != NO_ERROR) {
83 ALOGE("BpAAudioService::client closeStream transact failed %d", err);
84 return AAudioConvert_androidToAAudioResult(err);
85 }
86 // parse reply
87 aaudio_result_t res;
88 reply.readInt32(&res);
89 return res;
90 }
91
getStreamDescription(aaudio_handle_t streamHandle,aaudio::AudioEndpointParcelable & parcelable)92 virtual aaudio_result_t getStreamDescription(aaudio_handle_t streamHandle,
93 aaudio::AudioEndpointParcelable &parcelable) {
94 Parcel data, reply;
95 // send command
96 data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
97 data.writeInt32(streamHandle);
98 status_t err = remote()->transact(GET_STREAM_DESCRIPTION, data, &reply);
99 if (err != NO_ERROR) {
100 ALOGE("BpAAudioService::client transact(GET_STREAM_DESCRIPTION) returns %d", err);
101 return AAudioConvert_androidToAAudioResult(err);
102 }
103 // parse reply
104 aaudio_result_t result;
105 err = reply.readInt32(&result);
106 if (err != NO_ERROR) {
107 ALOGE("BpAAudioService::client transact(GET_STREAM_DESCRIPTION) readInt %d", err);
108 return AAudioConvert_androidToAAudioResult(err);
109 } else if (result != AAUDIO_OK) {
110 ALOGE("BpAAudioService::client GET_STREAM_DESCRIPTION passed result %d", result);
111 return result;
112 }
113 err = parcelable.readFromParcel(&reply);;
114 if (err != NO_ERROR) {
115 ALOGE("BpAAudioService::client transact(GET_STREAM_DESCRIPTION) read endpoint %d", err);
116 return AAudioConvert_androidToAAudioResult(err);
117 }
118 //parcelable.dump();
119 result = parcelable.validate();
120 if (result != AAUDIO_OK) {
121 ALOGE("BpAAudioService::client GET_STREAM_DESCRIPTION validation fails %d", result);
122 return result;
123 }
124 return result;
125 }
126
127 // TODO should we wait for a reply?
startStream(aaudio_handle_t streamHandle)128 virtual aaudio_result_t startStream(aaudio_handle_t streamHandle) override {
129 Parcel data, reply;
130 // send command
131 data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
132 data.writeInt32(streamHandle);
133 status_t err = remote()->transact(START_STREAM, data, &reply);
134 if (err != NO_ERROR) {
135 return AAudioConvert_androidToAAudioResult(err);
136 }
137 // parse reply
138 aaudio_result_t res;
139 reply.readInt32(&res);
140 return res;
141 }
142
pauseStream(aaudio_handle_t streamHandle)143 virtual aaudio_result_t pauseStream(aaudio_handle_t streamHandle) override {
144 Parcel data, reply;
145 // send command
146 data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
147 data.writeInt32(streamHandle);
148 status_t err = remote()->transact(PAUSE_STREAM, data, &reply);
149 if (err != NO_ERROR) {
150 return AAudioConvert_androidToAAudioResult(err);
151 }
152 // parse reply
153 aaudio_result_t res;
154 reply.readInt32(&res);
155 return res;
156 }
157
stopStream(aaudio_handle_t streamHandle)158 virtual aaudio_result_t stopStream(aaudio_handle_t streamHandle) override {
159 Parcel data, reply;
160 // send command
161 data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
162 data.writeInt32(streamHandle);
163 status_t err = remote()->transact(STOP_STREAM, data, &reply);
164 if (err != NO_ERROR) {
165 return AAudioConvert_androidToAAudioResult(err);
166 }
167 // parse reply
168 aaudio_result_t res;
169 reply.readInt32(&res);
170 return res;
171 }
172
flushStream(aaudio_handle_t streamHandle)173 virtual aaudio_result_t flushStream(aaudio_handle_t streamHandle) override {
174 Parcel data, reply;
175 // send command
176 data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
177 data.writeInt32(streamHandle);
178 status_t err = remote()->transact(FLUSH_STREAM, data, &reply);
179 if (err != NO_ERROR) {
180 return AAudioConvert_androidToAAudioResult(err);
181 }
182 // parse reply
183 aaudio_result_t res;
184 reply.readInt32(&res);
185 return res;
186 }
187
registerAudioThread(aaudio_handle_t streamHandle,pid_t clientProcessId,pid_t clientThreadId,int64_t periodNanoseconds)188 virtual aaudio_result_t registerAudioThread(aaudio_handle_t streamHandle,
189 pid_t clientProcessId,
190 pid_t clientThreadId,
191 int64_t periodNanoseconds)
192 override {
193 Parcel data, reply;
194 // send command
195 data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
196 data.writeInt32(streamHandle);
197 data.writeInt32((int32_t) clientProcessId);
198 data.writeInt32((int32_t) clientThreadId);
199 data.writeInt64(periodNanoseconds);
200 status_t err = remote()->transact(REGISTER_AUDIO_THREAD, data, &reply);
201 if (err != NO_ERROR) {
202 return AAudioConvert_androidToAAudioResult(err);
203 }
204 // parse reply
205 aaudio_result_t res;
206 reply.readInt32(&res);
207 return res;
208 }
209
unregisterAudioThread(aaudio_handle_t streamHandle,pid_t clientProcessId,pid_t clientThreadId)210 virtual aaudio_result_t unregisterAudioThread(aaudio_handle_t streamHandle,
211 pid_t clientProcessId,
212 pid_t clientThreadId)
213 override {
214 Parcel data, reply;
215 // send command
216 data.writeInterfaceToken(IAAudioService::getInterfaceDescriptor());
217 data.writeInt32(streamHandle);
218 data.writeInt32((int32_t) clientProcessId);
219 data.writeInt32((int32_t) clientThreadId);
220 status_t err = remote()->transact(UNREGISTER_AUDIO_THREAD, data, &reply);
221 if (err != NO_ERROR) {
222 return AAudioConvert_androidToAAudioResult(err);
223 }
224 // parse reply
225 aaudio_result_t res;
226 reply.readInt32(&res);
227 return res;
228 }
229
230 };
231
232 // Implement an interface to the service.
233 // This is here so that you don't have to link with libaaudio static library.
234 IMPLEMENT_META_INTERFACE(AAudioService, "IAAudioService");
235
236 // The order of parameters in the Parcels must match with code in BpAAudioService
237
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)238 status_t BnAAudioService::onTransact(uint32_t code, const Parcel& data,
239 Parcel* reply, uint32_t flags) {
240 aaudio_handle_t stream;
241 aaudio::AAudioStreamRequest request;
242 aaudio::AAudioStreamConfiguration configuration;
243 pid_t pid;
244 pid_t tid;
245 int64_t nanoseconds;
246 aaudio_result_t result;
247 ALOGV("BnAAudioService::onTransact(%i) %i", code, flags);
248 data.checkInterface(this);
249
250 switch(code) {
251 case OPEN_STREAM: {
252 request.readFromParcel(&data);
253
254 //ALOGD("BnAAudioService::client openStream request dump --------------------");
255 //request.dump();
256
257 stream = openStream(request, configuration);
258 //ALOGD("BnAAudioService::onTransact OPEN_STREAM server handle = 0x%08X", stream);
259 reply->writeInt32(stream);
260 configuration.writeToParcel(reply);
261 return NO_ERROR;
262 } break;
263
264 case CLOSE_STREAM: {
265 data.readInt32(&stream);
266 result = closeStream(stream);
267 //ALOGD("BnAAudioService::onTransact CLOSE_STREAM 0x%08X, result = %d",
268 // stream, result);
269 reply->writeInt32(result);
270 return NO_ERROR;
271 } break;
272
273 case GET_STREAM_DESCRIPTION: {
274 data.readInt32(&stream);
275 aaudio::AudioEndpointParcelable parcelable;
276 result = getStreamDescription(stream, parcelable);
277 if (result != AAUDIO_OK) {
278 return AAudioConvert_aaudioToAndroidStatus(result);
279 }
280 result = parcelable.validate();
281 if (result != AAUDIO_OK) {
282 ALOGE("BnAAudioService::onTransact getStreamDescription() returns %d", result);
283 parcelable.dump();
284 return AAudioConvert_aaudioToAndroidStatus(result);
285 }
286 reply->writeInt32(result);
287 parcelable.writeToParcel(reply);
288 return NO_ERROR;
289 } break;
290
291 case START_STREAM: {
292 data.readInt32(&stream);
293 result = startStream(stream);
294 ALOGV("BnAAudioService::onTransact START_STREAM 0x%08X, result = %d",
295 stream, result);
296 reply->writeInt32(result);
297 return NO_ERROR;
298 } break;
299
300 case PAUSE_STREAM: {
301 data.readInt32(&stream);
302 result = pauseStream(stream);
303 ALOGV("BnAAudioService::onTransact PAUSE_STREAM 0x%08X, result = %d",
304 stream, result);
305 reply->writeInt32(result);
306 return NO_ERROR;
307 } break;
308
309 case STOP_STREAM: {
310 data.readInt32(&stream);
311 result = stopStream(stream);
312 ALOGV("BnAAudioService::onTransact STOP_STREAM 0x%08X, result = %d",
313 stream, result);
314 reply->writeInt32(result);
315 return NO_ERROR;
316 } break;
317
318 case FLUSH_STREAM: {
319 data.readInt32(&stream);
320 result = flushStream(stream);
321 ALOGV("BnAAudioService::onTransact FLUSH_STREAM 0x%08X, result = %d",
322 stream, result);
323 reply->writeInt32(result);
324 return NO_ERROR;
325 } break;
326
327 case REGISTER_AUDIO_THREAD: {
328 data.readInt32(&stream);
329 data.readInt32(&pid);
330 data.readInt32(&tid);
331 data.readInt64(&nanoseconds);
332 result = registerAudioThread(stream, pid, tid, nanoseconds);
333 ALOGV("BnAAudioService::onTransact REGISTER_AUDIO_THREAD 0x%08X, result = %d",
334 stream, result);
335 reply->writeInt32(result);
336 return NO_ERROR;
337 } break;
338
339 case UNREGISTER_AUDIO_THREAD: {
340 data.readInt32(&stream);
341 data.readInt32(&pid);
342 data.readInt32(&tid);
343 result = unregisterAudioThread(stream, pid, tid);
344 ALOGV("BnAAudioService::onTransact UNREGISTER_AUDIO_THREAD 0x%08X, result = %d",
345 stream, result);
346 reply->writeInt32(result);
347 return NO_ERROR;
348 } break;
349
350 default:
351 // ALOGW("BnAAudioService::onTransact not handled %u", code);
352 return BBinder::onTransact(code, data, reply, flags);
353 }
354 }
355
356 } /* namespace android */
357