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