1 /*
2 ** Copyright 2017, The Android Open Source Project
3 **
4 ** Licensed under the Apache License, Version 2.0 (the "License");
5 ** you may not use this file except in compliance with the License.
6 ** You may obtain a copy of the License at
7 **
8 ** http://www.apache.org/licenses/LICENSE-2.0
9 **
10 ** Unless required by applicable law or agreed to in writing, software
11 ** distributed under the License ioogle/s 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 "guest/hals/ril/cuttlefish_ril.h"
18
19 #include <cutils/properties.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <sys/types.h>
23 #include <time.h>
24
25 #include <map>
26 #include <set>
27 #include <string>
28 #include <vector>
29
30 #include "common/libs/device_config/device_config.h"
31 #include "common/libs/net/netlink_client.h"
32 #include "common/libs/net/network_interface.h"
33 #include "common/libs/net/network_interface_manager.h"
34
35 #define CUTTLEFISH_RIL_VERSION_STRING "Android Cuttlefish RIL 1.4"
36
37 /* Modem Technology bits */
38 #define MDM_GSM 0x01
39 #define MDM_WCDMA 0x02
40 #define MDM_CDMA 0x04
41 #define MDM_EVDO 0x08
42 #define MDM_LTE 0x10
43
44 typedef enum {
45 SIM_ABSENT = 0,
46 SIM_NOT_READY = 1,
47 SIM_READY = 2, // SIM_READY means the radio state is RADIO_STATE_SIM_READY
48 SIM_PIN = 3,
49 SIM_PUK = 4,
50 SIM_NETWORK_PERSONALIZATION = 5,
51 RUIM_ABSENT = 6,
52 RUIM_NOT_READY = 7,
53 RUIM_READY = 8,
54 RUIM_PIN = 9,
55 RUIM_PUK = 10,
56 RUIM_NETWORK_PERSONALIZATION = 11
57 } SIM_Status;
58
59 static std::unique_ptr<cvd::DeviceConfig> global_ril_config = nullptr;
60
61 static const struct RIL_Env* gce_ril_env;
62
63 static const struct timeval TIMEVAL_SIMPOLL = {3, 0};
64
65 static time_t gce_ril_start_time;
66
67 static void pollSIMState(void* param);
68
69 RIL_RadioState gRadioPowerState = RADIO_STATE_OFF;
70 RIL_RadioAccessFamily default_access = RAF_LTE;
71
72 struct DataCall {
73 enum AllowedAuthenticationType { kNone = 0, kPap = 1, kChap = 2, kBoth = 3 };
74
75 enum ConnectionType {
76 kConnTypeIPv4,
77 kConnTypeIPv6,
78 kConnTypeIPv4v6,
79 kConnTypePPP
80 };
81
82 enum LinkState {
83 kLinkStateInactive = 0,
84 kLinkStateDown = 1,
85 kLinkStateUp = 2,
86 };
87
88 RIL_RadioTechnology technology_;
89 RIL_DataProfile profile_;
90 std::string access_point_;
91 std::string username_;
92 std::string password_;
93 AllowedAuthenticationType auth_type_;
94 ConnectionType connection_type_;
95 LinkState link_state_;
96 RIL_DataCallFailCause fail_cause_;
97 std::string other_properties_;
98 };
99
100 static std::string gSimPIN = "0000";
101 static const std::string gSimPUK = "11223344";
102 static int gSimPINAttempts = 0;
103 static const int gSimPINAttemptsMax = 3;
104 static SIM_Status gSimStatus = SIM_NOT_READY;
105 static bool areUiccApplicationsEnabled = true;
106
107 // SetUpNetworkInterface configures IP and Broadcast addresses on a RIL
108 // controlled network interface.
109 // This call returns true, if operation was successful.
SetUpNetworkInterface(const char * ipaddr,int prefixlen,const char * bcaddr)110 bool SetUpNetworkInterface(const char* ipaddr, int prefixlen,
111 const char* bcaddr) {
112 auto factory = cvd::NetlinkClientFactory::Default();
113 std::unique_ptr<cvd::NetlinkClient> nl(factory->New(NETLINK_ROUTE));
114 std::unique_ptr<cvd::NetworkInterfaceManager> nm(
115 cvd::NetworkInterfaceManager::New(factory));
116 std::unique_ptr<cvd::NetworkInterface> ni(nm->Open("rmnet0", "eth1"));
117
118 if (ni) {
119 ni->SetName("rmnet0");
120 ni->SetAddress(ipaddr);
121 ni->SetBroadcastAddress(bcaddr);
122 ni->SetPrefixLength(prefixlen);
123 ni->SetOperational(true);
124 bool res = nm->ApplyChanges(*ni);
125 if (!res) ALOGE("Could not configure rmnet0");
126 return res;
127 }
128 return false;
129 }
130
131 // TearDownNetworkInterface disables network interface.
132 // This call returns true, if operation was successful.
TearDownNetworkInterface()133 bool TearDownNetworkInterface() {
134 auto nm(cvd::NetworkInterfaceManager::New(nullptr));
135 auto ni(nm->Open("rmnet0", "eth1"));
136
137 if (ni) {
138 ni->SetOperational(false);
139 bool res = nm->ApplyChanges(*ni);
140 if (!res) ALOGE("Could not disable rmnet0");
141 return res;
142 }
143 return false;
144 }
145
146 static int gNextDataCallId = 8;
147 static std::map<int, DataCall> gDataCalls;
148 static bool gRilConnected = false;
149
request_or_send_data_calllist(RIL_Token * t)150 static int request_or_send_data_calllist(RIL_Token* t) {
151 RIL_Data_Call_Response_v11* responses =
152 new RIL_Data_Call_Response_v11[gDataCalls.size()];
153
154 int index = 0;
155
156 ALOGV("Query data call list: %zu data calls tracked.", gDataCalls.size());
157
158 for (std::map<int, DataCall>::iterator iter = gDataCalls.begin();
159 iter != gDataCalls.end(); ++iter, ++index) {
160 responses[index].status = iter->second.fail_cause_;
161 responses[index].suggestedRetryTime = -1;
162 responses[index].cid = iter->first;
163 responses[index].active = iter->second.link_state_;
164
165 switch (iter->second.connection_type_) {
166 case DataCall::kConnTypeIPv4:
167 responses[index].type = (char*)"IP";
168 break;
169 case DataCall::kConnTypeIPv6:
170 responses[index].type = (char*)"IPV6";
171 break;
172 case DataCall::kConnTypeIPv4v6:
173 responses[index].type = (char*)"IPV4V6";
174 break;
175 case DataCall::kConnTypePPP:
176 responses[index].type = (char*)"PPP";
177 break;
178 default:
179 responses[index].type = (char*)"IP";
180 break;
181 }
182
183 responses[index].ifname = (char*)"rmnet0";
184 responses[index].addresses =
185 const_cast<char*>(global_ril_config->ril_address_and_prefix());
186 responses[index].dnses = const_cast<char*>(global_ril_config->ril_dns());
187 responses[index].gateways = const_cast<char*>(global_ril_config->ril_gateway());
188 responses[index].pcscf = (char*)"";
189 responses[index].mtu = 1440;
190 }
191
192 bool new_conn_state = (gDataCalls.size() > 0);
193
194 if (gRilConnected != new_conn_state) {
195 time_t curr_time;
196 time(&curr_time);
197 double diff_in_secs = difftime(curr_time, gce_ril_start_time);
198
199 gRilConnected = new_conn_state;
200
201 if (new_conn_state) {
202 ALOGV("MOBILE_DATA_CONNECTED %.2lf seconds", diff_in_secs);
203 } else {
204 ALOGV("MOBILE_DATA_DISCONNECTED %.2lf seconds", diff_in_secs);
205 }
206
207 if (property_set("ril.net_connected", new_conn_state ? "1" : "0")) {
208 ALOGE("Couldn't set a system property ril.net_connected.");
209 }
210 }
211
212 if (t != NULL) {
213 gce_ril_env->OnRequestComplete(*t, RIL_E_SUCCESS, responses,
214 gDataCalls.size() * sizeof(*responses));
215 } else {
216 gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
217 responses,
218 gDataCalls.size() * sizeof(*responses));
219 }
220 delete[] responses;
221 return 0;
222 }
223
request_datacall_fail_cause(RIL_Token t)224 static void request_datacall_fail_cause(RIL_Token t) {
225 RIL_DataCallFailCause fail = PDP_FAIL_DATA_REGISTRATION_FAIL;
226
227 if (gDataCalls.size() > 0) {
228 fail = gDataCalls.rbegin()->second.fail_cause_;
229 }
230
231 ALOGV("Requesting last data call setup fail cause (%d)", fail);
232 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &fail, sizeof(fail));
233 };
234
request_data_calllist(void *,size_t,RIL_Token t)235 static void request_data_calllist(void* /*data*/, size_t /*datalen*/,
236 RIL_Token t) {
237 request_or_send_data_calllist(&t);
238 }
239
request_setup_data_call(void * data,size_t datalen,RIL_Token t)240 static void request_setup_data_call(void* data, size_t datalen, RIL_Token t) {
241 char** details = static_cast<char**>(data);
242 const size_t fields = datalen / sizeof(details[0]);
243
244 // There are two different versions of this interface, one providing 7 strings
245 // and the other providing 8. The code below will assume the presence of 7
246 // strings in all cases, so bail out here if things appear to be wrong. We
247 // protect the 8 string case below.
248 if (fields < 7) {
249 ALOGE("%s returning: called with small datalen %zu", __FUNCTION__, datalen);
250 return;
251 }
252
253 DataCall call;
254 int tech = atoi(details[0]);
255 switch (tech) {
256 case 0:
257 case 2 + RADIO_TECH_1xRTT:
258 call.technology_ = RADIO_TECH_1xRTT;
259 break;
260
261 case 1:
262 case 2 + RADIO_TECH_EDGE:
263 call.technology_ = RADIO_TECH_EDGE;
264 break;
265
266 default:
267 call.technology_ = RIL_RadioTechnology(tech - 2);
268 break;
269 }
270
271 int profile = atoi(details[1]);
272 call.profile_ = RIL_DataProfile(profile);
273
274 if (details[2]) call.access_point_ = details[2];
275 if (details[3]) call.username_ = details[3];
276 if (details[4]) call.password_ = details[4];
277
278 int auth_type = atoi(details[5]);
279 call.auth_type_ = DataCall::AllowedAuthenticationType(auth_type);
280
281 if (!strcmp("IP", details[6])) {
282 call.connection_type_ = DataCall::kConnTypeIPv4;
283 } else if (!strcmp("IPV6", details[6])) {
284 call.connection_type_ = DataCall::kConnTypeIPv6;
285 } else if (!strcmp("IPV4V6", details[6])) {
286 call.connection_type_ = DataCall::kConnTypeIPv4v6;
287 } else if (!strcmp("PPP", details[6])) {
288 call.connection_type_ = DataCall::kConnTypePPP;
289 } else {
290 ALOGW("Unknown / unsupported connection type %s. Falling back to IPv4",
291 details[6]);
292 call.connection_type_ = DataCall::kConnTypeIPv4;
293 }
294
295 if (call.connection_type_ != DataCall::kConnTypeIPv4) {
296 ALOGE("Non-IPv4 connections are not supported by Cuttlefish RIL.");
297 gce_ril_env->OnRequestComplete(t, RIL_E_INVALID_ARGUMENTS, NULL, 0);
298 return;
299 }
300
301 call.link_state_ = DataCall::kLinkStateUp;
302 call.fail_cause_ = PDP_FAIL_NONE;
303 if (fields > 7) {
304 if (details[7]) call.other_properties_ = details[7];
305 }
306
307 if (gDataCalls.empty()) {
308 SetUpNetworkInterface(global_ril_config->ril_ipaddr(),
309 global_ril_config->ril_prefixlen(),
310 global_ril_config->ril_broadcast());
311 }
312
313 gDataCalls[gNextDataCallId] = call;
314 gNextDataCallId++;
315
316 ALOGV("Requesting data call setup to APN %s, technology %s, prof %s",
317 details[2], details[0], details[1]);
318
319 request_or_send_data_calllist(&t);
320
321 gRilConnected = (gDataCalls.size() > 0);
322 }
323
request_teardown_data_call(void * data,size_t,RIL_Token t)324 static void request_teardown_data_call(void* data, size_t /*datalen*/,
325 RIL_Token t) {
326 char** data_strs = (char**)data;
327 int call_id = atoi(data_strs[0]);
328 int reason = atoi(data_strs[1]);
329
330 ALOGV("Tearing down data call %d, reason: %d", call_id, reason);
331
332 gDataCalls.erase(call_id);
333 gRilConnected = (gDataCalls.size() > 0);
334
335 if (!gRilConnected) {
336 TearDownNetworkInterface();
337 }
338 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
339 }
340
set_radio_state(RIL_RadioState new_state,RIL_Token t)341 static void set_radio_state(RIL_RadioState new_state, RIL_Token t) {
342 // From header:
343 // Toggle radio on and off (for "airplane" mode)
344 // If the radio is is turned off/on the radio modem subsystem
345 // is expected return to an initialized state. For instance,
346 // any voice and data calls will be terminated and all associated
347 // lists emptied.
348 gDataCalls.clear();
349
350 gSimStatus = SIM_NOT_READY;
351 ALOGV("RIL_RadioState change %d to %d", gRadioPowerState, new_state);
352 gRadioPowerState = new_state;
353
354 if (new_state == RADIO_STATE_OFF) {
355 TearDownNetworkInterface();
356 }
357
358 if (t != NULL) {
359 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
360 }
361
362 gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
363 NULL, 0);
364
365 pollSIMState(NULL);
366 }
367
368 // returns 1 if on, 0 if off, and -1 on error
request_radio_power(void * data,size_t,RIL_Token t)369 static void request_radio_power(void* data, size_t /*datalen*/, RIL_Token t) {
370 int on = ((int*)data)[0];
371 set_radio_state(on ? RADIO_STATE_ON : RADIO_STATE_OFF, t);
372 }
373
374 // TODO(ender): this should be a class member. Move where it belongs.
375 struct CallState {
376 RIL_CallState state; // e.g. RIL_CALL_HOLDING;
377 bool isInternational;
378 bool isMobileTerminated;
379 bool isVoice;
380 bool isMultiParty;
381
382 std::string number;
383 std::string name;
384 std::string dtmf;
385
386 bool canPresentNumber;
387 bool canPresentName;
388
CallStateCallState389 CallState()
390 : state(RIL_CallState(0)),
391 isInternational(false),
392 isMobileTerminated(true),
393 isVoice(true),
394 isMultiParty(false),
395 canPresentNumber(true),
396 canPresentName(true) {}
397
CallStateCallState398 CallState(const std::string& number)
399 : state(RIL_CALL_INCOMING),
400 isInternational(false),
401 isMobileTerminated(true),
402 isVoice(true),
403 isMultiParty(false),
404 number(number),
405 name(number),
406 canPresentNumber(true),
407 canPresentName(true) {}
408
isBackgroundCallState409 bool isBackground() { return state == RIL_CALL_HOLDING; }
410
isActiveCallState411 bool isActive() { return state == RIL_CALL_ACTIVE; }
412
isDialingCallState413 bool isDialing() { return state == RIL_CALL_DIALING; }
414
isIncomingCallState415 bool isIncoming() { return state == RIL_CALL_INCOMING; }
416
isWaitingCallState417 bool isWaiting() { return state == RIL_CALL_WAITING; }
418
addDtmfDigitCallState419 void addDtmfDigit(char c) {
420 dtmf.push_back(c);
421 ALOGV("Call to %s: DTMF %s", number.c_str(), dtmf.c_str());
422 }
423
makeBackgroundCallState424 bool makeBackground() {
425 if (state == RIL_CALL_ACTIVE) {
426 state = RIL_CALL_HOLDING;
427 return true;
428 }
429
430 return false;
431 }
432
makeActiveCallState433 bool makeActive() {
434 if (state == RIL_CALL_INCOMING || state == RIL_CALL_WAITING ||
435 state == RIL_CALL_DIALING || state == RIL_CALL_HOLDING) {
436 state = RIL_CALL_ACTIVE;
437 return true;
438 }
439
440 return false;
441 }
442 };
443
444 static int gLastActiveCallIndex = 1;
445 static int gMicrophoneMute = 0;
446 static std::map<int, CallState> gActiveCalls;
447
request_get_current_calls(void *,size_t,RIL_Token t)448 static void request_get_current_calls(void* /*data*/, size_t /*datalen*/,
449 RIL_Token t) {
450 const int countCalls = gActiveCalls.size();
451
452 RIL_Call** pp_calls = (RIL_Call**)alloca(countCalls * sizeof(RIL_Call*));
453 RIL_Call* p_calls = (RIL_Call*)alloca(countCalls * sizeof(RIL_Call));
454
455 memset(p_calls, 0, countCalls * sizeof(RIL_Call));
456
457 /* init the pointer array */
458 for (int i = 0; i < countCalls; i++) {
459 pp_calls[i] = &(p_calls[i]);
460 }
461
462 // TODO(ender): This should be built from calls requested via RequestDial.
463 for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
464 iter != gActiveCalls.end(); ++iter, ++p_calls) {
465 p_calls->state = iter->second.state;
466 p_calls->index = iter->first;
467 p_calls->toa = iter->second.isInternational ? 145 : 129;
468 p_calls->isMpty = iter->second.isMultiParty;
469 p_calls->isMT = iter->second.isMobileTerminated;
470 p_calls->als = iter->first;
471 p_calls->isVoice = iter->second.isVoice;
472 p_calls->isVoicePrivacy = 0;
473 p_calls->number = strdup(iter->second.number.c_str());
474 p_calls->numberPresentation = iter->second.canPresentNumber ? 0 : 1;
475 p_calls->name = strdup(iter->second.name.c_str());
476 p_calls->namePresentation = iter->second.canPresentName ? 0 : 1;
477 p_calls->uusInfo = NULL;
478
479 ALOGV("Call to %s (%s): voice=%d mt=%d type=%d state=%d index=%d",
480 p_calls->name, p_calls->number, p_calls->isVoice, p_calls->isMT,
481 p_calls->toa, p_calls->state, p_calls->index);
482 }
483
484 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, pp_calls,
485 countCalls * sizeof(RIL_Call*));
486
487 ALOGV("Get Current calls: %d calls found.\n", countCalls);
488 }
489
simulate_pending_calls_answered(void *)490 static void simulate_pending_calls_answered(void* /*ignore*/) {
491 ALOGV("Simulating outgoing call answered.");
492 // This also resumes held calls.
493 for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
494 iter != gActiveCalls.end(); ++iter) {
495 if (iter->second.isDialing()) {
496 iter->second.makeActive();
497 }
498 }
499
500 // Only unsolicited here.
501 gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
502 NULL, 0);
503 }
504
request_dial(void * data,size_t,RIL_Token t)505 static void request_dial(void* data, size_t /*datalen*/, RIL_Token t) {
506 RIL_Dial* p_dial = (RIL_Dial*)data;
507
508 ALOGV("Dialing %s, number presentation is %s.", p_dial->address,
509 (p_dial->clir == 0) ? "defined by operator"
510 : (p_dial->clir == 1) ? "allowed" : "restricted");
511
512 CallState state(p_dial->address);
513 state.isMobileTerminated = false;
514 state.state = RIL_CALL_DIALING;
515
516 switch (p_dial->clir) {
517 case 0: // default
518 case 1: // allow
519 state.canPresentNumber = true;
520 break;
521
522 case 2: // restrict
523 state.canPresentNumber = false;
524 break;
525 }
526
527 int call_index = gLastActiveCallIndex++;
528 gActiveCalls[call_index] = state;
529
530 static const struct timeval kAnswerTime = {5, 0};
531 gce_ril_env->RequestTimedCallback(simulate_pending_calls_answered, NULL,
532 &kAnswerTime);
533
534 // success or failure is ignored by the upper layer here.
535 // it will call GET_CURRENT_CALLS and determine success that way
536 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
537 }
538
request_set_mute(void * data,size_t,RIL_Token t)539 void request_set_mute(void* data, size_t /*datalen*/, RIL_Token t) {
540 gMicrophoneMute = ((int*)data)[0] != 0;
541 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
542 }
543
request_get_mute(RIL_Token t)544 void request_get_mute(RIL_Token t) {
545 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gMicrophoneMute,
546 sizeof(gMicrophoneMute));
547 }
548
549 // TODO(ender): this should be a class member. Move where it belongs.
550 struct SmsMessage {
551 enum SmsStatus { kUnread = 0, kRead = 1, kUnsent = 2, kSent = 3 };
552
553 std::string message;
554 SmsStatus status;
555 };
556
557 static int gNextMessageId = 1;
558 static std::map<int, SmsMessage> gMessagesOnSimCard;
559
request_write_sms_to_sim(void * data,size_t,RIL_Token t)560 static void request_write_sms_to_sim(void* data, size_t /*datalen*/,
561 RIL_Token t) {
562 RIL_SMS_WriteArgs* p_args = (RIL_SMS_WriteArgs*)data;
563
564 SmsMessage message;
565 message.status = SmsMessage::SmsStatus(p_args->status);
566 message.message = p_args->pdu;
567
568 ALOGV("Storing SMS message: '%s' with state: %s.", message.message.c_str(),
569 (message.status < SmsMessage::kUnsent)
570 ? ((message.status == SmsMessage::kRead) ? "READ" : "UNREAD")
571 : ((message.status == SmsMessage::kSent) ? "SENT" : "UNSENT"));
572
573 // TODO(ender): simulate SIM FULL?
574 int index = gNextMessageId++;
575 gMessagesOnSimCard[index] = message;
576
577 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &index, sizeof(index));
578 }
579
request_delete_sms_on_sim(void * data,size_t,RIL_Token t)580 static void request_delete_sms_on_sim(void* data, size_t /*datalen*/,
581 RIL_Token t) {
582 int index = *(int*)data;
583
584 ALOGV("Delete SMS message %d", index);
585
586 if (gMessagesOnSimCard.erase(index) == 0) {
587 // No such message
588 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
589 return;
590 }
591
592 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
593 }
594
request_hangup(void * data,size_t,RIL_Token t)595 static void request_hangup(void* data, size_t /*datalen*/, RIL_Token t) {
596 int* p_line = (int*)data;
597
598 ALOGV("Hanging up call %d.", *p_line);
599 std::map<int, CallState>::iterator iter = gActiveCalls.find(*p_line);
600
601 if (iter == gActiveCalls.end()) {
602 ALOGV("No such call: %d.", *p_line);
603 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
604 } else {
605 gActiveCalls.erase(iter);
606 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
607 }
608 }
609
request_hangup_waiting(void *,size_t,RIL_Token t)610 static void request_hangup_waiting(void* /*data*/, size_t /*datalen*/,
611 RIL_Token t) {
612 ALOGV("Hanging up background/held calls.");
613 for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
614 iter != gActiveCalls.end();) {
615 if (iter->second.isBackground()) {
616 // C++98 -- std::map::erase doesn't return iterator.
617 std::map<int, CallState>::iterator temp = iter++;
618 gActiveCalls.erase(temp);
619 } else {
620 ++iter;
621 }
622 }
623 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
624 }
625
request_hangup_current(RIL_Token t)626 static void request_hangup_current(RIL_Token t) {
627 ALOGV("Hanging up foreground/active calls.");
628 // This also resumes held calls.
629 for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
630 iter != gActiveCalls.end();) {
631 if (iter->second.isBackground()) {
632 iter->second.makeActive();
633 ++iter;
634 } else {
635 // C++98 -- std::map::erase doesn't return iterator.
636 std::map<int, CallState>::iterator temp = iter++;
637 gActiveCalls.erase(temp);
638 }
639 }
640 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
641 }
642
request_switch_current_and_waiting(RIL_Token t)643 static void request_switch_current_and_waiting(RIL_Token t) {
644 ALOGV("Toggle foreground and background calls.");
645 // TODO(ender): fix all states. Max 2 calls.
646 // BEFORE AFTER
647 // Call 1 Call 2 Call 1 Call 2
648 // ACTIVE HOLDING HOLDING ACTIVE
649 // ACTIVE WAITING HOLDING ACTIVE
650 // HOLDING WAITING HOLDING ACTIVE
651 // ACTIVE IDLE HOLDING IDLE
652 // IDLE IDLE IDLE IDLE
653 for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
654 iter != gActiveCalls.end(); ++iter) {
655 // TODO(ender): call could also be waiting or dialing or...
656 if (iter->second.isBackground()) {
657 iter->second.makeActive();
658 } else {
659 iter->second.makeBackground();
660 }
661 }
662 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
663 }
664
request_answer_incoming(RIL_Token t)665 static void request_answer_incoming(RIL_Token t) {
666 ALOGV("Answering incoming call.");
667
668 // There's two types of incoming calls:
669 // - incoming: we are receiving this call while nothing happens,
670 // - waiting: we are receiving this call while we're already talking.
671 // We only accept the incoming ones.
672 for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
673 iter != gActiveCalls.end(); ++iter) {
674 if (iter->second.isIncoming()) {
675 iter->second.makeActive();
676 }
677 }
678 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
679 }
680
request_combine_multiparty_call(void *,size_t,RIL_Token t)681 static void request_combine_multiparty_call(void* /*data*/, size_t /*datalen*/,
682 RIL_Token t) {
683 ALOGW("Conference calls are not supported.");
684 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
685 }
686
request_split_multiparty_call(void *,size_t,RIL_Token t)687 static void request_split_multiparty_call(void* /*data*/, size_t /*datalen*/,
688 RIL_Token t) {
689 ALOGW("Conference calls are not supported.");
690 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
691 }
692
request_udub_on_incoming_calls(RIL_Token t)693 static void request_udub_on_incoming_calls(RIL_Token t) {
694 // UDUB = user determined user busy.
695 // We don't exactly do that. We simply drop these calls.
696 ALOGV("Reporting busy signal to incoming calls.");
697 for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
698 iter != gActiveCalls.end();) {
699 // If we have an incoming call, there should be no waiting call.
700 // If we have a waiting call, then previous incoming call has been answered.
701 if (iter->second.isIncoming() || iter->second.isWaiting()) {
702 // C++98 -- std::map::erase doesn't return iterator.
703 std::map<int, CallState>::iterator temp = iter++;
704 gActiveCalls.erase(temp);
705 } else {
706 ++iter;
707 }
708 }
709 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
710 }
711
request_send_dtmf(void * data,size_t,RIL_Token t)712 static void request_send_dtmf(void* data, size_t /*datalen*/, RIL_Token t) {
713 char c = ((char*)data)[0];
714 ALOGV("Sending DTMF digit '%c'", c);
715
716 for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
717 iter != gActiveCalls.end(); ++iter) {
718 if (iter->second.isActive()) {
719 iter->second.addDtmfDigit(c);
720 break;
721 }
722 }
723
724 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
725 }
726
request_send_dtmf_stop(RIL_Token t)727 static void request_send_dtmf_stop(RIL_Token t) {
728 ALOGV("DTMF tone end.");
729
730 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
731 }
732
733 // Check SignalStrength.java file for more details on how these map to signal
734 // strength bars.
735 const int kGatewaySignalStrengthMin = 4;
736 const int kGatewaySignalStrengthMax = 30;
737 const int kCDMASignalStrengthMin = -110;
738 const int kCDMASignalStrengthMax = -60;
739 const int kEVDOSignalStrengthMin = -160;
740 const int kEVDOSignalStrengthMax = -70;
741 const int kLTESignalStrengthMin = 4;
742 const int kLTESignalStrengthMax = 30;
743
744 static int gGatewaySignalStrength = kGatewaySignalStrengthMax;
745 static int gCDMASignalStrength = kCDMASignalStrengthMax;
746 static int gEVDOSignalStrength = kEVDOSignalStrengthMax;
747 static int gLTESignalStrength = kLTESignalStrengthMax;
748
request_signal_strength(void *,size_t,RIL_Token t)749 static void request_signal_strength(void* /*data*/, size_t /*datalen*/,
750 RIL_Token t) {
751 // TODO(ender): possible to support newer APIs here.
752 RIL_SignalStrength_v10 strength;
753
754 gGatewaySignalStrength += (rand() % 3 - 1);
755 gCDMASignalStrength += (rand() % 3 - 1);
756 gEVDOSignalStrength += (rand() % 3 - 1);
757 gLTESignalStrength += (rand() % 3 - 1);
758
759 if (gGatewaySignalStrength < kGatewaySignalStrengthMin)
760 gGatewaySignalStrength = kGatewaySignalStrengthMin;
761 if (gGatewaySignalStrength > kGatewaySignalStrengthMax)
762 gGatewaySignalStrength = kGatewaySignalStrengthMax;
763 if (gCDMASignalStrength < kCDMASignalStrengthMin)
764 gCDMASignalStrength = kCDMASignalStrengthMin;
765 if (gCDMASignalStrength > kCDMASignalStrengthMax)
766 gCDMASignalStrength = kCDMASignalStrengthMax;
767 if (gEVDOSignalStrength < kEVDOSignalStrengthMin)
768 gEVDOSignalStrength = kEVDOSignalStrengthMin;
769 if (gEVDOSignalStrength > kEVDOSignalStrengthMax)
770 gEVDOSignalStrength = kEVDOSignalStrengthMax;
771 if (gLTESignalStrength < kLTESignalStrengthMin)
772 gLTESignalStrength = kLTESignalStrengthMin;
773 if (gLTESignalStrength > kLTESignalStrengthMax)
774 gLTESignalStrength = kLTESignalStrengthMax;
775
776 strength.GW_SignalStrength.signalStrength = gGatewaySignalStrength;
777 strength.GW_SignalStrength.bitErrorRate = 0; // 0..7%
778
779 strength.CDMA_SignalStrength.dbm = gCDMASignalStrength;
780 strength.CDMA_SignalStrength.ecio = 0; // Ec/Io; keep high to use dbm.
781
782 strength.EVDO_SignalStrength.dbm = gEVDOSignalStrength;
783 strength.EVDO_SignalStrength.ecio = 0; // Ec/Io; keep high to use dbm.
784
785 strength.LTE_SignalStrength.signalStrength = gLTESignalStrength;
786 strength.LTE_SignalStrength.rsrp = INT_MAX; // Invalid = Use signalStrength.
787 strength.LTE_SignalStrength.rsrq = INT_MAX; // Invalid = Use signalStrength.
788 strength.LTE_SignalStrength.rssnr = INT_MAX; // Invalid = Use signalStrength.
789 strength.LTE_SignalStrength.cqi = INT_MAX; // Invalid = Use signalStrength.
790
791 ALOGV("Reporting signal strength: GW=%d CDMA=%d EVDO=%d LTE=%d",
792 gGatewaySignalStrength, gCDMASignalStrength, gEVDOSignalStrength,
793 gLTESignalStrength);
794
795 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &strength, sizeof(strength));
796 }
797
798 static std::map<RIL_PreferredNetworkType, int> gModemSupportedNetworkTypes;
799
init_modem_supported_network_types()800 static void init_modem_supported_network_types() {
801 gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA] = MDM_GSM | MDM_WCDMA;
802 gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_ONLY] = MDM_GSM;
803 gModemSupportedNetworkTypes[PREF_NET_TYPE_WCDMA] = MDM_WCDMA;
804 gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA_AUTO] =
805 MDM_GSM | MDM_WCDMA;
806 gModemSupportedNetworkTypes[PREF_NET_TYPE_CDMA_EVDO_AUTO] =
807 MDM_CDMA | MDM_EVDO;
808 gModemSupportedNetworkTypes[PREF_NET_TYPE_CDMA_ONLY] = MDM_CDMA;
809 gModemSupportedNetworkTypes[PREF_NET_TYPE_EVDO_ONLY] = MDM_EVDO;
810 gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO] =
811 MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO;
812 gModemSupportedNetworkTypes[PREF_NET_TYPE_LTE_CDMA_EVDO] =
813 MDM_LTE | MDM_CDMA | MDM_EVDO;
814 gModemSupportedNetworkTypes[PREF_NET_TYPE_LTE_GSM_WCDMA] =
815 MDM_LTE | MDM_GSM | MDM_WCDMA;
816 gModemSupportedNetworkTypes[PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA] =
817 MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA;
818 gModemSupportedNetworkTypes[PREF_NET_TYPE_LTE_ONLY] = MDM_LTE;
819 }
820
821 static std::map<RIL_PreferredNetworkType, int> gModemTechnologies;
822
823 RIL_RadioTechnology gDataTechnologiesPreferenceOrder[] = {
824 RADIO_TECH_LTE, RADIO_TECH_EHRPD, RADIO_TECH_HSPAP, RADIO_TECH_HSPA,
825 RADIO_TECH_HSDPA, RADIO_TECH_HSUPA, RADIO_TECH_EVDO_B, RADIO_TECH_EVDO_A,
826 RADIO_TECH_EVDO_0, RADIO_TECH_1xRTT, RADIO_TECH_UMTS, RADIO_TECH_EDGE,
827 RADIO_TECH_GPRS};
828
829 RIL_RadioTechnology gVoiceTechnologiesPreferenceOrder[] = {
830 RADIO_TECH_LTE, RADIO_TECH_EHRPD, RADIO_TECH_EVDO_B, RADIO_TECH_EVDO_A,
831 RADIO_TECH_EVDO_0, RADIO_TECH_1xRTT, RADIO_TECH_IS95B, RADIO_TECH_IS95A,
832 RADIO_TECH_UMTS, RADIO_TECH_GSM};
833
init_modem_technologies()834 static void init_modem_technologies() {
835 gModemTechnologies[PREF_NET_TYPE_GSM_WCDMA] =
836 (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
837 (1 << RADIO_TECH_UMTS);
838 gModemTechnologies[PREF_NET_TYPE_GSM_ONLY] =
839 (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE);
840 gModemTechnologies[PREF_NET_TYPE_WCDMA] =
841 (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
842 gModemTechnologies[PREF_NET_TYPE_GSM_WCDMA_AUTO] =
843 (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
844 (1 << RADIO_TECH_UMTS);
845 gModemTechnologies[PREF_NET_TYPE_CDMA_EVDO_AUTO] =
846 (1 << RADIO_TECH_IS95A) | (1 << RADIO_TECH_IS95B) |
847 (1 << RADIO_TECH_1xRTT) | (1 << RADIO_TECH_EVDO_0) |
848 (1 << RADIO_TECH_EVDO_A) | (1 << RADIO_TECH_HSDPA) |
849 (1 << RADIO_TECH_HSUPA) | (1 << RADIO_TECH_HSPA) |
850 (1 << RADIO_TECH_EVDO_B);
851 gModemTechnologies[PREF_NET_TYPE_CDMA_ONLY] = (1 << RADIO_TECH_IS95A) |
852 (1 << RADIO_TECH_IS95B) |
853 (1 << RADIO_TECH_1xRTT);
854 gModemTechnologies[PREF_NET_TYPE_EVDO_ONLY] =
855 (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
856 (1 << RADIO_TECH_EVDO_A) | (1 << RADIO_TECH_HSDPA) |
857 (1 << RADIO_TECH_HSUPA) | (1 << RADIO_TECH_HSPA) |
858 (1 << RADIO_TECH_EVDO_B);
859 gModemTechnologies[PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO] =
860 (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
861 (1 << RADIO_TECH_UMTS) | (1 << RADIO_TECH_IS95A) |
862 (1 << RADIO_TECH_IS95B) | (1 << RADIO_TECH_1xRTT) |
863 (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
864 (1 << RADIO_TECH_HSDPA) | (1 << RADIO_TECH_HSUPA) |
865 (1 << RADIO_TECH_HSPA) | (1 << RADIO_TECH_EVDO_B);
866 gModemTechnologies[PREF_NET_TYPE_LTE_CDMA_EVDO] =
867 (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) |
868 (1 << RADIO_TECH_EHRPD) | (1 << RADIO_TECH_IS95A) |
869 (1 << RADIO_TECH_IS95B) | (1 << RADIO_TECH_1xRTT) |
870 (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
871 (1 << RADIO_TECH_HSDPA) | (1 << RADIO_TECH_HSUPA) |
872 (1 << RADIO_TECH_HSPA) | (1 << RADIO_TECH_EVDO_B);
873 gModemTechnologies[PREF_NET_TYPE_LTE_GSM_WCDMA] =
874 (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) |
875 (1 << RADIO_TECH_EHRPD) | (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) |
876 (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
877
878 gModemTechnologies[PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA] =
879 (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) |
880 (1 << RADIO_TECH_EHRPD) | (1 << RADIO_TECH_IS95A) |
881 (1 << RADIO_TECH_IS95B) | (1 << RADIO_TECH_1xRTT) |
882 (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
883 (1 << RADIO_TECH_HSDPA) | (1 << RADIO_TECH_HSUPA) |
884 (1 << RADIO_TECH_HSPA) | (1 << RADIO_TECH_EVDO_B) |
885 (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
886 (1 << RADIO_TECH_UMTS);
887 gModemTechnologies[PREF_NET_TYPE_LTE_ONLY] =
888 (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) | (1 << RADIO_TECH_EHRPD);
889 }
890
891 static const RIL_PreferredNetworkType gModemDefaultType =
892 PREF_NET_TYPE_LTE_GSM_WCDMA;
893 static RIL_PreferredNetworkType gModemCurrentType = gModemDefaultType;
894 static RIL_RadioTechnology gModemVoiceTechnology = RADIO_TECH_LTE;
895
896 // Report technology change.
897 // Select best technology from the list of supported techs.
898 // Demotes RADIO_TECH_GSM as it's voice-only.
getBestDataTechnology(RIL_PreferredNetworkType network_type)899 static RIL_RadioTechnology getBestDataTechnology(
900 RIL_PreferredNetworkType network_type) {
901 RIL_RadioTechnology technology = RADIO_TECH_GPRS;
902
903 std::map<RIL_PreferredNetworkType, int>::iterator iter =
904 gModemTechnologies.find(network_type);
905
906 ALOGV("Searching for best data technology for network type %d...",
907 network_type);
908
909 // Find which technology bits are lit. Pick the top most.
910 for (size_t tech_index = 0;
911 tech_index < sizeof(gDataTechnologiesPreferenceOrder) /
912 sizeof(gDataTechnologiesPreferenceOrder[0]);
913 ++tech_index) {
914 if (iter->second & (1 << gDataTechnologiesPreferenceOrder[tech_index])) {
915 technology = gDataTechnologiesPreferenceOrder[tech_index];
916 break;
917 }
918 }
919
920 ALOGV("Best data technology: %d.", technology);
921 return technology;
922 }
923
getBestVoiceTechnology(RIL_PreferredNetworkType network_type)924 static RIL_RadioTechnology getBestVoiceTechnology(
925 RIL_PreferredNetworkType network_type) {
926 RIL_RadioTechnology technology = RADIO_TECH_GSM;
927
928 std::map<RIL_PreferredNetworkType, int>::iterator iter =
929 gModemTechnologies.find(network_type);
930
931 ALOGV("Searching for best voice technology for network type %d...",
932 network_type);
933
934 // Find which technology bits are lit. Pick the top most.
935 for (size_t tech_index = 0;
936 tech_index < sizeof(gVoiceTechnologiesPreferenceOrder) /
937 sizeof(gVoiceTechnologiesPreferenceOrder[0]);
938 ++tech_index) {
939 if (iter->second & (1 << gVoiceTechnologiesPreferenceOrder[tech_index])) {
940 technology = gVoiceTechnologiesPreferenceOrder[tech_index];
941 break;
942 }
943 }
944
945 ALOGV("Best voice technology: %d.", technology);
946 return technology;
947 }
948
setRadioTechnology(RIL_PreferredNetworkType network_type)949 static void setRadioTechnology(RIL_PreferredNetworkType network_type) {
950 RIL_RadioTechnology technology = getBestVoiceTechnology(network_type);
951
952 if (technology != gModemVoiceTechnology) {
953 gModemVoiceTechnology = technology;
954 gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
955 &gModemVoiceTechnology,
956 sizeof(gModemVoiceTechnology));
957 }
958 }
959
request_get_radio_capability(RIL_Token t)960 static void request_get_radio_capability(RIL_Token t) {
961 ALOGV("Requesting radio capability.");
962 RIL_RadioCapability rc;
963 rc.version = RIL_RADIO_CAPABILITY_VERSION;
964 rc.session = 1;
965 rc.phase = RC_PHASE_CONFIGURED;
966 rc.rat = RAF_HSPAP;
967 strncpy(rc.logicalModemUuid, "com.google.cvdgce1.modem", MAX_UUID_LENGTH);
968 rc.status = RC_STATUS_SUCCESS;
969 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &rc, sizeof(rc));
970 }
971
request_set_radio_capability(void * data,size_t datalen,RIL_Token t)972 static void request_set_radio_capability(void* data, size_t datalen,
973 RIL_Token t) {
974 RIL_RadioCapability* rc = (RIL_RadioCapability*)data;
975 ALOGV(
976 "RadioCapability version %d session %d phase %d rat %d "
977 "logicalModemUuid %s status %d",
978 rc->version, rc->session, rc->phase, rc->rat, rc->logicalModemUuid,
979 rc->status);
980 // TODO(ender): do something about these numbers.
981 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, rc, datalen);
982 }
983
request_set_preferred_network_type(int,void * data,size_t,RIL_Token t)984 static void request_set_preferred_network_type(int /*request*/, void* data,
985 size_t /*datalen*/,
986 RIL_Token t) {
987 RIL_PreferredNetworkType desired_type = *(RIL_PreferredNetworkType*)(data);
988
989 // TODO(ender): telephony still believes this phone is GSM only.
990 ALOGV("Requesting modem technology change -> %d", desired_type);
991
992 if (gModemSupportedNetworkTypes.find(desired_type) ==
993 gModemSupportedNetworkTypes.end()) {
994 desired_type = gModemSupportedNetworkTypes.begin()->first;
995 }
996
997 if (gModemCurrentType == desired_type) {
998 ALOGV("Modem technology already set to %d.", desired_type);
999 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1000 return;
1001 }
1002
1003 int supported_technologies = gModemSupportedNetworkTypes[gModemDefaultType];
1004 int desired_technologies = gModemSupportedNetworkTypes[desired_type];
1005
1006 ALOGV("Requesting modem technology change %d -> %d", gModemCurrentType,
1007 desired_type);
1008
1009 // Check if we support this technology.
1010 if ((supported_technologies & desired_technologies) != desired_technologies) {
1011 ALOGV("Desired technology is not supported.");
1012 gce_ril_env->OnRequestComplete(t, RIL_E_MODE_NOT_SUPPORTED, NULL, 0);
1013 return;
1014 }
1015
1016 gModemCurrentType = desired_type;
1017 setRadioTechnology(desired_type);
1018 ALOGV("Technology change successful.");
1019 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1020 }
1021
request_get_preferred_network_type(int,void *,size_t,RIL_Token t)1022 static void request_get_preferred_network_type(int /*request*/, void* /*data*/,
1023 size_t /*datalen*/,
1024 RIL_Token t) {
1025 gce_ril_env->OnRequestComplete(
1026 t, RIL_E_SUCCESS,
1027 const_cast<RIL_PreferredNetworkType*>(&gModemDefaultType),
1028 sizeof(gModemDefaultType));
1029 }
1030
1031 enum RegistrationState {
1032 kUnregistered = 0,
1033 kRegisteredInHomeNetwork = 1,
1034 kSearchingForOperators = 2,
1035 kRegistrationDenied = 3,
1036 kUnknown = 4,
1037 kRegisteredInRoamingMode = 5,
1038
1039 kUnregistered_EmergencyCallsOnly = 10,
1040 kSearchingForOperators_EmergencyCallsOnly = 12,
1041 kRegistrationDenied_EmergencyCallsOnly = 13,
1042 kUnknown_EmergencyCallsOnly = 14
1043 };
1044
1045 static const char kCdmaMobileDeviceNumber[] = "5551234567";
1046 static const char kCdmaSID[] = "123";
1047 static const char kCdmaNID[] = "65535"; // special: indicates free roaming.
1048
request_registration_state(int request,void *,size_t,RIL_Token t)1049 static void request_registration_state(int request, void* /*data*/,
1050 size_t /*datalen*/, RIL_Token t) {
1051 char** responseStr = NULL;
1052 int numElements = 0;
1053
1054 // See RIL_REQUEST_VOICE_REGISTRATION_STATE and
1055 // RIL_REQUEST_DATA_REGISTRATION_STATE.
1056 numElements = (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) ? 15 : 6;
1057 responseStr = (char**)malloc(numElements * sizeof(char*));
1058
1059 asprintf(&responseStr[0], "%d", kRegisteredInHomeNetwork);
1060 responseStr[1] = NULL; // LAC - needed for GSM / WCDMA only.
1061 responseStr[2] = NULL; // CID - needed for GSM / WCDMA only.
1062
1063 // This is (and always has been) a huge memory leak.
1064 if (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
1065 ALOGV("Requesting voice registration state.");
1066 asprintf(&responseStr[3], "%d", getBestVoiceTechnology(gModemCurrentType));
1067 responseStr[4] = strdup("1"); // BSID
1068 responseStr[5] = strdup("123"); // Latitude
1069 responseStr[6] = strdup("222"); // Longitude
1070 responseStr[7] = strdup("0"); // CSS Indicator
1071 responseStr[8] = strdup(kCdmaSID); // SID
1072 responseStr[9] = strdup(kCdmaNID); // NID
1073 responseStr[10] = strdup("0"); // Roaming indicator
1074 responseStr[11] = strdup("1"); // System is in PRL
1075 responseStr[12] = strdup("0"); // Default Roaming indicator
1076 responseStr[13] = strdup("0"); // Reason for denial
1077 responseStr[14] = strdup("0"); // Primary Scrambling Code of Current
1078 } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
1079 ALOGV("Requesting data registration state.");
1080 asprintf(&responseStr[3], "%d", getBestDataTechnology(gModemCurrentType));
1081 responseStr[4] = strdup(""); // DataServiceDenyReason
1082 responseStr[5] = strdup("1"); // Max simultaneous data calls.
1083 } else {
1084 ALOGV("Unexpected request type: %d", request);
1085 return;
1086 }
1087
1088 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, responseStr,
1089 numElements * sizeof(responseStr));
1090 }
1091
request_baseband_version(RIL_Token t)1092 static void request_baseband_version(RIL_Token t) {
1093 const char* response_str = "CVD_R1.0.0";
1094
1095 ALOGV("Requested phone baseband version.");
1096
1097 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, strdup(response_str),
1098 sizeof(response_str));
1099 }
1100
1101 // Returns true, if modem is CDMA capable.
isCDMA()1102 static bool isCDMA() {
1103 switch (gModemCurrentType) {
1104 case PREF_NET_TYPE_GSM_WCDMA:
1105 case PREF_NET_TYPE_GSM_ONLY:
1106 case PREF_NET_TYPE_WCDMA:
1107 case PREF_NET_TYPE_GSM_WCDMA_AUTO:
1108 case PREF_NET_TYPE_LTE_GSM_WCDMA:
1109 case PREF_NET_TYPE_LTE_ONLY:
1110 return false;
1111
1112 case PREF_NET_TYPE_CDMA_EVDO_AUTO:
1113 case PREF_NET_TYPE_CDMA_ONLY:
1114 case PREF_NET_TYPE_EVDO_ONLY:
1115 case PREF_NET_TYPE_LTE_CDMA_EVDO:
1116 case PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA:
1117 case PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO:
1118 return true;
1119 default:
1120 break;
1121 }
1122
1123 ALOGE("INVALID MODEM TYPE: %d", gModemCurrentType);
1124 return false;
1125 }
1126
1127 // Returns true, if modem is GSM capable.
1128 // Note, this is not same as !isCDMA().
isGSM()1129 static bool isGSM() {
1130 switch (gModemCurrentType) {
1131 case PREF_NET_TYPE_GSM_WCDMA:
1132 case PREF_NET_TYPE_GSM_ONLY:
1133 case PREF_NET_TYPE_WCDMA:
1134 case PREF_NET_TYPE_GSM_WCDMA_AUTO:
1135 case PREF_NET_TYPE_LTE_GSM_WCDMA:
1136 case PREF_NET_TYPE_LTE_ONLY:
1137 case PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO:
1138 return true;
1139
1140 case PREF_NET_TYPE_CDMA_EVDO_AUTO:
1141 case PREF_NET_TYPE_CDMA_ONLY:
1142 case PREF_NET_TYPE_EVDO_ONLY:
1143 case PREF_NET_TYPE_LTE_CDMA_EVDO:
1144 case PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA:
1145 return false;
1146 default:
1147 break;
1148 }
1149
1150 ALOGE("INVALID MODEM TYPE: %d", gModemCurrentType);
1151 return false;
1152 }
1153
1154 static const char gIdentityGsmImei[] = "12345678902468"; // Luhn cksum = 0.
1155 static const char gIdentityGsmImeiSv[] = "01"; // Arbitrary version.
1156 static const char gIdentityCdmaEsn[] = "A0123456"; // 8 digits, ^[A-F].*
1157 static const char gIdentityCdmaMeid[] =
1158 "A0123456789012"; // 14 digits, ^[A-F].*
1159
request_get_imei(RIL_Token t)1160 static void request_get_imei(RIL_Token t) {
1161 ALOGV("Requesting IMEI");
1162 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
1163 const_cast<char*>(gIdentityGsmImei),
1164 strlen(gIdentityGsmImei));
1165 }
1166
request_get_imei_sv(RIL_Token t)1167 static void request_get_imei_sv(RIL_Token t) {
1168 ALOGV("Requesting IMEI SV");
1169 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
1170 const_cast<char*>(gIdentityGsmImeiSv),
1171 strlen(gIdentityGsmImeiSv));
1172 }
1173
request_device_identity(int,void *,size_t,RIL_Token t)1174 static void request_device_identity(int /*request*/, void* /*data*/,
1175 size_t /*datalen*/, RIL_Token t) {
1176 char* response[4] = {NULL};
1177
1178 ALOGV("Requesting device identity...");
1179
1180 if (isCDMA()) {
1181 response[2] = strdup(&gIdentityCdmaEsn[0]);
1182 response[3] = strdup(&gIdentityCdmaMeid[0]);
1183 }
1184
1185 if (isGSM()) {
1186 response[0] = strdup(&gIdentityGsmImei[0]);
1187 response[1] = strdup(&gIdentityGsmImeiSv[0]);
1188 }
1189
1190 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
1191
1192 free(response[0]);
1193 free(response[1]);
1194 }
1195
1196 // Let's pretend we have SIM for CDMA (by default).
1197 static bool gCdmaHasSim = true;
1198 static RIL_CdmaSubscriptionSource gCdmaSubscriptionType =
1199 CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM;
1200
request_cdma_get_subscription_source(int,void *,size_t,RIL_Token t)1201 static void request_cdma_get_subscription_source(int /*request*/,
1202 void* /*data*/,
1203 size_t /*datalen*/,
1204 RIL_Token t) {
1205 ALOGV("Requesting CDMA Subscription source.");
1206
1207 if (!isCDMA()) {
1208 // No such radio.
1209 gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1210 return;
1211 }
1212
1213 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gCdmaSubscriptionType,
1214 sizeof(gCdmaSubscriptionType));
1215 }
1216
request_cdma_set_subscription_source(int,void * data,size_t,RIL_Token t)1217 static void request_cdma_set_subscription_source(int /*request*/, void* data,
1218 size_t /*datalen*/,
1219 RIL_Token t) {
1220 ALOGV("Setting CDMA Subscription source.");
1221
1222 if (!isCDMA()) {
1223 // No such radio.
1224 gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1225 return;
1226 }
1227
1228 RIL_CdmaSubscriptionSource new_source = *(RIL_CdmaSubscriptionSource*)(data);
1229
1230 if (new_source == CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM && !gCdmaHasSim) {
1231 // No such radio.
1232 gce_ril_env->OnRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0);
1233 return;
1234 }
1235
1236 ALOGV("Changed CDMA subscription type from %d to %d", gCdmaSubscriptionType,
1237 new_source);
1238 gCdmaSubscriptionType = new_source;
1239
1240 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1241 gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
1242 &gCdmaSubscriptionType,
1243 sizeof(gCdmaSubscriptionType));
1244 }
1245
request_cdma_subscription(int,void *,size_t,RIL_Token t)1246 static void request_cdma_subscription(int /*request*/, void* /*data*/,
1247 size_t /*datalen*/, RIL_Token t) {
1248 ALOGV("Requesting CDMA Subscription.");
1249
1250 if (!isCDMA()) {
1251 // No such radio.
1252 gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1253 return;
1254 }
1255
1256 char* responseStr[5] = {NULL};
1257 responseStr[0] = strdup(&kCdmaMobileDeviceNumber[0]); // MDN
1258 responseStr[1] = strdup(&kCdmaSID[0]); // SID
1259 responseStr[2] = strdup(&kCdmaNID[0]); // NID
1260 responseStr[3] = strdup(&kCdmaMobileDeviceNumber[0]); // MIN
1261 responseStr[4] = strdup("1"); // PRL Version
1262 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, responseStr,
1263 sizeof(responseStr));
1264 }
1265
1266 static const int gMaxConcurrentVoiceCalls = 4;
1267 static const int gMaxConcurrentDataCalls = 4;
1268 static const int gMaxConcurrentStandbyConnections = 4;
1269
request_hardware_config(RIL_Token t)1270 static void request_hardware_config(RIL_Token t) {
1271 RIL_HardwareConfig hw_cfg[2];
1272
1273 ALOGV("Requesting hardware configuration.");
1274
1275 strncpy(hw_cfg[0].uuid, "com.google.cvdgce1.modem", sizeof(hw_cfg[0].uuid));
1276 strncpy(hw_cfg[1].uuid, "com.google.cvdgce1.sim", sizeof(hw_cfg[1].uuid));
1277
1278 int technologies = 0; // = unknown.
1279 std::map<RIL_PreferredNetworkType, int>::iterator iter =
1280 gModemTechnologies.find(gModemDefaultType);
1281 if (iter != gModemTechnologies.end()) {
1282 technologies = iter->second;
1283 }
1284
1285 hw_cfg[0].type = RIL_HARDWARE_CONFIG_MODEM;
1286 hw_cfg[0].state = RIL_HARDWARE_CONFIG_STATE_ENABLED;
1287 hw_cfg[0].cfg.modem.rilModel = 0;
1288 hw_cfg[0].cfg.modem.rat = technologies;
1289 hw_cfg[0].cfg.modem.maxVoice = gMaxConcurrentVoiceCalls;
1290 hw_cfg[0].cfg.modem.maxData = gMaxConcurrentDataCalls;
1291 hw_cfg[0].cfg.modem.maxStandby = gMaxConcurrentStandbyConnections;
1292
1293 hw_cfg[1].type = RIL_HARDWARE_CONFIG_SIM;
1294 hw_cfg[1].state = RIL_HARDWARE_CONFIG_STATE_ENABLED;
1295 memcpy(hw_cfg[1].cfg.sim.modemUuid, hw_cfg[0].uuid,
1296 sizeof(hw_cfg[1].cfg.sim.modemUuid));
1297
1298 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &hw_cfg, sizeof(hw_cfg));
1299 }
1300
1301 // 0 = Home network only, 1 = preferred networks only, 2 = all networks.
1302 static int gCdmaRoamingPreference = 2;
1303
request_cdma_get_roaming_preference(int,void *,size_t,RIL_Token t)1304 static void request_cdma_get_roaming_preference(int /*request*/, void* /*data*/,
1305 size_t /*datalen*/,
1306 RIL_Token t) {
1307 if (!isCDMA()) {
1308 // No such radio.
1309 gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1310 return;
1311 }
1312
1313 ALOGV("Requesting CDMA Roaming preference");
1314
1315 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gCdmaRoamingPreference,
1316 sizeof(gCdmaRoamingPreference));
1317 }
1318
request_cdma_set_roaming_preference(int,void * data,size_t,RIL_Token t)1319 static void request_cdma_set_roaming_preference(int /*request*/, void* data,
1320 size_t /*datalen*/,
1321 RIL_Token t) {
1322 if (!isCDMA()) {
1323 // No such radio.
1324 gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1325 return;
1326 }
1327
1328 int pref = *(int*)data;
1329 ALOGV("Changing CDMA roaming preference: %d -> %d", gCdmaRoamingPreference,
1330 pref);
1331
1332 if ((pref < 0) || (pref > 2)) {
1333 ALOGV("Unsupported roaming preference: %d", pref);
1334 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1335 return;
1336 }
1337
1338 gCdmaRoamingPreference = pref;
1339 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1340 }
1341
request_send_ussd(void *,size_t,RIL_Token t)1342 static void request_send_ussd(void* /*data*/, size_t /*datalen*/, RIL_Token t) {
1343 ALOGV("Sending USSD code is currently not supported");
1344 // TODO(ender): support this feature
1345 gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
1346 }
1347
request_cancel_ussd(RIL_Token t)1348 static void request_cancel_ussd(RIL_Token t) {
1349 ALOGV("Cancelling USSD code is currently not supported");
1350 // TODO(ender): support this feature
1351 gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
1352 }
1353
request_exit_emergency_mode(void *,size_t,RIL_Token t)1354 static void request_exit_emergency_mode(void* /*data*/, size_t /*datalen*/,
1355 RIL_Token t) {
1356 ALOGV("Exiting emergency callback mode.");
1357
1358 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1359 }
1360
gce_ril_current_state()1361 static RIL_RadioState gce_ril_current_state() {
1362 ALOGV("Reporting radio state %d", gRadioPowerState);
1363 return gRadioPowerState;
1364 }
1365
gce_ril_on_supports(int requestCode)1366 static int gce_ril_on_supports(int requestCode) {
1367 ALOGE("%s: Request code %d not implemented", __FUNCTION__, requestCode);
1368 return 1;
1369 }
1370
gce_ril_on_cancel(RIL_Token)1371 static void gce_ril_on_cancel(RIL_Token /*t*/) {
1372 ALOGE("Cancel operation not implemented");
1373 }
1374
gce_ril_get_version(void)1375 static const char* gce_ril_get_version(void) {
1376 ALOGV("Reporting Cuttlefish version " CUTTLEFISH_RIL_VERSION_STRING);
1377 return CUTTLEFISH_RIL_VERSION_STRING;
1378 }
1379
1380 static int s_cell_info_rate_ms = INT_MAX;
1381 static int s_mcc = 0;
1382 static int s_mnc = 0;
1383 static int s_lac = 0;
1384 static int s_cid = 0;
1385
1386 std::vector<RIL_NeighboringCell> gGSMNeighboringCells;
1387
request_get_neighboring_cell_ids(void *,size_t,RIL_Token t)1388 static void request_get_neighboring_cell_ids(void* /*data*/, size_t /*datalen*/,
1389 RIL_Token t) {
1390 ALOGV("Requesting GSM neighboring cell ids");
1391
1392 if (!isGSM() || gGSMNeighboringCells.empty()) {
1393 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1394 return;
1395 }
1396
1397 RIL_NeighboringCell** cells =
1398 new RIL_NeighboringCell*[gGSMNeighboringCells.size()];
1399
1400 for (size_t index = 0; index < gGSMNeighboringCells.size(); ++index) {
1401 cells[index] = &gGSMNeighboringCells[index];
1402 }
1403
1404 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, cells,
1405 sizeof(RIL_NeighboringCell*));
1406 delete[] cells;
1407 }
1408
request_get_cell_info_list(void *,size_t,RIL_Token t)1409 static void request_get_cell_info_list(void* /*data*/, size_t /*datalen*/,
1410 RIL_Token t) {
1411 struct timespec now;
1412 uint64_t curTime;
1413
1414 ALOGV("Requesting Cell Info List");
1415
1416 clock_gettime(CLOCK_MONOTONIC, &now);
1417 curTime = now.tv_sec * 1000000000LL + now.tv_nsec;
1418
1419 RIL_CellInfo_v12 ci;
1420
1421 if (isGSM()) {
1422 ci.cellInfoType = RIL_CELL_INFO_TYPE_GSM;
1423 ci.registered = 1;
1424 ci.timeStampType = RIL_TIMESTAMP_TYPE_ANTENNA; // Our own timestamp.
1425 ci.timeStamp = curTime - 1000; // Fake time in the past.
1426 ci.CellInfo.gsm.cellIdentityGsm.mcc = s_mcc;
1427 ci.CellInfo.gsm.cellIdentityGsm.mnc = s_mnc;
1428 ci.CellInfo.gsm.cellIdentityGsm.lac = s_lac;
1429 ci.CellInfo.gsm.cellIdentityGsm.cid = s_cid;
1430 ci.CellInfo.gsm.signalStrengthGsm.signalStrength = 10;
1431 ci.CellInfo.gsm.signalStrengthGsm.bitErrorRate = 0;
1432
1433 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &ci, sizeof(ci));
1434 } else if (isCDMA()) {
1435 // TODO(ender): CDMA cell support. And LTE.
1436 gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1437 } else {
1438 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1439 }
1440 }
1441
1442 struct NetworkOperator {
1443 std::string long_name;
1444 std::string short_name;
1445 bool is_accessible;
1446
NetworkOperatorNetworkOperator1447 NetworkOperator() {}
1448
NetworkOperatorNetworkOperator1449 NetworkOperator(const std::string& long_name, const std::string& short_name,
1450 bool is_accessible)
1451 : long_name(long_name),
1452 short_name(short_name),
1453 is_accessible(is_accessible) {}
1454 };
1455
1456 static std::map<std::string, NetworkOperator> gNetworkOperators;
1457 static std::string gCurrentNetworkOperator = "";
1458
1459 enum OperatorSelectionMethod {
1460 kOperatorAutomatic = 0,
1461 kOperatorManual = 1,
1462 kOperatorDeregistered = 2,
1463 kOperatorManualThenAutomatic = 4
1464 };
1465
init_virtual_network()1466 static void init_virtual_network() {
1467 gGSMNeighboringCells.resize(1);
1468 gGSMNeighboringCells[0].cid = (char*)"0000";
1469 gGSMNeighboringCells[0].rssi = 75;
1470 gNetworkOperators["311740"] =
1471 NetworkOperator("Android Virtual Operator", "Android", true);
1472 gNetworkOperators["310300"] =
1473 NetworkOperator("Alternative Operator", "Alternative", true);
1474 gNetworkOperators["310400"] =
1475 NetworkOperator("Hermetic Network Operator", "Hermetic", false);
1476 }
1477
1478 static OperatorSelectionMethod gOperatorSelectionMethod = kOperatorDeregistered;
1479
request_query_network_selection_mode(void *,size_t,RIL_Token t)1480 static void request_query_network_selection_mode(void* /*data*/,
1481 size_t /*datalen*/,
1482 RIL_Token t) {
1483 ALOGV("Query operator selection mode (%d)", gOperatorSelectionMethod);
1484 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gOperatorSelectionMethod,
1485 sizeof(gOperatorSelectionMethod));
1486 }
1487
request_operator(void *,size_t,RIL_Token t)1488 static void request_operator(void* /*data*/, size_t /*datalen*/, RIL_Token t) {
1489 std::map<std::string, NetworkOperator>::iterator iter =
1490 gNetworkOperators.find(gCurrentNetworkOperator);
1491
1492 ALOGV("Requesting current operator info");
1493
1494 if (iter == gNetworkOperators.end()) {
1495 gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
1496 return;
1497 }
1498
1499 const char* response[] = {iter->second.long_name.c_str(),
1500 iter->second.short_name.c_str(),
1501 iter->first.c_str()};
1502
1503 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response));
1504 }
1505
request_query_available_networks(void *,size_t,RIL_Token t)1506 static void request_query_available_networks(void* /*data*/, size_t /*datalen*/,
1507 RIL_Token t) {
1508 const char** available_networks =
1509 new const char*[gNetworkOperators.size() * 4];
1510
1511 ALOGV("Querying available networks.");
1512
1513 // TODO(ender): this should only respond once operator is selected and
1514 // registered.
1515 int index = 0;
1516 for (std::map<std::string, NetworkOperator>::iterator iter =
1517 gNetworkOperators.begin();
1518 iter != gNetworkOperators.end(); ++iter) {
1519 // TODO(ender): wrap in a neat structure maybe?
1520 available_networks[index++] = iter->second.long_name.c_str();
1521 available_networks[index++] = iter->second.short_name.c_str();
1522 available_networks[index++] = iter->first.c_str();
1523 if (!iter->second.is_accessible) {
1524 available_networks[index++] = "forbidden";
1525 } else if (iter->first == gCurrentNetworkOperator) {
1526 available_networks[index++] = "current";
1527 } else {
1528 available_networks[index++] = "available";
1529 }
1530 }
1531
1532 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &available_networks,
1533 4 * gNetworkOperators.size());
1534 delete[] available_networks;
1535 }
1536
request_set_automatic_network_selection(RIL_Token t)1537 static void request_set_automatic_network_selection(RIL_Token t) {
1538 ALOGV("Requesting automatic operator selection");
1539 gCurrentNetworkOperator = gNetworkOperators.begin()->first;
1540 gOperatorSelectionMethod = kOperatorAutomatic;
1541 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1542 }
1543
request_set_manual_network_selection(void * data,size_t,RIL_Token t)1544 static void request_set_manual_network_selection(void* data, size_t /*datalen*/,
1545 RIL_Token t) {
1546 char* mccmnc = (char*)data;
1547
1548 ALOGV("Requesting manual operator selection: %s", mccmnc);
1549
1550 std::map<std::string, NetworkOperator>::iterator iter =
1551 gNetworkOperators.find(mccmnc);
1552
1553 if (iter == gNetworkOperators.end() || iter->second.is_accessible) {
1554 gce_ril_env->OnRequestComplete(t, RIL_E_ILLEGAL_SIM_OR_ME, NULL, 0);
1555 return;
1556 }
1557
1558 gCurrentNetworkOperator = mccmnc;
1559 gOperatorSelectionMethod = kOperatorManual;
1560
1561 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1562 }
1563
1564 static const char kDefaultSMSC[] = "00";
1565 static int gNextSmsMessageId = 1;
1566
request_cdma_send_SMS(void *,RIL_Token t)1567 static void request_cdma_send_SMS(void* /*data*/, RIL_Token t) {
1568 RIL_SMS_Response response = {0, 0, 0};
1569 // RIL_CDMA_SMS_Message* rcsm = (RIL_CDMA_SMS_Message*) data;
1570
1571 ALOGW("CDMA SMS Send is currently not implemented.");
1572
1573 // Cdma Send SMS implementation will go here:
1574 // But it is not implemented yet.
1575 memset(&response, 0, sizeof(response));
1576 response.messageRef = -1; // This must be BearerData MessageId.
1577 gce_ril_env->OnRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response,
1578 sizeof(response));
1579 }
1580
request_send_SMS(void * data,RIL_Token t)1581 static void request_send_SMS(void* data, RIL_Token t) {
1582 RIL_SMS_Response response = {0, 0, 0};
1583
1584 ALOGV("Send GSM SMS Message");
1585
1586 // SMSC is an address of SMS center or NULL for default.
1587 const char* smsc = ((const char**)data)[0];
1588 if (smsc == NULL) smsc = &kDefaultSMSC[0];
1589
1590 response.messageRef = gNextSmsMessageId++;
1591 response.ackPDU = NULL;
1592 response.errorCode = 0;
1593
1594 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
1595
1596 // response.messageRef = -1;
1597 // gce_ril_env->OnRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response,
1598 // sizeof(response));
1599 }
1600
request_set_cell_info_list_rate(void * data,size_t,RIL_Token t)1601 static void request_set_cell_info_list_rate(void* data, size_t /*datalen*/,
1602 RIL_Token t) {
1603 // For now we'll save the rate but no RIL_UNSOL_CELL_INFO_LIST messages
1604 // will be sent.
1605 ALOGV("Setting cell info list rate.");
1606 s_cell_info_rate_ms = ((int*)data)[0];
1607 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1608 }
request_ims_send_SMS(void * data,size_t,RIL_Token t)1609 static void request_ims_send_SMS(void* data, size_t /*datalen*/, RIL_Token t) {
1610 RIL_IMS_SMS_Message* args = (RIL_IMS_SMS_Message*)data;
1611 RIL_SMS_Response response{};
1612
1613 ALOGV("Send IMS SMS Message");
1614
1615 switch (args->tech) {
1616 case RADIO_TECH_3GPP:
1617 return request_send_SMS(args->message.gsmMessage, t);
1618
1619 case RADIO_TECH_3GPP2:
1620 return request_cdma_send_SMS(args->message.gsmMessage, t);
1621
1622 default:
1623 ALOGE("Invalid SMS format value: %d", args->tech);
1624 response.messageRef = -2;
1625 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, &response,
1626 sizeof(response));
1627 }
1628 }
1629
request_SMS_acknowledge(void * data,size_t,RIL_Token t)1630 static void request_SMS_acknowledge(void* data, size_t /*datalen*/,
1631 RIL_Token t) {
1632 int* ack = (int*)data;
1633
1634 // TODO(ender): we should retain "incoming" sms for later reception.
1635 ALOGV("SMS receipt %ssuccessful (reason %d).", ack[0] ? "" : "un", ack[1]);
1636
1637 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
1638 }
1639
1640 struct SimFileCommand {
1641 uint8_t command;
1642 uint16_t efid;
1643 uint8_t param1;
1644 uint8_t param2;
1645 uint8_t param3;
1646
operator <SimFileCommand1647 bool operator<(const SimFileCommand& other) const {
1648 uint64_t sum1, sum2;
1649 sum1 = (command * 1ull << 40) | (efid * 1ull << 24) | (param1 << 16) |
1650 (param2 << 8) | (param3);
1651 sum2 = (other.command * 1ull << 40) | (other.efid * 1ull << 24) |
1652 (other.param1 << 16) | (other.param2 << 8) | (other.param3);
1653 return sum1 < sum2;
1654 }
1655
SimFileCommandSimFileCommand1656 SimFileCommand(uint8_t cmd, uint16_t efid, uint8_t p1, uint8_t p2, uint8_t p3)
1657 : command(cmd), efid(efid), param1(p1), param2(p2), param3(p3) {}
1658 };
1659
1660 struct SimFileResponse {
1661 uint8_t sw1;
1662 uint8_t sw2;
1663 const char* data;
1664
SimFileResponseSimFileResponse1665 SimFileResponse() : sw1(0), sw2(0), data(NULL) {}
1666
SimFileResponseSimFileResponse1667 SimFileResponse(uint8_t sw1, uint8_t sw2, const char* data)
1668 : sw1(sw1), sw2(sw2), data(data) {}
1669 };
1670
1671 // TODO(ender): Double check & rewrite these.
1672 std::map<SimFileCommand, SimFileResponse> gSimFileSystem;
1673
init_sim_file_system()1674 static void init_sim_file_system() {
1675 gSimFileSystem[SimFileCommand(192, 28436, 0, 0, 15)] =
1676 SimFileResponse(144, 0, "000000146f1404001aa0aa01020000");
1677 gSimFileSystem[SimFileCommand(176, 28436, 0, 0, 20)] =
1678 SimFileResponse(144, 0, "416e64726f6964ffffffffffffffffffffffffff");
1679 gSimFileSystem[SimFileCommand(192, 28433, 0, 0, 15)] =
1680 SimFileResponse(144, 0, "000000016f11040011a0aa01020000");
1681 gSimFileSystem[SimFileCommand(176, 28433, 0, 0, 1)] =
1682 SimFileResponse(144, 0, "55");
1683 gSimFileSystem[SimFileCommand(192, 12258, 0, 0, 15)] =
1684 SimFileResponse(144, 0, "0000000a2fe204000fa0aa01020000");
1685 gSimFileSystem[SimFileCommand(176, 12258, 0, 0, 10)] =
1686 SimFileResponse(144, 0, "98101430121181157002");
1687 gSimFileSystem[SimFileCommand(192, 28435, 0, 0, 15)] =
1688 SimFileResponse(144, 0, "000000016f13040011a0aa01020000");
1689 gSimFileSystem[SimFileCommand(176, 28435, 0, 0, 1)] =
1690 SimFileResponse(144, 0, "55");
1691 gSimFileSystem[SimFileCommand(192, 28472, 0, 0, 15)] =
1692 SimFileResponse(144, 0, "0000000f6f3804001aa0aa01020000");
1693 gSimFileSystem[SimFileCommand(176, 28472, 0, 0, 15)] =
1694 SimFileResponse(144, 0, "ff30ffff3c003c03000c0000f03f00");
1695 gSimFileSystem[SimFileCommand(192, 28617, 0, 0, 15)] =
1696 SimFileResponse(144, 0, "000000086fc9040011a0aa01020104");
1697 gSimFileSystem[SimFileCommand(178, 28617, 1, 4, 4)] =
1698 SimFileResponse(144, 0, "01000000");
1699 gSimFileSystem[SimFileCommand(192, 28618, 0, 0, 15)] =
1700 SimFileResponse(144, 0, "0000000a6fca040011a0aa01020105");
1701 gSimFileSystem[SimFileCommand(178, 28618, 1, 4, 5)] =
1702 SimFileResponse(144, 0, "0000000000");
1703 gSimFileSystem[SimFileCommand(192, 28589, 0, 0, 15)] =
1704 SimFileResponse(144, 0, "000000046fad04000aa0aa01020000");
1705 gSimFileSystem[SimFileCommand(176, 28589, 0, 0, 4)] =
1706 SimFileResponse(144, 0, "00000003");
1707 gSimFileSystem[SimFileCommand(192, 28438, 0, 0, 15)] =
1708 SimFileResponse(144, 0, "000000026f1604001aa0aa01020000");
1709 gSimFileSystem[SimFileCommand(176, 28438, 0, 0, 2)] =
1710 SimFileResponse(144, 0, "0233");
1711 gSimFileSystem[SimFileCommand(192, 28486, 0, 0, 15)] =
1712 SimFileResponse(148, 4, NULL);
1713 gSimFileSystem[SimFileCommand(192, 28621, 0, 0, 15)] =
1714 SimFileResponse(148, 4, NULL);
1715 gSimFileSystem[SimFileCommand(192, 28613, 0, 0, 15)] =
1716 SimFileResponse(144, 0, "000000f06fc504000aa0aa01020118");
1717 gSimFileSystem[SimFileCommand(178, 28613, 1, 4, 24)] = SimFileResponse(
1718 144, 0, "43058441aa890affffffffffffffffffffffffffffffffff");
1719 gSimFileSystem[SimFileCommand(192, 28480, 0, 0, 15)] =
1720 SimFileResponse(144, 0, "000000806f40040011a0aa01020120");
1721 // Primary phone number encapsulated
1722 // [51][55][21][43][65][f7] = 1 555 1234 567$
1723 gSimFileSystem[SimFileCommand(178, 28480, 1, 4, 32)] = SimFileResponse(
1724 144, 0,
1725 "ffffffffffffffffffffffffffffffffffff07915155214365f7ffffffffffff");
1726 gSimFileSystem[SimFileCommand(192, 28615, 0, 0, 15)] =
1727 SimFileResponse(144, 0, "000000406fc7040011a0aa01020120");
1728 // Voice mail number encapsulated
1729 // [56][6f][69][63][65][6d][61][69][6c] = 'Voicemail'
1730 // [51][55][67][45][23][f1] = 1 555 7654 321$
1731 gSimFileSystem[SimFileCommand(178, 28615, 1, 4, 32)] = SimFileResponse(
1732 144, 0,
1733 "566f6963656d61696cffffffffffffffffff07915155674523f1ffffffffffff");
1734 gSimFileSystem[SimFileCommand(192, 12037, 0, 0, 15)] =
1735 SimFileResponse(148, 4, NULL);
1736 gSimFileSystem[SimFileCommand(192, 28437, 0, 0, 15)] =
1737 SimFileResponse(148, 4, NULL);
1738 gSimFileSystem[SimFileCommand(192, 28478, 0, 0, 15)] =
1739 SimFileResponse(148, 4, NULL);
1740 gSimFileSystem[SimFileCommand(192, 28450, 0, 0, 15)] =
1741 SimFileResponse(148, 4, NULL);
1742 gSimFileSystem[SimFileCommand(192, 28456, 0, 0, 15)] =
1743 SimFileResponse(148, 4, NULL);
1744 gSimFileSystem[SimFileCommand(192, 28474, 0, 0, 15)] =
1745 SimFileResponse(148, 4, NULL);
1746 gSimFileSystem[SimFileCommand(192, 28481, 0, 0, 15)] =
1747 SimFileResponse(148, 4, NULL);
1748 gSimFileSystem[SimFileCommand(192, 28484, 0, 0, 15)] =
1749 SimFileResponse(148, 4, NULL);
1750 gSimFileSystem[SimFileCommand(192, 28493, 0, 0, 15)] =
1751 SimFileResponse(148, 4, NULL);
1752 gSimFileSystem[SimFileCommand(192, 28619, 0, 0, 15)] =
1753 SimFileResponse(148, 4, NULL);
1754 gSimFileSystem[SimFileCommand(176, 28506, 0, 0, 4)] =
1755 SimFileResponse(144, 0, "00000013");
1756 }
1757
request_SIM_IO(void * data,size_t,RIL_Token t)1758 static void request_SIM_IO(void* data, size_t /*datalen*/, RIL_Token t) {
1759 const RIL_SIM_IO_v6& args = *(RIL_SIM_IO_v6*)data;
1760 RIL_SIM_IO_Response sr = {0, 0, 0};
1761
1762 ALOGV(
1763 "Requesting SIM File IO: %d EFID %x, Params: %d, %d, %d, path: %s, "
1764 "data %s PIN: %s AID: %s",
1765 args.command, args.fileid, args.p1, args.p2, args.p3, args.path,
1766 args.data, args.pin2, args.aidPtr);
1767
1768 SimFileCommand cmd(args.command, args.fileid, args.p1, args.p2, args.p3);
1769
1770 std::map<SimFileCommand, SimFileResponse>::iterator resp =
1771 gSimFileSystem.find(cmd);
1772
1773 if (resp != gSimFileSystem.end()) {
1774 sr.sw1 = resp->second.sw1;
1775 sr.sw2 = resp->second.sw2;
1776 if (resp->second.data) sr.simResponse = strdup(resp->second.data);
1777 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr));
1778 return;
1779 }
1780
1781 ALOGW("Unsupported SIM File IO command.");
1782 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1783 }
1784
request_enter_sim_pin(void * data,size_t,RIL_Token t)1785 static void request_enter_sim_pin(void* data, size_t /*datalen*/, RIL_Token t) {
1786 const char** pin_aid = (const char**)data;
1787
1788 ALOGV("Entering PIN: %s / %s", pin_aid[0], pin_aid[1]);
1789
1790 ++gSimPINAttempts;
1791 int remaining_attempts = gSimPINAttemptsMax - gSimPINAttempts;
1792
1793 bool is_valid = false;
1794
1795 if (gSimStatus == SIM_PIN) {
1796 is_valid = (gSimPIN == pin_aid[0]);
1797 } else if (gSimStatus == SIM_PUK) {
1798 is_valid = (gSimPUK == pin_aid[0]);
1799 } else {
1800 ALOGV("Unexpected SIM status for unlock: %d", gSimStatus);
1801 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1802 return;
1803 }
1804
1805 if (!is_valid) {
1806 if (gSimPINAttempts == gSimPINAttemptsMax) {
1807 if (gSimStatus == SIM_PIN) {
1808 gSimStatus = SIM_PUK;
1809 gSimPINAttempts = 0;
1810 } else {
1811 ALOGV("PIN and PUK verification failed; locking SIM card.");
1812 gSimStatus = SIM_NOT_READY;
1813 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
1814 return;
1815 }
1816 }
1817
1818 gce_ril_env->OnRequestComplete(t, RIL_E_PASSWORD_INCORRECT,
1819 &remaining_attempts,
1820 sizeof(remaining_attempts));
1821 } else {
1822 if (gSimStatus == SIM_PUK) {
1823 ALOGV("Resetting SIM PIN to %s", pin_aid[1]);
1824 gSimPIN = pin_aid[1];
1825 }
1826
1827 gSimPINAttempts = 0;
1828 gSimStatus = SIM_READY;
1829 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &remaining_attempts,
1830 sizeof(remaining_attempts));
1831 }
1832
1833 pollSIMState(NULL);
1834 }
1835
1836 /**
1837 * No longer POLL.
1838 */
pollSIMState(void *)1839 static void pollSIMState(void* /*param*/) {
1840 // TODO(ender): check radio state?
1841
1842 ALOGV("Polling SIM Status.");
1843
1844 switch (gSimStatus) {
1845 case SIM_ABSENT:
1846 case SIM_PIN:
1847 case SIM_PUK:
1848 case SIM_NETWORK_PERSONALIZATION:
1849 default:
1850 ALOGV("SIM Absent or Locked");
1851 break;
1852
1853 case SIM_NOT_READY:
1854 // Transition directly to READY. Set default network operator.
1855 if (gRadioPowerState == RADIO_STATE_ON) {
1856 gSimStatus = SIM_READY;
1857 gCurrentNetworkOperator = "311740";
1858 }
1859
1860 gce_ril_env->RequestTimedCallback(pollSIMState, NULL, &TIMEVAL_SIMPOLL);
1861 break;
1862
1863 case SIM_READY:
1864 ALOGV("SIM Ready. Notifying network state changed.");
1865 break;
1866 }
1867
1868 if (gRadioPowerState != RADIO_STATE_OFF) {
1869 gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED,
1870 NULL, 0);
1871 gce_ril_env->OnUnsolicitedResponse(
1872 RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, NULL, 0);
1873 }
1874 }
1875
1876 std::map<SIM_Status, RIL_AppStatus> gRilAppStatus;
1877
init_sim_status()1878 static void init_sim_status() {
1879 gRilAppStatus[SIM_ABSENT] = (RIL_AppStatus){RIL_APPTYPE_UNKNOWN,
1880 RIL_APPSTATE_UNKNOWN,
1881 RIL_PERSOSUBSTATE_UNKNOWN,
1882 NULL,
1883 NULL,
1884 0,
1885 RIL_PINSTATE_UNKNOWN,
1886 RIL_PINSTATE_UNKNOWN};
1887 gRilAppStatus[SIM_NOT_READY] =
1888 (RIL_AppStatus){RIL_APPTYPE_SIM,
1889 RIL_APPSTATE_DETECTED,
1890 RIL_PERSOSUBSTATE_UNKNOWN,
1891 NULL,
1892 NULL,
1893 0,
1894 RIL_PINSTATE_ENABLED_NOT_VERIFIED,
1895 RIL_PINSTATE_ENABLED_NOT_VERIFIED};
1896 gRilAppStatus[SIM_READY] = (RIL_AppStatus){
1897 RIL_APPTYPE_SIM,
1898 RIL_APPSTATE_READY,
1899 RIL_PERSOSUBSTATE_READY,
1900 NULL,
1901 NULL,
1902 0,
1903 RIL_PINSTATE_ENABLED_VERIFIED,
1904 RIL_PINSTATE_ENABLED_VERIFIED,
1905 };
1906 gRilAppStatus[SIM_PIN] = (RIL_AppStatus){RIL_APPTYPE_SIM,
1907 RIL_APPSTATE_PIN,
1908 RIL_PERSOSUBSTATE_UNKNOWN,
1909 NULL,
1910 NULL,
1911 0,
1912 RIL_PINSTATE_ENABLED_NOT_VERIFIED,
1913 RIL_PINSTATE_UNKNOWN};
1914 gRilAppStatus[SIM_PUK] = (RIL_AppStatus){RIL_APPTYPE_SIM,
1915 RIL_APPSTATE_PUK,
1916 RIL_PERSOSUBSTATE_UNKNOWN,
1917 NULL,
1918 NULL,
1919 0,
1920 RIL_PINSTATE_ENABLED_BLOCKED,
1921 RIL_PINSTATE_UNKNOWN};
1922 gRilAppStatus[SIM_NETWORK_PERSONALIZATION] =
1923 (RIL_AppStatus){RIL_APPTYPE_SIM,
1924 RIL_APPSTATE_SUBSCRIPTION_PERSO,
1925 RIL_PERSOSUBSTATE_SIM_NETWORK,
1926 NULL,
1927 NULL,
1928 0,
1929 RIL_PINSTATE_ENABLED_NOT_VERIFIED,
1930 RIL_PINSTATE_UNKNOWN};
1931 gRilAppStatus[RUIM_ABSENT] = (RIL_AppStatus){RIL_APPTYPE_UNKNOWN,
1932 RIL_APPSTATE_UNKNOWN,
1933 RIL_PERSOSUBSTATE_UNKNOWN,
1934 NULL,
1935 NULL,
1936 0,
1937 RIL_PINSTATE_UNKNOWN,
1938 RIL_PINSTATE_UNKNOWN};
1939 gRilAppStatus[RUIM_NOT_READY] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
1940 RIL_APPSTATE_DETECTED,
1941 RIL_PERSOSUBSTATE_UNKNOWN,
1942 NULL,
1943 NULL,
1944 0,
1945 RIL_PINSTATE_UNKNOWN,
1946 RIL_PINSTATE_UNKNOWN};
1947 gRilAppStatus[RUIM_READY] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
1948 RIL_APPSTATE_READY,
1949 RIL_PERSOSUBSTATE_READY,
1950 NULL,
1951 NULL,
1952 0,
1953 RIL_PINSTATE_UNKNOWN,
1954 RIL_PINSTATE_UNKNOWN};
1955 gRilAppStatus[RUIM_PIN] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
1956 RIL_APPSTATE_PIN,
1957 RIL_PERSOSUBSTATE_UNKNOWN,
1958 NULL,
1959 NULL,
1960 0,
1961 RIL_PINSTATE_ENABLED_NOT_VERIFIED,
1962 RIL_PINSTATE_UNKNOWN};
1963 gRilAppStatus[RUIM_PUK] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
1964 RIL_APPSTATE_PUK,
1965 RIL_PERSOSUBSTATE_UNKNOWN,
1966 NULL,
1967 NULL,
1968 0,
1969 RIL_PINSTATE_ENABLED_BLOCKED,
1970 RIL_PINSTATE_UNKNOWN};
1971 gRilAppStatus[RUIM_NETWORK_PERSONALIZATION] =
1972 (RIL_AppStatus){RIL_APPTYPE_RUIM,
1973 RIL_APPSTATE_SUBSCRIPTION_PERSO,
1974 RIL_PERSOSUBSTATE_SIM_NETWORK,
1975 NULL,
1976 NULL,
1977 0,
1978 RIL_PINSTATE_ENABLED_NOT_VERIFIED,
1979 RIL_PINSTATE_UNKNOWN};
1980 }
1981
1982 /**
1983 * Get the current card status.
1984 */
getCardStatus(RIL_Token t)1985 static void getCardStatus(RIL_Token t) {
1986 ALOGV("Querying SIM status.");
1987 RIL_CardStatus_v6 card_status;
1988
1989 if (gSimStatus == SIM_ABSENT) {
1990 card_status.card_state = RIL_CARDSTATE_ABSENT;
1991 card_status.num_applications = 0;
1992 } else {
1993 card_status.card_state = RIL_CARDSTATE_PRESENT;
1994 card_status.num_applications = 1;
1995 }
1996
1997 card_status.universal_pin_state = RIL_PINSTATE_UNKNOWN;
1998 card_status.gsm_umts_subscription_app_index = -1;
1999 card_status.cdma_subscription_app_index = -1;
2000 card_status.ims_subscription_app_index = -1;
2001
2002 // Initialize application status
2003 for (int i = 0; i < RIL_CARD_MAX_APPS; i++) {
2004 card_status.applications[i] = gRilAppStatus[SIM_ABSENT];
2005 }
2006
2007 if (card_status.num_applications > 0) {
2008 card_status.gsm_umts_subscription_app_index = 0;
2009
2010 card_status.applications[0] = gRilAppStatus[gSimStatus];
2011 card_status.universal_pin_state = card_status.applications[0].pin1;
2012 // To enable basic CDMA (currently neither supported nor functional):
2013 // card_status.num_applications = 2;
2014 // card_status.cdma_subscription_app_index = 1;
2015 // card_status.applications[1] =
2016 // gRilAppStatus[SIM_Status(gSimStatus + RUIM_ABSENT)];
2017 }
2018
2019 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &card_status,
2020 sizeof(card_status));
2021 }
2022
2023 struct SimSession {
2024 std::string aid;
2025 };
2026
2027 static int gNextSimSessionId = 1;
2028 static std::map<int, SimSession> gSimSessions;
2029
request_sim_open_channel(void * data,size_t,RIL_Token t)2030 static void request_sim_open_channel(void* data, size_t /*datalen*/,
2031 RIL_Token t) {
2032 char* aid = (char*)data;
2033 SimSession session;
2034
2035 ALOGV("Requesting new SIM session");
2036
2037 if (aid != NULL) {
2038 session.aid = aid;
2039 }
2040
2041 int response = gNextSimSessionId++;
2042 gSimSessions[response] = session;
2043
2044 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response));
2045 }
2046
request_sim_close_channel(void * data,size_t,RIL_Token t)2047 static void request_sim_close_channel(void* data, size_t /*datalen*/,
2048 RIL_Token t) {
2049 int session = *(int*)(data);
2050
2051 ALOGV("Closing SIM session %d", session);
2052
2053 if (gSimSessions.erase(session) == 0) {
2054 // No such session.
2055 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2056 } else {
2057 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2058 }
2059 }
2060
request_sim_apdu(void * data,size_t,RIL_Token t)2061 static void request_sim_apdu(void* data, size_t /*datalen*/, RIL_Token t) {
2062 RIL_SIM_APDU* apdu = (RIL_SIM_APDU*)data;
2063
2064 ALOGV("Requesting APDU: Session %d CLA %d INST %d Params: %d %d %d, data %s",
2065 apdu->sessionid, apdu->cla, apdu->instruction, apdu->p1, apdu->p2,
2066 apdu->p3, apdu->data);
2067
2068 if (gSimSessions.find(apdu->sessionid) != gSimSessions.end()) {
2069 RIL_SIM_IO_Response sr{};
2070
2071 // Fallback / default behavior.
2072 sr.sw1 = 144;
2073 sr.sw2 = 0;
2074 sr.simResponse = NULL;
2075
2076 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr));
2077 } else {
2078 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2079 }
2080 }
2081
2082 // 0 = Lock is available, but disabled.
2083 // 1 = Lock is available and enabled,
2084 // 2 = lock is neither available nor enabled
2085 static const int kFacilityLockAllDisabled = 0;
2086
request_facility_lock(void * data,size_t,RIL_Token t)2087 static void request_facility_lock(void* data, size_t /*datalen*/, RIL_Token t) {
2088 char** data_vec = (char**)data;
2089
2090 // TODO(ender): implement this; essentially: AT+CLCK
2091 // See http://www.activexperts.com/sms-component/at/commands/?at=%2BCLCK
2092 // and
2093 // opt/telephony/src/java/com/android/internal/telephony/CommandsInterface.java
2094 // opt/telephony/src/java/com/android/internal/telephony/uicc/UiccCardApplication.java
2095
2096 ALOGV("Query Facility Lock Code: %s PIN2: %s Service(s): %s AID: %s",
2097 data_vec[0], data_vec[1], data_vec[2], data_vec[3]);
2098
2099 // TODO(ender): there should be a bit vector of responses for each of the
2100 // services requested.
2101 // Depending on lock code, facilities may be unlocked or locked. We report
2102 // these are all unlocked, regardless of the query.
2103 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
2104 const_cast<int*>(&kFacilityLockAllDisabled),
2105 sizeof(kFacilityLockAllDisabled));
2106 }
2107
request_international_subscriber_id_number(RIL_Token t)2108 static void request_international_subscriber_id_number(RIL_Token t) {
2109 // TODO(ender): Reuse MCC and MNC.
2110 std::string subscriber_id = gCurrentNetworkOperator.c_str();
2111 subscriber_id += "123456789";
2112
2113 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
2114 strdup(subscriber_id.c_str()), sizeof(char*));
2115 }
2116
2117 static bool gScreenIsOn = true;
2118
request_set_screen_state(void * data,size_t,RIL_Token t)2119 static void request_set_screen_state(void* data, size_t /*datalen*/,
2120 RIL_Token t) {
2121 gScreenIsOn = *(int*)data ? true : false;
2122 ALOGV("Screen is %s", gScreenIsOn ? "on" : "off");
2123 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2124 }
2125
2126 // Unsure which section this belongs in.
2127
2128 static int gModemTtyMode = 1; // 0 = off, 1 = full, 2 = HCO, 3 = VCO.
request_set_tty_mode(void * data,size_t,RIL_Token t)2129 static void request_set_tty_mode(void* data, size_t /*datalen*/, RIL_Token t) {
2130 int new_tty_mode = *(int*)(data);
2131 ALOGV("Switching modem TTY mode %d -> %d", gModemTtyMode, new_tty_mode);
2132
2133 if (new_tty_mode >= 0 && new_tty_mode <= 3) {
2134 gModemTtyMode = new_tty_mode;
2135 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2136 } else {
2137 gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
2138 }
2139 }
2140
request_get_tty_mode(RIL_Token t)2141 static void request_get_tty_mode(RIL_Token t) {
2142 ALOGV("Querying TTY mode");
2143 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gModemTtyMode,
2144 sizeof(gModemTtyMode));
2145 }
2146
2147 static bool gImsRegistered = false;
2148 static int gImsFormat = RADIO_TECH_3GPP;
2149
request_ims_registration_state(RIL_Token t)2150 static void request_ims_registration_state(RIL_Token t) {
2151 ALOGV("Querying IMS mode");
2152 int reply[2];
2153 reply[0] = gImsRegistered;
2154 reply[1] = gImsFormat;
2155
2156 ALOGV("Requesting IMS Registration state: %d, format=%d ", reply[0],
2157 reply[1]);
2158
2159 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, reply, sizeof(reply));
2160 }
2161
2162 // New functions after P.
request_start_network_scan(RIL_Token t)2163 static void request_start_network_scan(RIL_Token t) {
2164 ALOGV("Scanning network - void");
2165 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2166 return;
2167 }
2168
request_set_preferred_network_type_bitmap(int,void * data,size_t,RIL_Token t)2169 static void request_set_preferred_network_type_bitmap(int /*request*/, void* data,
2170 size_t /*datalen*/,
2171 RIL_Token t) {
2172 RIL_RadioAccessFamily desired_access = *(RIL_RadioAccessFamily*)(data);
2173
2174 ALOGV("Requesting modem technology change %d -> %d", default_access, desired_access);
2175
2176 /** TODO future implementation: set modem type based on radio access family.
2177 * 1) find supported_technologies and desired_technologies
2178 * 2) return RIL_E_MODE_NOT_SUPPORTED error if not supported
2179 */
2180 default_access = desired_access;
2181 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2182 return;
2183 }
2184
request_get_preferred_network_type_bitmap(int,void *,size_t,RIL_Token t)2185 static void request_get_preferred_network_type_bitmap(int /*request*/, void* /*data*/,
2186 size_t /*datalen*/,
2187 RIL_Token t) {
2188 ALOGV("Requesting modem radio access family: %d", default_access);
2189 gce_ril_env->OnRequestComplete(
2190 t, RIL_E_SUCCESS, (RIL_RadioAccessFamily*)(&default_access), sizeof(default_access));
2191 }
2192
request_emergency_dial(int,void *,size_t,RIL_Token t)2193 static void request_emergency_dial(int /*request*/, void* /*data*/, size_t /*datalen*/,
2194 RIL_Token t) {
2195 ALOGV("Emergency dial");
2196 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2197 return;
2198 }
2199
request_set_sim_card_power(int,void *,size_t,RIL_Token t)2200 static void request_set_sim_card_power(int /*request*/, void* /*data*/, size_t /*datalen*/,
2201 RIL_Token t) {
2202 ALOGV("Set sim card power - void");
2203 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2204 return;
2205 }
2206
request_get_modem_stack_status(int,RIL_Token t)2207 static void request_get_modem_stack_status(int /*request*/, RIL_Token t) {
2208 ALOGV("Getting modem stack status - void");
2209 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2210 return;
2211 }
2212
request_enable_modem(int,RIL_Token t)2213 static void request_enable_modem(int /*request*/, RIL_Token t) {
2214 ALOGV("Enabling modem - void");
2215 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2216 return;
2217 }
2218
request_set_system_selection_channels(int,RIL_Token t)2219 static void request_set_system_selection_channels(int /*request*/, RIL_Token t) {
2220 ALOGV("request_set_system_selection_channels - void");
2221 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2222 return;
2223 }
2224
2225 // New functions after Q.
request_set_signal_strength_reporting_criteria(int,void *,size_t,RIL_Token t)2226 static void request_set_signal_strength_reporting_criteria(int /*request*/, void* /*data*/,
2227 size_t /*datalen*/, RIL_Token t) {
2228 ALOGV("request_set_signal_strength_reporting_criteria - void");
2229 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2230 return;
2231 }
2232
request_set_link_capacity_reporting_criteria(int,void *,size_t,RIL_Token t)2233 static void request_set_link_capacity_reporting_criteria(int /*request*/, void* /*data*/,
2234 size_t /*datalen*/, RIL_Token t) {
2235 ALOGV("request_set_link_capacity_reporting_criteria - void");
2236 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2237 return;
2238 }
2239
request_enable_uicc_applications(int,void * data,size_t datalen,RIL_Token t)2240 static void request_enable_uicc_applications(int /*request*/, void* data,
2241 size_t datalen,
2242 RIL_Token t) {
2243 ALOGV("Enable uicc applications.");
2244
2245 if (data == NULL || datalen != sizeof(int)) {
2246 gce_ril_env->OnRequestComplete(t, RIL_E_INTERNAL_ERR, NULL, 0);
2247 return;
2248 }
2249
2250 bool enable = *(int *)(data) != 0;
2251
2252 ALOGV("areUiccApplicationsEnabled change from %d to %d", areUiccApplicationsEnabled, enable);
2253
2254 areUiccApplicationsEnabled = enable;
2255
2256 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2257 }
2258
request_are_uicc_applications_enabled(int,void *,size_t,RIL_Token t)2259 static void request_are_uicc_applications_enabled(int /*request*/, void* /*data*/,
2260 size_t /*datalen*/,
2261 RIL_Token t) {
2262 ALOGV("Getting whether uicc applications are enabled.");
2263
2264 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &areUiccApplicationsEnabled, sizeof(bool));
2265 }
2266
request_enter_sim_depersonalization(RIL_Token t)2267 static void request_enter_sim_depersonalization(RIL_Token t) {
2268 ALOGV("request_enter_sim_depersonalization - void");
2269 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2270 return;
2271 }
2272
request_cdma_send_sms_expect_more(RIL_Token t)2273 static void request_cdma_send_sms_expect_more(RIL_Token t) {
2274 ALOGV("request_cdma_send_sms_expect_more - void");
2275 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2276 return;
2277 }
2278
gce_ril_on_request(int request,void * data,size_t datalen,RIL_Token t)2279 static void gce_ril_on_request(int request, void* data, size_t datalen,
2280 RIL_Token t) {
2281 // Ignore all requests except RIL_REQUEST_GET_SIM_STATUS
2282 // when RADIO_STATE_UNAVAILABLE.
2283 if (gRadioPowerState == RADIO_STATE_UNAVAILABLE &&
2284 request != RIL_REQUEST_GET_SIM_STATUS) {
2285 gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
2286 return;
2287 }
2288
2289 // Ignore all non-power requests when RADIO_STATE_OFF.
2290 if (gRadioPowerState == RADIO_STATE_OFF) {
2291 switch (request) {
2292 case RIL_REQUEST_GET_SIM_STATUS:
2293 case RIL_REQUEST_OPERATOR:
2294 case RIL_REQUEST_RADIO_POWER:
2295 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE:
2296 // Process all the above, even though the radio is off
2297 break;
2298 default:
2299 gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
2300 return;
2301 }
2302 }
2303
2304 ALOGV("Received request %d", request);
2305
2306 switch (request) {
2307 case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS:
2308 request_query_available_networks(data, datalen, t);
2309 break;
2310 case RIL_REQUEST_GET_IMEI:
2311 request_get_imei(t);
2312 break;
2313 case RIL_REQUEST_GET_IMEISV:
2314 request_get_imei_sv(t);
2315 break;
2316 case RIL_REQUEST_DEACTIVATE_DATA_CALL:
2317 request_teardown_data_call(data, datalen, t);
2318 break;
2319 case RIL_REQUEST_SCREEN_STATE:
2320 request_set_screen_state(data, datalen, t);
2321 break;
2322 case RIL_REQUEST_GET_SIM_STATUS:
2323 getCardStatus(t);
2324 break;
2325 case RIL_REQUEST_GET_CURRENT_CALLS:
2326 request_get_current_calls(data, datalen, t);
2327 break;
2328 case RIL_REQUEST_DIAL:
2329 request_dial(data, datalen, t);
2330 break;
2331 case RIL_REQUEST_HANGUP:
2332 request_hangup(data, datalen, t);
2333 break;
2334 case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:
2335 request_hangup_waiting(data, datalen, t);
2336 break;
2337 case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:
2338 request_hangup_current(t);
2339 break;
2340 case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE:
2341 request_switch_current_and_waiting(t);
2342 break;
2343 case RIL_REQUEST_ANSWER:
2344 request_answer_incoming(t);
2345 break;
2346 case RIL_REQUEST_SET_MUTE:
2347 request_set_mute(data, datalen, t);
2348 break;
2349 case RIL_REQUEST_GET_MUTE:
2350 request_get_mute(t);
2351 break;
2352 case RIL_REQUEST_CONFERENCE:
2353 request_combine_multiparty_call(data, datalen, t);
2354 break;
2355 case RIL_REQUEST_SEPARATE_CONNECTION:
2356 request_split_multiparty_call(data, datalen, t);
2357 break;
2358 case RIL_REQUEST_UDUB:
2359 request_udub_on_incoming_calls(t);
2360 break;
2361 case RIL_REQUEST_SIGNAL_STRENGTH:
2362 request_signal_strength(data, datalen, t);
2363 break;
2364 case RIL_REQUEST_VOICE_REGISTRATION_STATE:
2365 case RIL_REQUEST_DATA_REGISTRATION_STATE:
2366 request_registration_state(request, data, datalen, t);
2367 break;
2368 case RIL_REQUEST_OPERATOR:
2369 request_operator(data, datalen, t);
2370 break;
2371 case RIL_REQUEST_RADIO_POWER:
2372 request_radio_power(data, datalen, t);
2373 break;
2374 case RIL_REQUEST_DTMF:
2375 case RIL_REQUEST_DTMF_START:
2376 request_send_dtmf(data, datalen, t);
2377 break;
2378 case RIL_REQUEST_DTMF_STOP:
2379 request_send_dtmf_stop(t);
2380 break;
2381 case RIL_REQUEST_SEND_SMS:
2382 request_send_SMS(data, t);
2383 break;
2384 case RIL_REQUEST_CDMA_SEND_SMS:
2385 request_cdma_send_SMS(data, t);
2386 break;
2387 case RIL_REQUEST_SETUP_DATA_CALL:
2388 request_setup_data_call(data, datalen, t);
2389 break;
2390 case RIL_REQUEST_SMS_ACKNOWLEDGE:
2391 request_SMS_acknowledge(data, datalen, t);
2392 break;
2393 case RIL_REQUEST_GET_IMSI:
2394 request_international_subscriber_id_number(t);
2395 break;
2396 case RIL_REQUEST_QUERY_FACILITY_LOCK:
2397 request_facility_lock(data, datalen, t);
2398 break;
2399 case RIL_REQUEST_SIM_IO:
2400 request_SIM_IO(data, datalen, t);
2401 break;
2402 case RIL_REQUEST_SEND_USSD:
2403 request_send_ussd(data, datalen, t);
2404 break;
2405 case RIL_REQUEST_CANCEL_USSD:
2406 request_cancel_ussd(t);
2407 break;
2408 case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC:
2409 request_set_automatic_network_selection(t);
2410 break;
2411 case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL:
2412 request_set_manual_network_selection(data, datalen, t);
2413 break;
2414 case RIL_REQUEST_DATA_CALL_LIST:
2415 request_data_calllist(data, datalen, t);
2416 break;
2417 case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE:
2418 request_datacall_fail_cause(t);
2419 break;
2420 case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE:
2421 request_query_network_selection_mode(data, datalen, t);
2422 break;
2423 case RIL_REQUEST_OEM_HOOK_RAW:
2424 case RIL_REQUEST_OEM_HOOK_STRINGS:
2425 ALOGV("OEM Hooks not supported!");
2426 gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
2427 break;
2428 case RIL_REQUEST_WRITE_SMS_TO_SIM:
2429 request_write_sms_to_sim(data, datalen, t);
2430 break;
2431 case RIL_REQUEST_DELETE_SMS_ON_SIM:
2432 request_delete_sms_on_sim(data, datalen, t);
2433 break;
2434 case RIL_REQUEST_ENTER_SIM_PIN:
2435 case RIL_REQUEST_ENTER_SIM_PUK:
2436 case RIL_REQUEST_ENTER_SIM_PIN2:
2437 case RIL_REQUEST_ENTER_SIM_PUK2:
2438 case RIL_REQUEST_CHANGE_SIM_PIN:
2439 case RIL_REQUEST_CHANGE_SIM_PIN2:
2440 request_enter_sim_pin(data, datalen, t);
2441 break;
2442 case RIL_REQUEST_VOICE_RADIO_TECH: {
2443 RIL_RadioTechnology tech = getBestVoiceTechnology(gModemCurrentType);
2444 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &tech, sizeof(tech));
2445 break;
2446 }
2447 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE:
2448 request_set_preferred_network_type(request, data, datalen, t);
2449 break;
2450 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE:
2451 request_get_preferred_network_type(request, data, datalen, t);
2452 break;
2453 case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS:
2454 request_get_neighboring_cell_ids(data, datalen, t);
2455 break;
2456 case RIL_REQUEST_GET_CELL_INFO_LIST:
2457 request_get_cell_info_list(data, datalen, t);
2458 break;
2459 case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE:
2460 request_set_cell_info_list_rate(data, datalen, t);
2461 break;
2462 case RIL_REQUEST_BASEBAND_VERSION:
2463 request_baseband_version(t);
2464 break;
2465 case RIL_REQUEST_SET_TTY_MODE:
2466 request_set_tty_mode(data, datalen, t);
2467 break;
2468 case RIL_REQUEST_QUERY_TTY_MODE:
2469 request_get_tty_mode(t);
2470 break;
2471 case RIL_REQUEST_GET_RADIO_CAPABILITY:
2472 request_get_radio_capability(t);
2473 break;
2474 case RIL_REQUEST_SET_RADIO_CAPABILITY:
2475 request_set_radio_capability(data, datalen, t);
2476 break;
2477 case RIL_REQUEST_SET_DATA_PROFILE:
2478 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2479 break;
2480 case RIL_REQUEST_GET_HARDWARE_CONFIG:
2481 request_hardware_config(t);
2482 break;
2483 case RIL_REQUEST_IMS_REGISTRATION_STATE:
2484 request_ims_registration_state(t);
2485 break;
2486 case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL:
2487 request_sim_apdu(data, datalen, t);
2488 break;
2489 case RIL_REQUEST_SIM_OPEN_CHANNEL:
2490 request_sim_open_channel(data, datalen, t);
2491 break;
2492 case RIL_REQUEST_SIM_CLOSE_CHANNEL:
2493 request_sim_close_channel(data, datalen, t);
2494 break;
2495 case RIL_REQUEST_IMS_SEND_SMS:
2496 request_ims_send_SMS(data, datalen, t);
2497 break;
2498 case RIL_REQUEST_SET_INITIAL_ATTACH_APN:
2499 ALOGW("INITIAL ATTACH APN");
2500 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2501 break;
2502
2503 // New requests after P.
2504 case RIL_REQUEST_START_NETWORK_SCAN:
2505 request_start_network_scan(t);
2506 break;
2507 case RIL_REQUEST_GET_MODEM_STACK_STATUS:
2508 request_get_modem_stack_status(request, t);
2509 break;
2510 case RIL_REQUEST_ENABLE_MODEM:
2511 request_enable_modem(request, t);
2512 break;
2513 case RIL_REQUEST_EMERGENCY_DIAL:
2514 request_emergency_dial(request, data, datalen, t);
2515 break;
2516 case RIL_REQUEST_SET_SIM_CARD_POWER:
2517 request_set_sim_card_power(request, data, datalen, t);
2518 break;
2519 case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE_BITMAP:
2520 request_get_preferred_network_type_bitmap(request, data, datalen, t);
2521 break;
2522 case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE_BITMAP:
2523 request_set_preferred_network_type_bitmap(request, data, datalen, t);
2524 break;
2525 case RIL_REQUEST_SET_SYSTEM_SELECTION_CHANNELS:
2526 request_set_system_selection_channels(request, t);
2527 break;
2528 case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING:
2529 gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
2530 break;
2531 case RIL_REQUEST_DEVICE_IDENTITY:
2532 request_device_identity(request, data, datalen, t);
2533 break;
2534 case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:
2535 request_cdma_get_subscription_source(request, data, datalen, t);
2536 break;
2537 case RIL_REQUEST_CDMA_SUBSCRIPTION:
2538 request_cdma_subscription(request, data, datalen, t);
2539 break;
2540 case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:
2541 request_cdma_set_subscription_source(request, data, datalen, t);
2542 break;
2543 case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:
2544 request_cdma_get_roaming_preference(request, data, datalen, t);
2545 break;
2546 case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:
2547 request_cdma_set_roaming_preference(request, data, datalen, t);
2548 break;
2549 case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE:
2550 request_exit_emergency_mode(data, datalen, t);
2551 break;
2552
2553 // New requests after Q.
2554 case RIL_REQUEST_SET_SIGNAL_STRENGTH_REPORTING_CRITERIA:
2555 request_set_signal_strength_reporting_criteria(request, data, datalen, t);
2556 break;
2557 case RIL_REQUEST_SET_LINK_CAPACITY_REPORTING_CRITERIA:
2558 request_set_link_capacity_reporting_criteria(request, data, datalen, t);
2559 break;
2560 case RIL_REQUEST_ENABLE_UICC_APPLICATIONS:
2561 request_enable_uicc_applications(request, data, datalen, t);
2562 break;
2563 case RIL_REQUEST_ARE_UICC_APPLICATIONS_ENABLED:
2564 request_are_uicc_applications_enabled(request, data, datalen, t);
2565 break;
2566 case RIL_REQUEST_ENTER_SIM_DEPERSONALIZATION:
2567 request_enter_sim_depersonalization(t);
2568 break;
2569 case RIL_REQUEST_CDMA_SEND_SMS_EXPECT_MORE:
2570 request_cdma_send_sms_expect_more(t);
2571 break;
2572 default:
2573 ALOGE("Request %d not supported.", request);
2574 gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
2575 break;
2576 }
2577 }
2578
2579 #define CUTTLEFISH_RIL_VERSION 6
2580
2581 static const RIL_RadioFunctions ril_callbacks = {
2582 CUTTLEFISH_RIL_VERSION, gce_ril_on_request, gce_ril_current_state,
2583 gce_ril_on_supports, gce_ril_on_cancel, gce_ril_get_version};
2584
2585 extern "C" {
2586
RIL_Init(const struct RIL_Env * env,int,char **)2587 const RIL_RadioFunctions* RIL_Init(const struct RIL_Env* env, int /*argc*/,
2588 char** /*argv*/) {
2589 time(&gce_ril_start_time);
2590 gce_ril_env = env;
2591
2592 global_ril_config = cvd::DeviceConfig::Get();
2593 if (!global_ril_config) {
2594 ALOGE("Failed to open device configuration!!!");
2595 return nullptr;
2596 }
2597
2598 TearDownNetworkInterface();
2599
2600 init_modem_supported_network_types();
2601 init_modem_technologies();
2602 init_virtual_network();
2603 init_sim_file_system();
2604 init_sim_status();
2605
2606 return &ril_callbacks;
2607 }
2608
2609 } // extern "C"
2610