1 /**
2 * Copyright (C) 2010 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 <map>
18
19 #include <v8.h>
20 #include <telephony/ril.h>
21
22 #include "ril.pb.h"
23
24 #include "logging.h"
25 #include "mock_ril.h"
26 #include "node_buffer.h"
27 #include "node_object_wrap.h"
28 #include "protobuf_v8.h"
29 #include "status.h"
30 #include "util.h"
31 #include "worker.h"
32
33 #include "responses.h"
34
35 //#define RESPONSES_DEBUG
36 #ifdef RESPONSES_DEBUG
37
38 #define DBG(...) LOGD(__VA_ARGS__)
39
40 #else
41
42 #define DBG(...)
43
44 #endif
45
46
47 /**
48 * The Buffer is assumed to be empty so nothing to convert
49 * @return STATUS_OK and *data = NULL *datalen = 0;
50 */
RspWithNoData(int cmd,RIL_Token token,RIL_Errno rilErrno,Buffer * buffer)51 RIL_Errno RspWithNoData(
52 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer *buffer) {
53 DBG("RspWithNoData E");
54
55 // Complete the request
56 s_rilenv->OnRequestComplete(token, rilErrno, NULL, 0);
57
58 DBG("RspWithNoData X");
59 return rilErrno;
60 }
61
62 /**
63 * Handle response for an array of strings
64 *
65 * If a string value is "*magic-null*" then that value
66 * will be returned as null.
67 */
RspStrings(int cmd,RIL_Token token,RIL_Errno rilErrno,Buffer * buffer)68 RIL_Errno RspStrings(
69 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer *buffer) {
70 DBG("RspStrings E");
71
72 ril_proto::RspStrings *rsp = new ril_proto::RspStrings();
73 rsp->ParseFromArray(buffer->data(), buffer->length());
74 int result_len = rsp->strings_size() * sizeof(const char *);
75 const char **result = (const char **)alloca(result_len);
76 for (int i = 0; i < rsp->strings_size(); i++) {
77 result[i] = rsp->strings(i).c_str();
78 DBG("result[%d]='%s'", i, result[i]);
79 if (strcmp("*magic-null*", result[i]) == 0) {
80 result[i] = NULL;
81 }
82 }
83
84 // Complete the request
85 s_rilenv->OnRequestComplete(token, rilErrno, result, result_len);
86
87 DBG("RspStrings X rilErrno=%d", rilErrno);
88 return rilErrno;
89 }
90
91 /**
92 * Handle response for a string
93 */
RspString(int cmd,RIL_Token token,RIL_Errno rilErrno,Buffer * buffer)94 RIL_Errno RspString(
95 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer *buffer) {
96 DBG("RspString E");
97
98 ril_proto::RspStrings *rsp = new ril_proto::RspStrings();
99 rsp->ParseFromArray(buffer->data(), buffer->length());
100 const char *result = rsp->strings(0).c_str();
101
102 // Complete the request
103 s_rilenv->OnRequestComplete(token, rilErrno, (void *)result, strlen(result));
104
105 DBG("RspString X rilErrno=%d", rilErrno);
106 return rilErrno;
107 }
108
109 /**
110 * Handle response for an array of integers
111 */
RspIntegers(int cmd,RIL_Token token,RIL_Errno rilErrno,Buffer * buffer)112 RIL_Errno RspIntegers(
113 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer *buffer) {
114 DBG("RspIntegers E");
115
116 ril_proto::RspIntegers *rsp = new ril_proto::RspIntegers();
117 rsp->ParseFromArray(buffer->data(), buffer->length());
118 int result_len = rsp->integers_size() * sizeof(const int32_t);
119 int32_t *result = (int32_t *)alloca(result_len);
120 for (int i = 0; i < rsp->integers_size(); i++) {
121 result[i] = rsp->integers(i);
122 DBG("result[%d]=%d", i, result[i]);
123 }
124
125 // Complete the request
126 s_rilenv->OnRequestComplete(token, rilErrno, result, result_len);
127
128 DBG("RspIntegers X rilErrno=%d", rilErrno);
129 return rilErrno;
130 }
131
132 /**
133 * Handle RIL_REQUEST_GET_SIM_STATUS response
134 */
RspGetSimStatus(int cmd,RIL_Token token,RIL_Errno rilErrno,Buffer * buffer)135 RIL_Errno RspGetSimStatus(
136 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer *buffer) { // 1
137 DBG("RspGetSimStatus E");
138
139 ril_proto::RspGetSimStatus *rsp = new ril_proto::RspGetSimStatus();
140 rsp->ParseFromArray(buffer->data(), buffer->length());
141 const ril_proto::RilCardStatus& r = rsp->card_status();
142 RIL_CardStatus cardStatus;
143 cardStatus.card_state = RIL_CardState(r.card_state());
144 cardStatus.universal_pin_state = RIL_PinState(r.universal_pin_state());
145 cardStatus.gsm_umts_subscription_app_index = r.gsm_umts_subscription_app_index();
146 cardStatus.num_applications = r.num_applications();
147 for (int i = 0; i < cardStatus.num_applications; i++) {
148 cardStatus.applications[i].app_type = RIL_AppType(r.applications(i).app_type());
149 cardStatus.applications[i].app_state = RIL_AppState(r.applications(i).app_state());
150 cardStatus.applications[i].perso_substate =
151 RIL_PersoSubstate(r.applications(i).perso_substate());
152 cardStatus.applications[i].aid_ptr = const_cast<char *>(r.applications(i).aid().c_str());
153 cardStatus.applications[i].app_label_ptr =
154 const_cast<char *>(r.applications(i).app_label().c_str());
155 cardStatus.applications[i].pin1_replaced = r.applications(i).pin1_replaced();
156 cardStatus.applications[i].pin1 = RIL_PinState(r.applications(i).pin1());
157 cardStatus.applications[i].pin2 = RIL_PinState(r.applications(i).pin2());
158 }
159
160 // Complete the request
161 s_rilenv->OnRequestComplete(token, rilErrno,
162 &cardStatus, sizeof(cardStatus));
163
164 DBG("RspGetSimStatus X rilErrno=%d", rilErrno);
165 return rilErrno;
166 }
167
168 /**
169 * Handle RIL_REQUEST_ENTER_SIM_PIN_DATA response
170 */
RspEnterSimPinData(int cmd,RIL_Token token,RIL_Errno rilErrno,Buffer * buffer)171 RIL_Errno RspEnterSimPinData(
172 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer *buffer) { // 2
173 DBG("RspEnterSimPinData E");
174
175 ril_proto::RspEnterSimPin *rsp = new ril_proto::RspEnterSimPin();
176 rsp->ParseFromArray(buffer->data(), buffer->length());
177 DBG("retries_remaining=%d", rsp->retries_remaining());
178 int retries_remaining = rsp->retries_remaining();
179
180 // Complete the request
181 s_rilenv->OnRequestComplete(token, rilErrno,
182 &retries_remaining, sizeof(retries_remaining));
183
184 DBG("RspEnterSimPinData X rilErrno=%d", rilErrno);
185 return rilErrno;
186 }
187
188 /**
189 * Handle RIL_REQUEST_GET_CURRENT_CALLS response // 9
190 */
RspGetCurrentCalls(int cmd,RIL_Token token,RIL_Errno rilErrno,Buffer * buffer)191 RIL_Errno RspGetCurrentCalls (
192 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer *buffer) { // 9
193 DBG("RspGetCurrentCalls E");
194
195 ril_proto::RspGetCurrentCalls *rsp = new ril_proto::RspGetCurrentCalls();
196 rsp->ParseFromArray(buffer->data(), buffer->length());
197 int result_len = rsp->calls_size() * sizeof(const RIL_Call *);
198 DBG("RspGetCurrentCalls rilErrno=%d result_len=%d", rilErrno, result_len);
199 RIL_Call **result = (RIL_Call **)alloca(result_len);
200 for (int i = 0; i < rsp->calls_size(); i++) {
201 const ril_proto::RilCall& srcCall = rsp->calls(i);
202 RIL_Call *dstCall = (RIL_Call *)alloca(sizeof(RIL_Call));
203
204 result[i] = dstCall;
205 dstCall->state = (RIL_CallState)srcCall.state();
206 dstCall->index = srcCall.index();
207 dstCall->toa = srcCall.toa();
208 dstCall->isMpty = (char)srcCall.is_mpty();
209 dstCall->isMT = (char)srcCall.is_mt();
210 dstCall->als = srcCall.als();
211 dstCall->isVoice = (char)srcCall.is_voice();
212 dstCall->isVoicePrivacy = (char)srcCall.is_voice_privacy();
213 dstCall->number = (char *)srcCall.number().c_str();
214 dstCall->numberPresentation = srcCall.number_presentation();
215 dstCall->name = (char *)srcCall.name().c_str();
216 dstCall->namePresentation = srcCall.name_presentation();
217 if (srcCall.has_uus_info()) {
218 dstCall->uusInfo =
219 (RIL_UUS_Info *)alloca(sizeof(RIL_UUS_Info));
220 dstCall->uusInfo->uusType =
221 (RIL_UUS_Type)srcCall.uus_info().uus_type();
222 dstCall->uusInfo->uusDcs =
223 (RIL_UUS_DCS)srcCall.uus_info().uus_dcs();
224 dstCall->uusInfo->uusLength =
225 srcCall.uus_info().uus_length();
226 dstCall->uusInfo->uusData =
227 (char *)srcCall.uus_info().uus_data().c_str();
228 } else {
229 dstCall->uusInfo = NULL;
230 }
231 }
232
233 // Complete the request
234 s_rilenv->OnRequestComplete(token, rilErrno, result, result_len);
235
236 DBG("RspGetCurrentCalls X rilErrno=%d", rilErrno);
237 return rilErrno;
238 }
239
240 /**
241 * Handle RIL_REQUEST_SIGNAL_STRENGTH response
242 */
RspSignalStrength(int cmd,RIL_Token token,RIL_Errno rilErrno,Buffer * buffer)243 RIL_Errno RspSignalStrength(
244 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer *buffer) { // 19
245 DBG("RspSignalStrength E");
246
247 DBG("cmd = %d, token=%p, rilErrno=%d", cmd, token, rilErrno);
248
249 // Retrieve response from response message
250 ril_proto::RspSignalStrength *rsp = new ril_proto::RspSignalStrength();
251 rsp->ParseFromArray(buffer->data(), buffer->length());
252 const ril_proto::RILGWSignalStrength& gwST = rsp->gw_signalstrength();
253 const ril_proto::RILCDMASignalStrength& cdmaST = rsp->cdma_signalstrength();
254 const ril_proto::RILEVDOSignalStrength& evdoST = rsp->evdo_signalstrength();
255
256 // Copy the response message from response to format defined in ril.h
257 RIL_SignalStrength curSignalStrength;
258
259 curSignalStrength.GW_SignalStrength.signalStrength = gwST.signal_strength();
260 curSignalStrength.GW_SignalStrength.bitErrorRate = gwST.bit_error_rate();
261 curSignalStrength.CDMA_SignalStrength.dbm = cdmaST.dbm();
262 curSignalStrength.CDMA_SignalStrength.ecio = cdmaST.ecio();
263 curSignalStrength.EVDO_SignalStrength.dbm = evdoST.dbm();
264 curSignalStrength.EVDO_SignalStrength.ecio = evdoST.ecio();
265 curSignalStrength.EVDO_SignalStrength.signalNoiseRatio = evdoST.signal_noise_ratio();
266
267 DBG("print response signal strength: ");
268 DBG("gw signalstrength = %d", curSignalStrength.GW_SignalStrength.signalStrength);
269 DBG("gw_signalstrength = %d", curSignalStrength.GW_SignalStrength.bitErrorRate);
270 DBG("cdma_signalstrength = %d", curSignalStrength.CDMA_SignalStrength.dbm);
271 DBG("cdma_signalstrength = %d", curSignalStrength.CDMA_SignalStrength.ecio);
272 DBG("evdo_signalstrength = %d", curSignalStrength.EVDO_SignalStrength.dbm);
273 DBG("evdo_signalstrength = %d", curSignalStrength.EVDO_SignalStrength.ecio);
274 DBG("evdo_signalstrength = %d", curSignalStrength.EVDO_SignalStrength.signalNoiseRatio);
275
276 // Complete the request
277 s_rilenv->OnRequestComplete(token, rilErrno, &curSignalStrength, sizeof(curSignalStrength));
278
279 DBG("RspSignalStrength X rilErrno=%d", rilErrno);
280 return rilErrno;
281 }
282
283 /**
284 * Handle RIL_REQUEST_OPERATOR response
285 */
RspOperator(int cmd,RIL_Token token,RIL_Errno rilErrno,Buffer * buffer)286 RIL_Errno RspOperator(
287 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer *buffer) { // 22
288 int status;
289
290 DBG("RspOperator E");
291
292 ril_proto::RspOperator *rsp = new ril_proto::RspOperator();
293 rsp->ParseFromArray(buffer->data(), buffer->length());
294 const char *result[3] = { NULL, NULL, NULL };
295 if (rsp->has_long_alpha_ons()) {
296 DBG("long_alpha_ons=%s", rsp->long_alpha_ons().c_str());
297 result[0] = rsp->long_alpha_ons().c_str();
298 }
299 if (rsp->has_short_alpha_ons()) {
300 DBG("short_alpha_ons=%s", rsp->short_alpha_ons().c_str());
301 result[1] = rsp->short_alpha_ons().c_str();
302 }
303 if (rsp->has_mcc_mnc()) {
304 DBG("mcc_mnc=%s", rsp->mcc_mnc().c_str());
305 result[2] = rsp->mcc_mnc().c_str();
306 }
307
308 // Complete the request
309 s_rilenv->OnRequestComplete(token, rilErrno, result, sizeof(result));
310
311 DBG("RspOperator X rilErrno=%d", rilErrno);
312 return rilErrno;
313 }
314
315 // ----------------- Handle unsolicited response ----------------------------------------
316 /**
317 * Handle RIL_UNSOL_SIGNAL_STRENGTH response
318 */
UnsolRspSignalStrength(int cmd,Buffer * buffer)319 void UnsolRspSignalStrength(int cmd, Buffer* buffer) {
320
321 DBG("UnsolRspSignalStrength E");
322 LOGE("unsolicited response command: %d", cmd);
323 // Retrieve response from response message
324 ril_proto::RspSignalStrength *rsp = new ril_proto::RspSignalStrength();
325 rsp->ParseFromArray(buffer->data(), buffer->length());
326 const ril_proto::RILGWSignalStrength& gwST = rsp->gw_signalstrength();
327 const ril_proto::RILCDMASignalStrength& cdmaST = rsp->cdma_signalstrength();
328 const ril_proto::RILEVDOSignalStrength& evdoST = rsp->evdo_signalstrength();
329
330 // Copy the response message from response to format defined in ril.h
331 RIL_SignalStrength curSignalStrength;
332
333 curSignalStrength.GW_SignalStrength.signalStrength = gwST.signal_strength();
334 curSignalStrength.GW_SignalStrength.bitErrorRate = gwST.bit_error_rate();
335 curSignalStrength.CDMA_SignalStrength.dbm = cdmaST.dbm();
336 curSignalStrength.CDMA_SignalStrength.ecio = cdmaST.ecio();
337 curSignalStrength.EVDO_SignalStrength.dbm = evdoST.dbm();
338 curSignalStrength.EVDO_SignalStrength.ecio = evdoST.ecio();
339 curSignalStrength.EVDO_SignalStrength.signalNoiseRatio = evdoST.signal_noise_ratio();
340
341 DBG("print response signal strength: ");
342 DBG("gw signalstrength = %d", curSignalStrength.GW_SignalStrength.signalStrength);
343 DBG("gw_signalstrength = %d", curSignalStrength.GW_SignalStrength.bitErrorRate);
344 DBG("cdma_signalstrength = %d", curSignalStrength.CDMA_SignalStrength.dbm);
345 DBG("cdma_signalstrength = %d", curSignalStrength.CDMA_SignalStrength.ecio);
346 DBG("evdo_signalstrength = %d", curSignalStrength.EVDO_SignalStrength.dbm);
347 DBG("evdo_signalstrength = %d", curSignalStrength.EVDO_SignalStrength.ecio);
348 DBG("evdo_signalstrength = %d", curSignalStrength.EVDO_SignalStrength.signalNoiseRatio);
349
350 s_rilenv->OnUnsolicitedResponse(cmd, &curSignalStrength, sizeof(curSignalStrength));
351 DBG("UnsolRspSignalStrength X");
352 }
353
354 /**
355 * Maps for converting request complete and unsoliciated response
356 * protobufs to ril data arrays.
357 */
358 typedef RIL_Errno (*RspConversion)(
359 int cmd, RIL_Token token, RIL_Errno rilErrno, Buffer* buffer);
360 typedef std::map<int, RspConversion> RspConversionMap;
361 RspConversionMap rilRspConversionMap;
362
363 typedef void (*UnsolRspConversion)(int cmd, Buffer* buffer);
364 typedef std::map<int, UnsolRspConversion> UnsolRspConversionMap;
365 UnsolRspConversionMap unsolRilRspConversionMap;
366
367 /**
368 * Send a ril request complete response.
369 */
SendRilRequestComplete(const v8::Arguments & args)370 v8::Handle<v8::Value> SendRilRequestComplete(const v8::Arguments& args) {
371 DBG("SendRilRequestComplete E");
372 v8::HandleScope handle_scope;
373 v8::Handle<v8::Value> retValue;
374
375 int cmd;
376 RIL_Errno rilErrno;
377 RIL_Token token;
378 Buffer* buffer;
379
380 /**
381 * Get the arguments. There should be at least 3, cmd,
382 * ril error code and token. Optionally a Buffer containing
383 * the protobuf representation of the data to return.
384 */
385 if (args.Length() < REQUEST_COMPLETE_REQUIRED_CMDS) {
386 // Expecting a cmd, ERROR and token
387 LOGE("SendRilRequestComplete X %d parameters"
388 " expecting at least %d: rilErrno, cmd, and token",
389 args.Length(), REQUEST_COMPLETE_REQUIRED_CMDS);
390 return v8::Undefined();
391 }
392 v8::Handle<v8::Value> v8RilErrCode(
393 args[REQUEST_COMPLETE_RIL_ERR_CODE_INDEX]->ToObject());
394 rilErrno = RIL_Errno(v8RilErrCode->NumberValue());
395
396 v8::Handle<v8::Value> v8Cmd(
397 args[REQUEST_COMPLETE_CMD_INDEX]->ToObject());
398 cmd = int(v8Cmd->NumberValue());
399
400 v8::Handle<v8::Value> v8Token(
401 args[REQUEST_COMPLETE_TOKEN_INDEX]->ToObject());
402 token = RIL_Token(int64_t(v8Token->NumberValue()));
403
404 if (args.Length() >= (REQUEST_COMPLETE_DATA_INDEX+1)) {
405 buffer = ObjectWrap::Unwrap<Buffer>(
406 args[REQUEST_COMPLETE_DATA_INDEX]->ToObject());
407 } else {
408 buffer = NULL;
409 }
410
411 DBG("SendRilRequestComplete: rilErrno=%d, cmd=%d, token=%p", rilErrno, cmd, token);
412 RspConversionMap::iterator itr;
413 itr = rilRspConversionMap.find(cmd);
414 if (itr != rilRspConversionMap.end()) {
415 itr->second(cmd, token, rilErrno, buffer);
416 } else {
417 if ((buffer == NULL) || (buffer->length() <= 0)) {
418 // Nothing to convert
419 rilErrno = RIL_E_SUCCESS;
420 } else {
421 // There was a buffer but we don't support the resonse yet.
422 LOGE("SendRilRequestComplete: No conversion routine for cmd %d,"
423 " return RIL_E_REQUEST_NOT_SUPPORTED", cmd);
424 rilErrno = RIL_E_REQUEST_NOT_SUPPORTED;
425 }
426 // Complete the request
427 s_rilenv->OnRequestComplete(token, rilErrno, NULL, 0);
428 }
429
430 DBG("SendRilRequestComplete X rillErrno=%d", rilErrno);
431 return v8::Undefined();
432 }
433
434 /**
435 * Send an unsolicited response.
436 */
SendRilUnsolicitedResponse(const v8::Arguments & args)437 v8::Handle<v8::Value> SendRilUnsolicitedResponse(const v8::Arguments& args) {
438 DBG("SendRilUnsolicitedResponse E");
439 v8::HandleScope handle_scope;
440 v8::Handle<v8::Value> retValue;
441
442 int status;
443 void *data;
444 size_t datalen;
445
446 int cmd;
447 Buffer* buffer;
448
449 /**
450 * Get the cmd number and data arguments
451 */
452 if (args.Length() < UNSOL_RESPONSE_REQUIRED_CMDS) {
453 // Expecting a cmd
454 LOGE("SendRilUnsolicitedResponse X %d parameters"
455 " expecting at least a cmd",
456 args.Length());
457 return v8::Undefined();
458 }
459 v8::Handle<v8::Value> v8RilErrCode(args[UNSOL_RESPONSE_CMD_INDEX]->ToObject());
460 cmd = int(v8RilErrCode->NumberValue());
461
462 // data is optional
463 if (args.Length() >= (UNSOL_RESPONSE_DATA_INDEX+1)) {
464 buffer = ObjectWrap::Unwrap<Buffer>(args[UNSOL_RESPONSE_DATA_INDEX]->ToObject());
465 } else {
466 buffer = NULL;
467 }
468
469 UnsolRspConversionMap::iterator itr;
470 itr = unsolRilRspConversionMap.find(cmd);
471 if (itr != unsolRilRspConversionMap.end()) {
472 itr->second(cmd, buffer);
473 } else {
474 if ((buffer == NULL) || (buffer->length() <= 0)) {
475 // Nothing to convert
476 data = NULL;
477 datalen = 0;
478 } else {
479 // There was a buffer but we don't support the response yet.
480 LOGE("SendRilUnsolicitedResponse: No conversion routine for cmd %d,"
481 " return RIL_E_REQUEST_NOT_SUPPORTED", cmd);
482 data = NULL;
483 datalen = 0;
484 }
485 s_rilenv->OnUnsolicitedResponse(cmd, NULL, 0);
486 }
487
488 DBG("SendRilUnsolicitedResponse X");
489 return v8::Undefined();
490 }
491
responsesInit(v8::Handle<v8::Context> context)492 int responsesInit(v8::Handle<v8::Context> context) {
493 LOGD("responsesInit E");
494 int status = STATUS_OK;
495
496 rilRspConversionMap[RIL_REQUEST_GET_SIM_STATUS] = RspGetSimStatus; // 1
497 rilRspConversionMap[RIL_REQUEST_ENTER_SIM_PIN] = RspEnterSimPinData; // 2
498 rilRspConversionMap[RIL_REQUEST_GET_CURRENT_CALLS] = RspGetCurrentCalls; // 9
499 rilRspConversionMap[RIL_REQUEST_GET_IMSI] = RspString; // 11
500 rilRspConversionMap[RIL_REQUEST_HANGUP] = RspWithNoData; // 12
501 rilRspConversionMap[RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND] = RspWithNoData; // 13
502 rilRspConversionMap[RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND] = RspWithNoData; // 14
503 rilRspConversionMap[RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE] = RspWithNoData; // 15
504 rilRspConversionMap[RIL_REQUEST_CONFERENCE] = RspWithNoData; // 16
505 rilRspConversionMap[RIL_REQUEST_LAST_CALL_FAIL_CAUSE] = RspIntegers; // 18
506 rilRspConversionMap[RIL_REQUEST_SIGNAL_STRENGTH] = RspSignalStrength; // 19
507 rilRspConversionMap[RIL_REQUEST_REGISTRATION_STATE] = RspStrings; // 20
508 rilRspConversionMap[RIL_REQUEST_GPRS_REGISTRATION_STATE] = RspStrings; // 21
509 rilRspConversionMap[RIL_REQUEST_OPERATOR] = RspOperator; // 22
510 rilRspConversionMap[RIL_REQUEST_GET_IMEI] = RspString; // 38
511 rilRspConversionMap[RIL_REQUEST_GET_IMEISV] = RspString; // 39
512 rilRspConversionMap[RIL_REQUEST_ANSWER] = RspWithNoData; // 39
513 rilRspConversionMap[RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE] = RspIntegers; // 45
514 rilRspConversionMap[RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC] = RspWithNoData; // 46
515 rilRspConversionMap[RIL_REQUEST_BASEBAND_VERSION] = RspString; // 51
516 rilRspConversionMap[RIL_REQUEST_SEPARATE_CONNECTION] = RspWithNoData; // 52
517 rilRspConversionMap[RIL_REQUEST_SET_MUTE] = RspWithNoData; // 53
518 rilRspConversionMap[RIL_REQUEST_SCREEN_STATE] = RspWithNoData; // 61
519
520 unsolRilRspConversionMap[RIL_UNSOL_SIGNAL_STRENGTH] = UnsolRspSignalStrength; // 1009
521
522
523 LOGD("responsesInit X: status=%d", status);
524 return STATUS_OK;
525 }
526