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 #define LOG_TAG "RIL_SAP"
18
19 #include <android/binder_manager.h>
20 #include <android/binder_process.h>
21
22 #pragma clang diagnostic push
23 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
24 #include <android/hardware/radio/1.1/ISap.h>
25 #include <libradiocompat/Sap.h>
26 #pragma clang diagnostic pop
27
28 #include <sap_service.h>
29 #include "pb_decode.h"
30 #include "pb_encode.h"
31
32 using namespace android::hardware::radio::V1_0;
33 using ::android::hardware::Return;
34 using ::android::hardware::hidl_vec;
35 using ::android::hardware::hidl_array;
36 using ::android::hardware::Void;
37 using android::CommandInfo;
38 using android::RequestInfo;
39 using android::requestToString;
40 using android::sp;
41
42 struct SapImpl;
43
44 #if (SIM_COUNT >= 2)
45 sp<SapImpl> sapService[SIM_COUNT];
46 #else
47 sp<SapImpl> sapService[1];
48 #endif
49
50 struct SapImpl : public android::hardware::radio::V1_1::ISap {
51 int32_t slotId;
52 sp<ISapCallback> sapCallback;
53 RIL_SOCKET_ID rilSocketId;
54
55 Return<void> setCallback(const ::android::sp<ISapCallback>& sapCallbackParam);
56
57 Return<void> connectReq(int32_t token, int32_t maxMsgSize);
58
59 Return<void> disconnectReq(int32_t token);
60
61 Return<void> apduReq(int32_t token, SapApduType type, const hidl_vec<uint8_t>& command);
62
63 Return<void> transferAtrReq(int32_t token);
64
65 Return<void> powerReq(int32_t token, bool state);
66
67 Return<void> resetSimReq(int32_t token);
68
69 Return<void> transferCardReaderStatusReq(int32_t token);
70
71 Return<void> setTransferProtocolReq(int32_t token, SapTransferProtocol transferProtocol);
72
73 MsgHeader* createMsgHeader(MsgId msgId, int32_t token);
74
75 Return<void> addPayloadAndDispatchRequest(MsgHeader *msg, uint16_t reqLen, uint8_t *reqPtr);
76
77 void sendFailedResponse(MsgId msgId, int32_t token, int numPointers, ...);
78
79 void checkReturnStatus(Return<void>& ret);
80 };
81
checkReturnStatus(Return<void> & ret)82 void SapImpl::checkReturnStatus(Return<void>& ret) {
83 if (ret.isOk() == false) {
84 RLOGE("checkReturnStatus: unable to call response/indication callback: %s",
85 ret.description().c_str());
86 // Remote process (SapRilReceiver.java) hosting the callback must be dead. Reset the
87 // callback object; there's no other recovery to be done here. When the client process is
88 // back up, it will call setCallback()
89 sapCallback = NULL;
90 }
91 }
92
setCallback(const::android::sp<ISapCallback> & sapCallbackParam)93 Return<void> SapImpl::setCallback(const ::android::sp<ISapCallback>& sapCallbackParam) {
94 RLOGD("SapImpl::setCallback for slotId %d", slotId);
95 sapCallback = sapCallbackParam;
96 return Void();
97 }
98
createMsgHeader(MsgId msgId,int32_t token)99 MsgHeader* SapImpl::createMsgHeader(MsgId msgId, int32_t token) {
100 // Memory for msg will be freed by RilSapSocket::onRequestComplete()
101 MsgHeader *msg = (MsgHeader *)calloc(1, sizeof(MsgHeader));
102 if (msg == NULL) {
103 return NULL;
104 }
105 msg->token = token;
106 msg->type = MsgType_REQUEST;
107 msg->id = msgId;
108 msg->error = Error_RIL_E_SUCCESS;
109 return msg;
110 }
111
addPayloadAndDispatchRequest(MsgHeader * msg,uint16_t reqLen,uint8_t * reqPtr)112 Return<void> SapImpl::addPayloadAndDispatchRequest(MsgHeader *msg, uint16_t reqLen,
113 uint8_t *reqPtr) {
114 pb_bytes_array_t *payload = (pb_bytes_array_t *) malloc(sizeof(pb_bytes_array_t) - 1 + reqLen);
115 if (payload == NULL) {
116 sendFailedResponse(msg->id, msg->token, 2, reqPtr, msg);
117 return Void();
118 }
119
120 msg->payload = payload;
121 msg->payload->size = reqLen;
122 memcpy(msg->payload->bytes, reqPtr, reqLen);
123
124 RilSapSocket *sapSocket = RilSapSocket::getSocketById(rilSocketId);
125 if (sapSocket) {
126 RLOGD("SapImpl::addPayloadAndDispatchRequest: calling dispatchRequest");
127 sapSocket->dispatchRequest(msg);
128 } else {
129 RLOGE("SapImpl::addPayloadAndDispatchRequest: sapSocket is null");
130 sendFailedResponse(msg->id, msg->token, 3, payload, reqPtr, msg);
131 return Void();
132 }
133 free(msg->payload);
134 free(reqPtr);
135 return Void();
136 }
137
sendFailedResponse(MsgId msgId,int32_t token,int numPointers,...)138 void SapImpl::sendFailedResponse(MsgId msgId, int32_t token, int numPointers, ...) {
139 va_list ap;
140 va_start(ap, numPointers);
141 for (int i = 0; i < numPointers; i++) {
142 void *ptr = va_arg(ap, void *);
143 if (ptr) free(ptr);
144 }
145 va_end(ap);
146 Return<void> retStatus;
147
148 if (sapCallback == NULL) {
149 RLOGE("sendFailedResponse: sapCallback == NULL; msgId = %d; token = %d", msgId, token);
150 return;
151 }
152
153 switch(msgId) {
154 case MsgId_RIL_SIM_SAP_CONNECT:
155 retStatus = sapCallback->connectResponse(token, SapConnectRsp::CONNECT_FAILURE, 0);
156 break;
157
158 case MsgId_RIL_SIM_SAP_DISCONNECT:
159 retStatus = sapCallback->disconnectResponse(token);
160 break;
161
162 case MsgId_RIL_SIM_SAP_APDU: {
163 hidl_vec<uint8_t> apduRsp;
164 retStatus = sapCallback->apduResponse(token, SapResultCode::GENERIC_FAILURE, apduRsp);
165 break;
166 }
167
168 case MsgId_RIL_SIM_SAP_TRANSFER_ATR: {
169 hidl_vec<uint8_t> atr;
170 retStatus = sapCallback->transferAtrResponse(token, SapResultCode::GENERIC_FAILURE,
171 atr);
172 break;
173 }
174
175 case MsgId_RIL_SIM_SAP_POWER:
176 retStatus = sapCallback->powerResponse(token, SapResultCode::GENERIC_FAILURE);
177 break;
178
179 case MsgId_RIL_SIM_SAP_RESET_SIM:
180 retStatus = sapCallback->resetSimResponse(token, SapResultCode::GENERIC_FAILURE);
181 break;
182
183 case MsgId_RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS:
184 retStatus = sapCallback->transferCardReaderStatusResponse(token,
185 SapResultCode::GENERIC_FAILURE, 0);
186 break;
187
188 case MsgId_RIL_SIM_SAP_SET_TRANSFER_PROTOCOL:
189 retStatus = sapCallback->transferProtocolResponse(token, SapResultCode::NOT_SUPPORTED);
190 break;
191
192 default:
193 return;
194 }
195 sapService[slotId]->checkReturnStatus(retStatus);
196 }
197
connectReq(int32_t token,int32_t maxMsgSize)198 Return<void> SapImpl::connectReq(int32_t token, int32_t maxMsgSize) {
199 RLOGD("SapImpl::connectReq");
200 MsgHeader *msg = createMsgHeader(MsgId_RIL_SIM_SAP_CONNECT, token);
201 if (msg == NULL) {
202 RLOGE("SapImpl::connectReq: Error allocating memory for msg");
203 sendFailedResponse(MsgId_RIL_SIM_SAP_CONNECT, token, 0);
204 return Void();
205 }
206
207 /***** Encode RIL_SIM_SAP_CONNECT_REQ *****/
208 RIL_SIM_SAP_CONNECT_REQ req;
209 memset(&req, 0, sizeof(RIL_SIM_SAP_CONNECT_REQ));
210 req.max_message_size = maxMsgSize;
211
212 size_t encodedSize = 0;
213 if (!pb_get_encoded_size(&encodedSize, RIL_SIM_SAP_CONNECT_REQ_fields, &req)) {
214 RLOGE("SapImpl::connectReq: Error getting encoded size for RIL_SIM_SAP_CONNECT_REQ");
215 sendFailedResponse(MsgId_RIL_SIM_SAP_CONNECT, token, 1, msg);
216 return Void();
217 }
218
219 uint8_t *buffer = (uint8_t *)calloc(1, encodedSize);
220 if (buffer == NULL) {
221 RLOGE("SapImpl::connectReq: Error allocating memory for buffer");
222 sendFailedResponse(MsgId_RIL_SIM_SAP_CONNECT, token, 1, msg);
223 return Void();
224 }
225 pb_ostream_t stream = pb_ostream_from_buffer(buffer, encodedSize);
226
227 RLOGD("SapImpl::connectReq calling pb_encode");
228 if (!pb_encode(&stream, RIL_SIM_SAP_CONNECT_REQ_fields, &req)) {
229 RLOGE("SapImpl::connectReq: Error encoding RIL_SIM_SAP_CONNECT_REQ");
230 sendFailedResponse(MsgId_RIL_SIM_SAP_CONNECT, token, 2, buffer, msg);
231 return Void();
232 }
233 /***** Encode RIL_SIM_SAP_CONNECT_REQ done *****/
234
235 /* encoded req is payload */
236 return addPayloadAndDispatchRequest(msg, stream.bytes_written, buffer);
237 }
238
disconnectReq(int32_t token)239 Return<void> SapImpl::disconnectReq(int32_t token) {
240 RLOGD("SapImpl::disconnectReq");
241 MsgHeader *msg = createMsgHeader(MsgId_RIL_SIM_SAP_DISCONNECT, token);
242 if (msg == NULL) {
243 RLOGE("SapImpl::disconnectReq: Error allocating memory for msg");
244 sendFailedResponse(MsgId_RIL_SIM_SAP_DISCONNECT, token, 0);
245 return Void();
246 }
247
248 /***** Encode RIL_SIM_SAP_DISCONNECT_REQ *****/
249 RIL_SIM_SAP_DISCONNECT_REQ req;
250 memset(&req, 0, sizeof(RIL_SIM_SAP_DISCONNECT_REQ));
251
252 size_t encodedSize = 0;
253 if (!pb_get_encoded_size(&encodedSize, RIL_SIM_SAP_DISCONNECT_REQ_fields, &req)) {
254 RLOGE("SapImpl::disconnectReq: Error getting encoded size for RIL_SIM_SAP_DISCONNECT_REQ");
255 sendFailedResponse(MsgId_RIL_SIM_SAP_DISCONNECT, token, 1, msg);
256 return Void();
257 }
258
259 uint8_t *buffer = (uint8_t *)calloc(1, encodedSize);
260 if (buffer == NULL) {
261 RLOGE("SapImpl::disconnectReq: Error allocating memory for buffer");
262 sendFailedResponse(MsgId_RIL_SIM_SAP_DISCONNECT, token, 1, msg);
263 return Void();
264 }
265
266 pb_ostream_t stream = pb_ostream_from_buffer(buffer, encodedSize);
267
268 RLOGD("SapImpl::disconnectReq calling pb_encode");
269 if (!pb_encode(&stream, RIL_SIM_SAP_DISCONNECT_REQ_fields, &req)) {
270 RLOGE("SapImpl::disconnectReq: Error encoding RIL_SIM_SAP_DISCONNECT_REQ");
271 sendFailedResponse(MsgId_RIL_SIM_SAP_DISCONNECT, token, 2, buffer, msg);
272 return Void();
273 }
274 /***** Encode RIL_SIM_SAP_DISCONNECT_REQ done *****/
275
276 /* encoded req is payload */
277 return addPayloadAndDispatchRequest(msg, stream.bytes_written, buffer);
278 }
279
apduReq(int32_t token,SapApduType type,const hidl_vec<uint8_t> & command)280 Return<void> SapImpl::apduReq(int32_t token, SapApduType type, const hidl_vec<uint8_t>& command) {
281 RLOGD("SapImpl::apduReq");
282 MsgHeader *msg = createMsgHeader(MsgId_RIL_SIM_SAP_APDU, token);
283 if (msg == NULL) {
284 RLOGE("SapImpl::apduReq: Error allocating memory for msg");
285 sendFailedResponse(MsgId_RIL_SIM_SAP_APDU, token, 0);
286 return Void();
287 }
288
289 /***** Encode RIL_SIM_SAP_APDU_REQ *****/
290 RIL_SIM_SAP_APDU_REQ req;
291 memset(&req, 0, sizeof(RIL_SIM_SAP_APDU_REQ));
292 req.type = (RIL_SIM_SAP_APDU_REQ_Type)type;
293
294 if (command.size() > 0) {
295 req.command = (pb_bytes_array_t *)malloc(sizeof(pb_bytes_array_t) - 1 + command.size());
296 if (req.command == NULL) {
297 RLOGE("SapImpl::apduReq: Error allocating memory for req.command");
298 sendFailedResponse(MsgId_RIL_SIM_SAP_APDU, token, 1, msg);
299 return Void();
300 }
301 req.command->size = command.size();
302 memcpy(req.command->bytes, command.data(), command.size());
303 }
304
305 size_t encodedSize = 0;
306 if (!pb_get_encoded_size(&encodedSize, RIL_SIM_SAP_APDU_REQ_fields, &req)) {
307 RLOGE("SapImpl::apduReq: Error getting encoded size for RIL_SIM_SAP_APDU_REQ");
308 sendFailedResponse(MsgId_RIL_SIM_SAP_APDU, token, 2, req.command, msg);
309 return Void();
310 }
311
312 uint8_t *buffer = (uint8_t *)calloc(1, encodedSize);
313 if (buffer == NULL) {
314 RLOGE("SapImpl::apduReq: Error allocating memory for buffer");
315 sendFailedResponse(MsgId_RIL_SIM_SAP_APDU, token, 2, req.command, msg);
316 return Void();
317 }
318
319 pb_ostream_t stream = pb_ostream_from_buffer(buffer, encodedSize);
320
321 RLOGD("SapImpl::apduReq calling pb_encode");
322 if (!pb_encode(&stream, RIL_SIM_SAP_APDU_REQ_fields, &req)) {
323 RLOGE("SapImpl::apduReq: Error encoding RIL_SIM_SAP_APDU_REQ");
324 sendFailedResponse(MsgId_RIL_SIM_SAP_APDU, token, 3, req.command, buffer, msg);
325 return Void();
326 }
327 /***** Encode RIL_SIM_SAP_APDU_REQ done *****/
328
329 /* encoded req is payload */
330 return addPayloadAndDispatchRequest(msg, stream.bytes_written, buffer);
331 }
332
transferAtrReq(int32_t token)333 Return<void> SapImpl::transferAtrReq(int32_t token) {
334 RLOGD("SapImpl::transferAtrReq");
335 MsgHeader *msg = createMsgHeader(MsgId_RIL_SIM_SAP_TRANSFER_ATR, token);
336 if (msg == NULL) {
337 RLOGE("SapImpl::transferAtrReq: Error allocating memory for msg");
338 sendFailedResponse(MsgId_RIL_SIM_SAP_TRANSFER_ATR, token, 0);
339 return Void();
340 }
341
342 /***** Encode RIL_SIM_SAP_TRANSFER_ATR_REQ *****/
343 RIL_SIM_SAP_TRANSFER_ATR_REQ req;
344 memset(&req, 0, sizeof(RIL_SIM_SAP_TRANSFER_ATR_REQ));
345
346 size_t encodedSize = 0;
347 if (!pb_get_encoded_size(&encodedSize, RIL_SIM_SAP_TRANSFER_ATR_REQ_fields, &req)) {
348 RLOGE("SapImpl::transferAtrReq: Error getting encoded size for "
349 "RIL_SIM_SAP_TRANSFER_ATR_REQ");
350 sendFailedResponse(MsgId_RIL_SIM_SAP_TRANSFER_ATR, token, 1, msg);
351 return Void();
352 }
353
354 uint8_t *buffer = (uint8_t *)calloc(1, encodedSize);
355 if (buffer == NULL) {
356 RLOGE("SapImpl::transferAtrReq: Error allocating memory for buffer");
357 sendFailedResponse(MsgId_RIL_SIM_SAP_TRANSFER_ATR, token, 1, msg);
358 return Void();
359 }
360
361 pb_ostream_t stream = pb_ostream_from_buffer(buffer, encodedSize);
362
363 RLOGD("SapImpl::transferAtrReq calling pb_encode");
364 if (!pb_encode(&stream, RIL_SIM_SAP_TRANSFER_ATR_REQ_fields, &req)) {
365 RLOGE("SapImpl::transferAtrReq: Error encoding RIL_SIM_SAP_TRANSFER_ATR_REQ");
366 sendFailedResponse(MsgId_RIL_SIM_SAP_TRANSFER_ATR, token, 2, buffer, msg);
367 return Void();
368 }
369 /***** Encode RIL_SIM_SAP_TRANSFER_ATR_REQ done *****/
370
371 /* encoded req is payload */
372 return addPayloadAndDispatchRequest(msg, stream.bytes_written, buffer);
373 }
374
powerReq(int32_t token,bool state)375 Return<void> SapImpl::powerReq(int32_t token, bool state) {
376 RLOGD("SapImpl::powerReq");
377 MsgHeader *msg = createMsgHeader(MsgId_RIL_SIM_SAP_POWER, token);
378 if (msg == NULL) {
379 RLOGE("SapImpl::powerReq: Error allocating memory for msg");
380 sendFailedResponse(MsgId_RIL_SIM_SAP_POWER, token, 0);
381 return Void();
382 }
383
384 /***** Encode RIL_SIM_SAP_POWER_REQ *****/
385 RIL_SIM_SAP_POWER_REQ req;
386 memset(&req, 0, sizeof(RIL_SIM_SAP_POWER_REQ));
387 req.state = state;
388
389 size_t encodedSize = 0;
390 if (!pb_get_encoded_size(&encodedSize, RIL_SIM_SAP_POWER_REQ_fields, &req)) {
391 RLOGE("SapImpl::powerReq: Error getting encoded size for RIL_SIM_SAP_POWER_REQ");
392 sendFailedResponse(MsgId_RIL_SIM_SAP_POWER, token, 1, msg);
393 return Void();
394 }
395
396 uint8_t *buffer = (uint8_t *)calloc(1, encodedSize);
397 if (buffer == NULL) {
398 RLOGE("SapImpl::powerReq: Error allocating memory for buffer");
399 sendFailedResponse(MsgId_RIL_SIM_SAP_POWER, token, 1, msg);
400 return Void();
401 }
402
403 pb_ostream_t stream = pb_ostream_from_buffer(buffer, encodedSize);
404
405 RLOGD("SapImpl::powerReq calling pb_encode");
406 if (!pb_encode(&stream, RIL_SIM_SAP_POWER_REQ_fields, &req)) {
407 RLOGE("SapImpl::powerReq: Error encoding RIL_SIM_SAP_POWER_REQ");
408 sendFailedResponse(MsgId_RIL_SIM_SAP_POWER, token, 2, buffer, msg);
409 return Void();
410 }
411 /***** Encode RIL_SIM_SAP_POWER_REQ done *****/
412
413 /* encoded req is payload */
414 return addPayloadAndDispatchRequest(msg, stream.bytes_written, buffer);
415 }
416
resetSimReq(int32_t token)417 Return<void> SapImpl::resetSimReq(int32_t token) {
418 RLOGD("SapImpl::resetSimReq");
419 MsgHeader *msg = createMsgHeader(MsgId_RIL_SIM_SAP_RESET_SIM, token);
420 if (msg == NULL) {
421 RLOGE("SapImpl::resetSimReq: Error allocating memory for msg");
422 sendFailedResponse(MsgId_RIL_SIM_SAP_RESET_SIM, token, 0);
423 return Void();
424 }
425
426 /***** Encode RIL_SIM_SAP_RESET_SIM_REQ *****/
427 RIL_SIM_SAP_RESET_SIM_REQ req;
428 memset(&req, 0, sizeof(RIL_SIM_SAP_RESET_SIM_REQ));
429
430 size_t encodedSize = 0;
431 if (!pb_get_encoded_size(&encodedSize, RIL_SIM_SAP_RESET_SIM_REQ_fields, &req)) {
432 RLOGE("SapImpl::resetSimReq: Error getting encoded size for RIL_SIM_SAP_RESET_SIM_REQ");
433 sendFailedResponse(MsgId_RIL_SIM_SAP_RESET_SIM, token, 1, msg);
434 return Void();
435 }
436
437 uint8_t *buffer = (uint8_t *)calloc(1, encodedSize);
438 if (buffer == NULL) {
439 RLOGE("SapImpl::resetSimReq: Error allocating memory for buffer");
440 sendFailedResponse(MsgId_RIL_SIM_SAP_RESET_SIM, token, 1, msg);
441 return Void();
442 }
443
444 pb_ostream_t stream = pb_ostream_from_buffer(buffer, encodedSize);
445
446 RLOGD("SapImpl::resetSimReq calling pb_encode");
447 if (!pb_encode(&stream, RIL_SIM_SAP_RESET_SIM_REQ_fields, &req)) {
448 RLOGE("SapImpl::resetSimReq: Error encoding RIL_SIM_SAP_RESET_SIM_REQ");
449 sendFailedResponse(MsgId_RIL_SIM_SAP_RESET_SIM, token, 2, buffer, msg);
450 return Void();
451 }
452 /***** Encode RIL_SIM_SAP_RESET_SIM_REQ done *****/
453
454 /* encoded req is payload */
455 return addPayloadAndDispatchRequest(msg, stream.bytes_written, buffer);
456 }
457
transferCardReaderStatusReq(int32_t token)458 Return<void> SapImpl::transferCardReaderStatusReq(int32_t token) {
459 RLOGD("SapImpl::transferCardReaderStatusReq");
460 MsgHeader *msg = createMsgHeader(MsgId_RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS, token);
461 if (msg == NULL) {
462 RLOGE("SapImpl::transferCardReaderStatusReq: Error allocating memory for msg");
463 sendFailedResponse(MsgId_RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS, token, 0);
464 return Void();
465 }
466
467 /***** Encode RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_REQ *****/
468 RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_REQ req;
469 memset(&req, 0, sizeof(RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_REQ));
470
471 size_t encodedSize = 0;
472 if (!pb_get_encoded_size(&encodedSize, RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_REQ_fields,
473 &req)) {
474 RLOGE("SapImpl::transferCardReaderStatusReq: Error getting encoded size for "
475 "RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_REQ");
476 sendFailedResponse(MsgId_RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS, token, 1, msg);
477 return Void();
478 }
479
480 uint8_t *buffer = (uint8_t *)calloc(1, encodedSize);
481 if (buffer == NULL) {
482 RLOGE("SapImpl::transferCardReaderStatusReq: Error allocating memory for buffer");
483 sendFailedResponse(MsgId_RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS, token, 1, msg);
484 return Void();
485 }
486
487 pb_ostream_t stream = pb_ostream_from_buffer(buffer, encodedSize);
488
489 RLOGD("SapImpl::transferCardReaderStatusReq calling pb_encode");
490 if (!pb_encode(&stream, RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_REQ_fields, &req)) {
491 RLOGE("SapImpl::transferCardReaderStatusReq: Error encoding "
492 "RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_REQ");
493 sendFailedResponse(MsgId_RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS, token, 2, buffer, msg);
494 return Void();
495 }
496 /***** Encode RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_REQ done *****/
497
498 /* encoded req is payload */
499 return addPayloadAndDispatchRequest(msg, stream.bytes_written, buffer);
500 }
501
setTransferProtocolReq(int32_t token,SapTransferProtocol transferProtocol)502 Return<void> SapImpl::setTransferProtocolReq(int32_t token, SapTransferProtocol transferProtocol) {
503 RLOGD("SapImpl::setTransferProtocolReq");
504 MsgHeader *msg = createMsgHeader(MsgId_RIL_SIM_SAP_SET_TRANSFER_PROTOCOL, token);
505 if (msg == NULL) {
506 RLOGE("SapImpl::setTransferProtocolReq: Error allocating memory for msg");
507 sendFailedResponse(MsgId_RIL_SIM_SAP_SET_TRANSFER_PROTOCOL, token, 0);
508 return Void();
509 }
510
511 /***** Encode RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_REQ *****/
512 RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_REQ req;
513 memset(&req, 0, sizeof(RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_REQ));
514 req.protocol = (RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_REQ_Protocol)transferProtocol;
515
516 size_t encodedSize = 0;
517 if (!pb_get_encoded_size(&encodedSize, RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_REQ_fields, &req)) {
518 RLOGE("SapImpl::setTransferProtocolReq: Error getting encoded size for "
519 "RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_REQ");
520 sendFailedResponse(MsgId_RIL_SIM_SAP_SET_TRANSFER_PROTOCOL, token, 1, msg);
521 return Void();
522 }
523
524 uint8_t *buffer = (uint8_t *)calloc(1, encodedSize);
525 if (buffer == NULL) {
526 RLOGE("SapImpl::setTransferProtocolReq: Error allocating memory for buffer");
527 sendFailedResponse(MsgId_RIL_SIM_SAP_SET_TRANSFER_PROTOCOL, token, 1, msg);
528 return Void();
529 }
530
531 pb_ostream_t stream = pb_ostream_from_buffer(buffer, encodedSize);
532
533 RLOGD("SapImpl::setTransferProtocolReq calling pb_encode");
534 if (!pb_encode(&stream, RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_REQ_fields, &req)) {
535 RLOGE("SapImpl::setTransferProtocolReq: Error encoding "
536 "RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_REQ");
537 sendFailedResponse(MsgId_RIL_SIM_SAP_SET_TRANSFER_PROTOCOL, token, 2, buffer, msg);
538 return Void();
539 }
540 /***** Encode RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_REQ done *****/
541
542 /* encoded req is payload */
543 return addPayloadAndDispatchRequest(msg, stream.bytes_written, buffer);
544 }
545
sapDecodeMessage(MsgId msgId,MsgType msgType,uint8_t * payloadPtr,size_t payloadLen)546 void *sapDecodeMessage(MsgId msgId, MsgType msgType, uint8_t *payloadPtr, size_t payloadLen) {
547 void *responsePtr = NULL;
548 pb_istream_t stream;
549
550 /* Create the stream */
551 stream = pb_istream_from_buffer((uint8_t *)payloadPtr, payloadLen);
552
553 /* Decode based on the message id */
554 switch (msgId)
555 {
556 case MsgId_RIL_SIM_SAP_CONNECT:
557 responsePtr = malloc(sizeof(RIL_SIM_SAP_CONNECT_RSP));
558 if (responsePtr) {
559 if (!pb_decode(&stream, RIL_SIM_SAP_CONNECT_RSP_fields, responsePtr)) {
560 RLOGE("Error decoding RIL_SIM_SAP_CONNECT_RSP");
561 return NULL;
562 }
563 }
564 break;
565
566 case MsgId_RIL_SIM_SAP_DISCONNECT:
567 if (msgType == MsgType_RESPONSE) {
568 responsePtr = malloc(sizeof(RIL_SIM_SAP_DISCONNECT_RSP));
569 if (responsePtr) {
570 if (!pb_decode(&stream, RIL_SIM_SAP_DISCONNECT_RSP_fields, responsePtr)) {
571 RLOGE("Error decoding RIL_SIM_SAP_DISCONNECT_RSP");
572 return NULL;
573 }
574 }
575 } else {
576 responsePtr = malloc(sizeof(RIL_SIM_SAP_DISCONNECT_IND));
577 if (responsePtr) {
578 if (!pb_decode(&stream, RIL_SIM_SAP_DISCONNECT_IND_fields, responsePtr)) {
579 RLOGE("Error decoding RIL_SIM_SAP_DISCONNECT_IND");
580 return NULL;
581 }
582 }
583 }
584 break;
585
586 case MsgId_RIL_SIM_SAP_APDU:
587 responsePtr = malloc(sizeof(RIL_SIM_SAP_APDU_RSP));
588 if (responsePtr) {
589 if (!pb_decode(&stream, RIL_SIM_SAP_APDU_RSP_fields, responsePtr)) {
590 RLOGE("Error decoding RIL_SIM_SAP_APDU_RSP");
591 return NULL;
592 }
593 }
594 break;
595
596 case MsgId_RIL_SIM_SAP_TRANSFER_ATR:
597 responsePtr = malloc(sizeof(RIL_SIM_SAP_TRANSFER_ATR_RSP));
598 if (responsePtr) {
599 if (!pb_decode(&stream, RIL_SIM_SAP_TRANSFER_ATR_RSP_fields, responsePtr)) {
600 RLOGE("Error decoding RIL_SIM_SAP_TRANSFER_ATR_RSP");
601 return NULL;
602 }
603 }
604 break;
605
606 case MsgId_RIL_SIM_SAP_POWER:
607 responsePtr = malloc(sizeof(RIL_SIM_SAP_POWER_RSP));
608 if (responsePtr) {
609 if (!pb_decode(&stream, RIL_SIM_SAP_POWER_RSP_fields, responsePtr)) {
610 RLOGE("Error decoding RIL_SIM_SAP_POWER_RSP");
611 return NULL;
612 }
613 }
614 break;
615
616 case MsgId_RIL_SIM_SAP_RESET_SIM:
617 responsePtr = malloc(sizeof(RIL_SIM_SAP_RESET_SIM_RSP));
618 if (responsePtr) {
619 if (!pb_decode(&stream, RIL_SIM_SAP_RESET_SIM_RSP_fields, responsePtr)) {
620 RLOGE("Error decoding RIL_SIM_SAP_RESET_SIM_RSP");
621 return NULL;
622 }
623 }
624 break;
625
626 case MsgId_RIL_SIM_SAP_STATUS:
627 responsePtr = malloc(sizeof(RIL_SIM_SAP_STATUS_IND));
628 if (responsePtr) {
629 if (!pb_decode(&stream, RIL_SIM_SAP_STATUS_IND_fields, responsePtr)) {
630 RLOGE("Error decoding RIL_SIM_SAP_STATUS_IND");
631 return NULL;
632 }
633 }
634 break;
635
636 case MsgId_RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS:
637 responsePtr = malloc(sizeof(RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP));
638 if (responsePtr) {
639 if (!pb_decode(&stream, RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP_fields,
640 responsePtr)) {
641 RLOGE("Error decoding RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP");
642 return NULL;
643 }
644 }
645 break;
646
647 case MsgId_RIL_SIM_SAP_ERROR_RESP:
648 responsePtr = malloc(sizeof(RIL_SIM_SAP_ERROR_RSP));
649 if (responsePtr) {
650 if (!pb_decode(&stream, RIL_SIM_SAP_ERROR_RSP_fields, responsePtr)) {
651 RLOGE("Error decoding RIL_SIM_SAP_ERROR_RSP");
652 return NULL;
653 }
654 }
655 break;
656
657 case MsgId_RIL_SIM_SAP_SET_TRANSFER_PROTOCOL:
658 responsePtr = malloc(sizeof(RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_RSP));
659 if (responsePtr) {
660 if (!pb_decode(&stream, RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_RSP_fields,
661 responsePtr)) {
662 RLOGE("Error decoding RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_RSP");
663 return NULL;
664 }
665 }
666 break;
667
668 default:
669 break;
670 }
671 return responsePtr;
672 } /* sapDecodeMessage */
673
getSapImpl(RilSapSocket * sapSocket)674 sp<SapImpl> getSapImpl(RilSapSocket *sapSocket) {
675 switch (sapSocket->getSocketId()) {
676 case RIL_SOCKET_1:
677 RLOGD("getSapImpl: returning sapService[0]");
678 return sapService[0];
679 #if (SIM_COUNT >= 2)
680 case RIL_SOCKET_2:
681 return sapService[1];
682 #if (SIM_COUNT >= 3)
683 case RIL_SOCKET_3:
684 return sapService[2];
685 #if (SIM_COUNT >= 4)
686 case RIL_SOCKET_4:
687 return sapService[3];
688 #endif
689 #endif
690 #endif
691 default:
692 return NULL;
693 }
694 }
695
convertApduResponseProtoToHal(RIL_SIM_SAP_APDU_RSP_Response responseProto)696 SapResultCode convertApduResponseProtoToHal(RIL_SIM_SAP_APDU_RSP_Response responseProto) {
697 switch(responseProto) {
698 case RIL_SIM_SAP_APDU_RSP_Response_RIL_E_SUCCESS:
699 return SapResultCode::SUCCESS;
700 case RIL_SIM_SAP_APDU_RSP_Response_RIL_E_GENERIC_FAILURE:
701 return SapResultCode::GENERIC_FAILURE;
702 case RIL_SIM_SAP_APDU_RSP_Response_RIL_E_SIM_NOT_READY:
703 return SapResultCode::CARD_NOT_ACCESSSIBLE;
704 case RIL_SIM_SAP_APDU_RSP_Response_RIL_E_SIM_ALREADY_POWERED_OFF:
705 return SapResultCode::CARD_ALREADY_POWERED_OFF;
706 case RIL_SIM_SAP_APDU_RSP_Response_RIL_E_SIM_ABSENT:
707 return SapResultCode::CARD_REMOVED;
708 default:
709 return SapResultCode::GENERIC_FAILURE;
710 }
711 }
712
convertTransferAtrResponseProtoToHal(RIL_SIM_SAP_TRANSFER_ATR_RSP_Response responseProto)713 SapResultCode convertTransferAtrResponseProtoToHal(
714 RIL_SIM_SAP_TRANSFER_ATR_RSP_Response responseProto) {
715 switch(responseProto) {
716 case RIL_SIM_SAP_TRANSFER_ATR_RSP_Response_RIL_E_SUCCESS:
717 return SapResultCode::SUCCESS;
718 case RIL_SIM_SAP_TRANSFER_ATR_RSP_Response_RIL_E_GENERIC_FAILURE:
719 return SapResultCode::GENERIC_FAILURE;
720 case RIL_SIM_SAP_TRANSFER_ATR_RSP_Response_RIL_E_SIM_ALREADY_POWERED_OFF:
721 return SapResultCode::CARD_ALREADY_POWERED_OFF;
722 case RIL_SIM_SAP_TRANSFER_ATR_RSP_Response_RIL_E_SIM_ABSENT:
723 return SapResultCode::CARD_REMOVED;
724 case RIL_SIM_SAP_TRANSFER_ATR_RSP_Response_RIL_E_SIM_DATA_NOT_AVAILABLE:
725 return SapResultCode::DATA_NOT_AVAILABLE;
726 default:
727 return SapResultCode::GENERIC_FAILURE;
728 }
729 }
730
convertPowerResponseProtoToHal(RIL_SIM_SAP_POWER_RSP_Response responseProto)731 SapResultCode convertPowerResponseProtoToHal(RIL_SIM_SAP_POWER_RSP_Response responseProto) {
732 switch(responseProto) {
733 case RIL_SIM_SAP_POWER_RSP_Response_RIL_E_SUCCESS:
734 return SapResultCode::SUCCESS;
735 case RIL_SIM_SAP_POWER_RSP_Response_RIL_E_GENERIC_FAILURE:
736 return SapResultCode::GENERIC_FAILURE;
737 case RIL_SIM_SAP_POWER_RSP_Response_RIL_E_SIM_ABSENT:
738 return SapResultCode::CARD_REMOVED;
739 case RIL_SIM_SAP_POWER_RSP_Response_RIL_E_SIM_ALREADY_POWERED_OFF:
740 return SapResultCode::CARD_ALREADY_POWERED_OFF;
741 case RIL_SIM_SAP_POWER_RSP_Response_RIL_E_SIM_ALREADY_POWERED_ON:
742 return SapResultCode::CARD_ALREADY_POWERED_ON;
743 default:
744 return SapResultCode::GENERIC_FAILURE;
745 }
746 }
747
convertResetSimResponseProtoToHal(RIL_SIM_SAP_RESET_SIM_RSP_Response responseProto)748 SapResultCode convertResetSimResponseProtoToHal(RIL_SIM_SAP_RESET_SIM_RSP_Response responseProto) {
749 switch(responseProto) {
750 case RIL_SIM_SAP_RESET_SIM_RSP_Response_RIL_E_SUCCESS:
751 return SapResultCode::SUCCESS;
752 case RIL_SIM_SAP_RESET_SIM_RSP_Response_RIL_E_GENERIC_FAILURE:
753 return SapResultCode::GENERIC_FAILURE;
754 case RIL_SIM_SAP_RESET_SIM_RSP_Response_RIL_E_SIM_ABSENT:
755 return SapResultCode::CARD_REMOVED;
756 case RIL_SIM_SAP_RESET_SIM_RSP_Response_RIL_E_SIM_NOT_READY:
757 return SapResultCode::CARD_NOT_ACCESSSIBLE;
758 case RIL_SIM_SAP_RESET_SIM_RSP_Response_RIL_E_SIM_ALREADY_POWERED_OFF:
759 return SapResultCode::CARD_ALREADY_POWERED_OFF;
760 }
761 return SapResultCode::GENERIC_FAILURE;
762 }
763
convertTransferCardReaderStatusResponseProtoToHal(RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP_Response responseProto)764 SapResultCode convertTransferCardReaderStatusResponseProtoToHal(
765 RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP_Response responseProto) {
766 switch(responseProto) {
767 case RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP_Response_RIL_E_SUCCESS:
768 return SapResultCode::SUCCESS;
769 case RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP_Response_RIL_E_GENERIC_FAILURE:
770 return SapResultCode::GENERIC_FAILURE;
771 case RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP_Response_RIL_E_SIM_DATA_NOT_AVAILABLE:
772 return SapResultCode::DATA_NOT_AVAILABLE;
773 }
774 return SapResultCode::GENERIC_FAILURE;
775 }
776
processResponse(MsgHeader * rsp,RilSapSocket * sapSocket,MsgType msgType)777 void processResponse(MsgHeader *rsp, RilSapSocket *sapSocket, MsgType msgType) {
778 MsgId msgId = rsp->id;
779 uint8_t *data = rsp->payload->bytes;
780 size_t dataLen = rsp->payload->size;
781
782 void *messagePtr = sapDecodeMessage(msgId, msgType, data, dataLen);
783
784 sp<SapImpl> sapImpl = getSapImpl(sapSocket);
785 if (sapImpl->sapCallback == NULL) {
786 RLOGE("processResponse: sapCallback == NULL; msgId = %d; msgType = %d",
787 msgId, msgType);
788 return;
789 }
790
791 if (messagePtr == NULL) {
792 RLOGE("processResponse: *messagePtr == NULL; msgId = %d; msgType = %d",
793 msgId, msgType);
794 sapImpl->sendFailedResponse(msgId, rsp->token, 0);
795 return;
796 }
797
798 RLOGD("processResponse: sapCallback != NULL; msgId = %d; msgType = %d",
799 msgId, msgType);
800
801 Return<void> retStatus;
802 switch (msgId) {
803 case MsgId_RIL_SIM_SAP_CONNECT: {
804 RIL_SIM_SAP_CONNECT_RSP *connectRsp = (RIL_SIM_SAP_CONNECT_RSP *)messagePtr;
805 RLOGD("processResponse: calling sapCallback->connectResponse %d %d %d",
806 rsp->token,
807 connectRsp->response,
808 connectRsp->max_message_size);
809 retStatus = sapImpl->sapCallback->connectResponse(rsp->token,
810 (SapConnectRsp)connectRsp->response,
811 connectRsp->max_message_size);
812 break;
813 }
814
815 case MsgId_RIL_SIM_SAP_DISCONNECT:
816 if (msgType == MsgType_RESPONSE) {
817 RLOGD("processResponse: calling sapCallback->disconnectResponse %d", rsp->token);
818 retStatus = sapImpl->sapCallback->disconnectResponse(rsp->token);
819 } else {
820 RIL_SIM_SAP_DISCONNECT_IND *disconnectInd =
821 (RIL_SIM_SAP_DISCONNECT_IND *)messagePtr;
822 RLOGD("processResponse: calling sapCallback->disconnectIndication %d %d",
823 rsp->token, disconnectInd->disconnectType);
824 retStatus = sapImpl->sapCallback->disconnectIndication(rsp->token,
825 (SapDisconnectType)disconnectInd->disconnectType);
826 }
827 break;
828
829 case MsgId_RIL_SIM_SAP_APDU: {
830 RIL_SIM_SAP_APDU_RSP *apduRsp = (RIL_SIM_SAP_APDU_RSP *)messagePtr;
831 SapResultCode apduResponse = convertApduResponseProtoToHal(apduRsp->response);
832 RLOGD("processResponse: calling sapCallback->apduResponse %d %d",
833 rsp->token, apduResponse);
834 hidl_vec<uint8_t> apduRspVec;
835 if (apduRsp->apduResponse != NULL && apduRsp->apduResponse->size > 0) {
836 apduRspVec.setToExternal(apduRsp->apduResponse->bytes, apduRsp->apduResponse->size);
837 }
838 retStatus = sapImpl->sapCallback->apduResponse(rsp->token, apduResponse, apduRspVec);
839 break;
840 }
841
842 case MsgId_RIL_SIM_SAP_TRANSFER_ATR: {
843 RIL_SIM_SAP_TRANSFER_ATR_RSP *transferAtrRsp =
844 (RIL_SIM_SAP_TRANSFER_ATR_RSP *)messagePtr;
845 SapResultCode transferAtrResponse =
846 convertTransferAtrResponseProtoToHal(transferAtrRsp->response);
847 RLOGD("processResponse: calling sapCallback->transferAtrResponse %d %d",
848 rsp->token, transferAtrResponse);
849 hidl_vec<uint8_t> transferAtrRspVec;
850 if (transferAtrRsp->atr != NULL && transferAtrRsp->atr->size > 0) {
851 transferAtrRspVec.setToExternal(transferAtrRsp->atr->bytes,
852 transferAtrRsp->atr->size);
853 }
854 retStatus = sapImpl->sapCallback->transferAtrResponse(rsp->token, transferAtrResponse,
855 transferAtrRspVec);
856 break;
857 }
858
859 case MsgId_RIL_SIM_SAP_POWER: {
860 SapResultCode powerResponse = convertPowerResponseProtoToHal(
861 ((RIL_SIM_SAP_POWER_RSP *)messagePtr)->response);
862 RLOGD("processResponse: calling sapCallback->powerResponse %d %d",
863 rsp->token, powerResponse);
864 retStatus = sapImpl->sapCallback->powerResponse(rsp->token, powerResponse);
865 break;
866 }
867
868 case MsgId_RIL_SIM_SAP_RESET_SIM: {
869 SapResultCode resetSimResponse = convertResetSimResponseProtoToHal(
870 ((RIL_SIM_SAP_RESET_SIM_RSP *)messagePtr)->response);
871 RLOGD("processResponse: calling sapCallback->resetSimResponse %d %d",
872 rsp->token, resetSimResponse);
873 retStatus = sapImpl->sapCallback->resetSimResponse(rsp->token, resetSimResponse);
874 break;
875 }
876
877 case MsgId_RIL_SIM_SAP_STATUS: {
878 RIL_SIM_SAP_STATUS_IND *statusInd = (RIL_SIM_SAP_STATUS_IND *)messagePtr;
879 RLOGD("processResponse: calling sapCallback->statusIndication %d %d",
880 rsp->token, statusInd->statusChange);
881 retStatus = sapImpl->sapCallback->statusIndication(rsp->token,
882 (SapStatus)statusInd->statusChange);
883 break;
884 }
885
886 case MsgId_RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS: {
887 RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP *transferStatusRsp =
888 (RIL_SIM_SAP_TRANSFER_CARD_READER_STATUS_RSP *)messagePtr;
889 SapResultCode transferCardReaderStatusResponse =
890 convertTransferCardReaderStatusResponseProtoToHal(
891 transferStatusRsp->response);
892 RLOGD("processResponse: calling sapCallback->transferCardReaderStatusResponse %d %d %d",
893 rsp->token,
894 transferCardReaderStatusResponse,
895 transferStatusRsp->CardReaderStatus);
896 retStatus = sapImpl->sapCallback->transferCardReaderStatusResponse(rsp->token,
897 transferCardReaderStatusResponse,
898 transferStatusRsp->CardReaderStatus);
899 break;
900 }
901
902 case MsgId_RIL_SIM_SAP_ERROR_RESP: {
903 RLOGD("processResponse: calling sapCallback->errorResponse %d", rsp->token);
904 retStatus = sapImpl->sapCallback->errorResponse(rsp->token);
905 break;
906 }
907
908 case MsgId_RIL_SIM_SAP_SET_TRANSFER_PROTOCOL: {
909 SapResultCode setTransferProtocolResponse;
910 if (((RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_RSP *)messagePtr)->response ==
911 RIL_SIM_SAP_SET_TRANSFER_PROTOCOL_RSP_Response_RIL_E_SUCCESS) {
912 setTransferProtocolResponse = SapResultCode::SUCCESS;
913 } else {
914 setTransferProtocolResponse = SapResultCode::NOT_SUPPORTED;
915 }
916 RLOGD("processResponse: calling sapCallback->transferProtocolResponse %d %d",
917 rsp->token, setTransferProtocolResponse);
918 retStatus = sapImpl->sapCallback->transferProtocolResponse(rsp->token,
919 setTransferProtocolResponse);
920 break;
921 }
922
923 default:
924 return;
925 }
926 sapImpl->checkReturnStatus(retStatus);
927 }
928
processResponse(MsgHeader * rsp,RilSapSocket * sapSocket)929 void sap::processResponse(MsgHeader *rsp, RilSapSocket *sapSocket) {
930 processResponse(rsp, sapSocket, MsgType_RESPONSE);
931 }
932
processUnsolResponse(MsgHeader * rsp,RilSapSocket * sapSocket)933 void sap::processUnsolResponse(MsgHeader *rsp, RilSapSocket *sapSocket) {
934 processResponse(rsp, sapSocket, MsgType_UNSOL_RESPONSE);
935 }
936
registerService(const RIL_RadioFunctions * callbacks)937 void sap::registerService(const RIL_RadioFunctions *callbacks) {
938 using namespace android::hardware;
939 namespace compat = android::hardware::radio::compat;
940
941 int simCount = 1;
942 const char *serviceNames[] = {
943 android::RIL_getServiceName()
944 #if (SIM_COUNT >= 2)
945 , RIL2_SERVICE_NAME
946 #if (SIM_COUNT >= 3)
947 , RIL3_SERVICE_NAME
948 #if (SIM_COUNT >= 4)
949 , RIL4_SERVICE_NAME
950 #endif
951 #endif
952 #endif
953 };
954
955 RIL_SOCKET_ID socketIds[] = {
956 RIL_SOCKET_1
957 #if (SIM_COUNT >= 2)
958 , RIL_SOCKET_2
959 #if (SIM_COUNT >= 3)
960 , RIL_SOCKET_3
961 #if (SIM_COUNT >= 4)
962 , RIL_SOCKET_4
963 #endif
964 #endif
965 #endif
966 };
967 #if (SIM_COUNT >= 2)
968 simCount = SIM_COUNT;
969 #endif
970
971 for (int i = 0; i < simCount; i++) {
972 sapService[i] = new SapImpl;
973 sapService[i]->slotId = i;
974 sapService[i]->rilSocketId = socketIds[i];
975 RLOGD("registerService: starting ISap %s for slotId %d", serviceNames[i], i);
976
977 // use a compat shim to convert HIDL interface to AIDL and publish it
978 // TODO(bug 220004469): replace with a full AIDL implementation
979 static auto aidlHal = ndk::SharedRefBase::make<compat::Sap>(sapService[i]);
980 const auto instance =
981 std::string(compat::Sap::descriptor) + "/" + std::string(serviceNames[i]);
982 const auto status = AServiceManager_addService(aidlHal->asBinder().get(), instance.c_str());
983 if (status == STATUS_OK) {
984 RLOGD("registerService addService: instance %s, status %d", instance.c_str(), status);
985 } else {
986 RLOGE("failed to register sapService for instance %s, status %d", instance.c_str(),
987 status);
988 }
989 }
990 }
991