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