diff --git a/guest/hals/ril/vsoc_ril.cpp b/guest/hals/ril/vsoc_ril.cpp
index 3baee1c..43650f6 100644
--- a/guest/hals/ril/vsoc_ril.cpp
+++ b/guest/hals/ril/vsoc_ril.cpp
@@ -16,10 +16,10 @@
 
 #include "guest/hals/ril/vsoc_ril.h"
 
-#include <string.h>
-#include <time.h>
-#include <sys/types.h>
 #include <cutils/properties.h>
+#include <string.h>
+#include <sys/types.h>
+#include <time.h>
 
 #include <map>
 #include <set>
@@ -62,7 +62,7 @@
 
 static const struct RIL_Env* gce_ril_env;
 
-static const struct timeval TIMEVAL_SIMPOLL = {3,0};
+static const struct timeval TIMEVAL_SIMPOLL = {3, 0};
 
 static time_t gce_ril_start_time;
 
@@ -70,14 +70,8 @@
 
 RIL_RadioState gRadioPowerState = RADIO_STATE_OFF;
 
-
 struct DataCall {
-  enum AllowedAuthenticationType {
-    kNone = 0,
-    kPap = 1,
-    kChap = 2,
-    kBoth = 3
-  };
+  enum AllowedAuthenticationType { kNone = 0, kPap = 1, kChap = 2, kBoth = 3 };
 
   enum ConnectionType {
     kConnTypeIPv4,
@@ -147,13 +141,11 @@
   return false;
 }
 
-
 static int gNextDataCallId = 8;
 static std::map<int, DataCall> gDataCalls;
 static bool gRilConnected = false;
 
-static int request_or_send_data_calllist(RIL_Token *t) {
-
+static int request_or_send_data_calllist(RIL_Token* t) {
 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
   RIL_Data_Call_Response_v11* responses =
       new RIL_Data_Call_Response_v11[gDataCalls.size()];
@@ -221,14 +213,13 @@
     }
   }
 
-
   if (t != NULL) {
-    gce_ril_env->OnRequestComplete(
-        *t, RIL_E_SUCCESS, responses, gDataCalls.size() * sizeof(*responses));
+    gce_ril_env->OnRequestComplete(*t, RIL_E_SUCCESS, responses,
+                                   gDataCalls.size() * sizeof(*responses));
   } else {
-    gce_ril_env->OnUnsolicitedResponse(
-        RIL_UNSOL_DATA_CALL_LIST_CHANGED, responses,
-        gDataCalls.size() * sizeof(*responses));
+    gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED,
+                                       responses,
+                                       gDataCalls.size() * sizeof(*responses));
   }
   delete[] responses;
   return 0;
@@ -245,11 +236,11 @@
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &fail, sizeof(fail));
 };
 
-static void on_data_calllist_changed(void *param) {
+static void on_data_calllist_changed(void* param) {
   request_or_send_data_calllist(NULL);
 }
 
-static void request_data_calllist(void *data, size_t datalen, RIL_Token t) {
+static void request_data_calllist(void* data, size_t datalen, RIL_Token t) {
   request_or_send_data_calllist(&t);
 }
 
@@ -260,9 +251,10 @@
   char** details = static_cast<char**>(data);
   const size_t fields = datalen / sizeof(details[0]);
 
-  // There are two different versions of this interface, one providing 7 strings and the other
-  // providing 8. The code below will assume the presence of 7 strings in all cases, so bail out
-  // here if things appear to be wrong. We protect the 8 string case below.
+  // There are two different versions of this interface, one providing 7 strings
+  // and the other providing 8. The code below will assume the presence of 7
+  // strings in all cases, so bail out here if things appear to be wrong. We
+  // protect the 8 string case below.
   if (fields < 7) {
     ALOGE("%s returning: called with small datalen %zu", __FUNCTION__, datalen);
     return;
@@ -336,7 +328,8 @@
   gRilConnected = (gDataCalls.size() > 0);
 }
 
-static void request_teardown_data_call(void* data, size_t datalen, RIL_Token t) {
+static void request_teardown_data_call(void* data, size_t datalen,
+                                       RIL_Token t) {
   char** data_strs = (char**)data;
   int call_id = atoi(data_strs[0]);
   int reason = atoi(data_strs[1]);
@@ -376,8 +369,8 @@
     gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
   }
 
-  gce_ril_env->OnUnsolicitedResponse(
-      RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, NULL, 0);
+  gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
+                                     NULL, 0);
 
   pollSIMState(NULL);
 }
@@ -391,20 +384,19 @@
   return state == RADIO_STATE_ON;
 }
 
-static void request_radio_power(void *data, size_t datalen, RIL_Token t) {
-  int on = ((int *) data)[0];
+static void request_radio_power(void* data, size_t datalen, RIL_Token t) {
+  int on = ((int*)data)[0];
   set_radio_state(on ? RADIO_STATE_ON : RADIO_STATE_OFF, t);
 }
 
-
-static void send_call_state_changed(void *param) {
-  gce_ril_env->OnUnsolicitedResponse(
-      RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, NULL, 0);
+static void send_call_state_changed(void* param) {
+  gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
+                                     NULL, 0);
 }
 
 // TODO(ender): this should be a class member. Move where it belongs.
 struct CallState {
-  RIL_CallState state;              // e.g. RIL_CALL_HOLDING;
+  RIL_CallState state;  // e.g. RIL_CALL_HOLDING;
   bool isInternational;
   bool isMobileTerminated;
   bool isVoice;
@@ -426,7 +418,6 @@
         canPresentNumber(true),
         canPresentName(true) {}
 
-
   CallState(const std::string& number)
       : state(RIL_CALL_INCOMING),
         isInternational(false),
@@ -438,25 +429,15 @@
         canPresentNumber(true),
         canPresentName(true) {}
 
-  bool isBackground() {
-    return state == RIL_CALL_HOLDING;
-  }
+  bool isBackground() { return state == RIL_CALL_HOLDING; }
 
-  bool isActive() {
-    return state == RIL_CALL_ACTIVE;
-  }
+  bool isActive() { return state == RIL_CALL_ACTIVE; }
 
-  bool isDialing() {
-    return state == RIL_CALL_DIALING;
-  }
+  bool isDialing() { return state == RIL_CALL_DIALING; }
 
-  bool isIncoming() {
-    return state == RIL_CALL_INCOMING;
-  }
+  bool isIncoming() { return state == RIL_CALL_INCOMING; }
 
-  bool isWaiting() {
-    return state == RIL_CALL_WAITING;
-  }
+  bool isWaiting() { return state == RIL_CALL_WAITING; }
 
   void addDtmfDigit(char c) {
     dtmf.push_back(c);
@@ -473,10 +454,8 @@
   }
 
   bool makeActive() {
-    if (state == RIL_CALL_INCOMING
-        || state == RIL_CALL_WAITING
-        || state == RIL_CALL_DIALING
-        || state == RIL_CALL_HOLDING) {
+    if (state == RIL_CALL_INCOMING || state == RIL_CALL_WAITING ||
+        state == RIL_CALL_DIALING || state == RIL_CALL_HOLDING) {
       state = RIL_CALL_ACTIVE;
       return true;
     }
@@ -489,16 +468,16 @@
 static int gMicrophoneMute = 0;
 static std::map<int, CallState> gActiveCalls;
 
-static void request_get_current_calls(void *data, size_t datalen, RIL_Token t) {
+static void request_get_current_calls(void* data, size_t datalen, RIL_Token t) {
   const int countCalls = gActiveCalls.size();
 
-  RIL_Call** pp_calls = (RIL_Call **) alloca(countCalls * sizeof(RIL_Call *));
-  RIL_Call* p_calls = (RIL_Call *) alloca(countCalls * sizeof(RIL_Call));
+  RIL_Call** pp_calls = (RIL_Call**)alloca(countCalls * sizeof(RIL_Call*));
+  RIL_Call* p_calls = (RIL_Call*)alloca(countCalls * sizeof(RIL_Call));
 
   memset(p_calls, 0, countCalls * sizeof(RIL_Call));
 
   /* init the pointer array */
-  for(int i = 0; i < countCalls ; i++) {
+  for (int i = 0; i < countCalls; i++) {
     pp_calls[i] = &(p_calls[i]);
   }
 
@@ -524,8 +503,8 @@
           p_calls->toa, p_calls->state, p_calls->index);
   }
 
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, pp_calls, countCalls * sizeof(RIL_Call *));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, pp_calls,
+                                 countCalls * sizeof(RIL_Call*));
 
   ALOGV("Get Current calls: %d calls found.\n", countCalls);
 }
@@ -541,16 +520,16 @@
   }
 
   // Only unsolicited here.
-  gce_ril_env->OnUnsolicitedResponse(
-      RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, NULL, 0);
+  gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
+                                     NULL, 0);
 }
 
-static void request_dial(void *data, size_t datalen, RIL_Token t) {
+static void request_dial(void* data, size_t datalen, RIL_Token t) {
   RIL_Dial* p_dial = (RIL_Dial*)data;
 
   ALOGV("Dialing %s, number presentation is %s.", p_dial->address,
-      (p_dial->clir == 0) ? "defined by operator" :
-      (p_dial->clir == 1) ? "allowed" : "restricted");
+        (p_dial->clir == 0) ? "defined by operator"
+                            : (p_dial->clir == 1) ? "allowed" : "restricted");
 
   CallState state(p_dial->address);
   state.isMobileTerminated = false;
@@ -570,9 +549,9 @@
   int call_index = gLastActiveCallIndex++;
   gActiveCalls[call_index] = state;
 
-  static const struct timeval kAnswerTime = { 5, 0 };
-  gce_ril_env->RequestTimedCallback(
-      simulate_pending_calls_answered, NULL, &kAnswerTime);
+  static const struct timeval kAnswerTime = {5, 0};
+  gce_ril_env->RequestTimedCallback(simulate_pending_calls_answered, NULL,
+                                    &kAnswerTime);
 
   // success or failure is ignored by the upper layer here.
   // it will call GET_CURRENT_CALLS and determine success that way
@@ -591,12 +570,7 @@
 
 // TODO(ender): this should be a class member. Move where it belongs.
 struct SmsMessage {
-  enum SmsStatus {
-    kUnread = 0,
-    kRead = 1,
-    kUnsent = 2,
-    kSent = 3
-  };
+  enum SmsStatus { kUnread = 0, kRead = 1, kUnsent = 2, kSent = 3 };
 
   std::string message;
   SmsStatus status;
@@ -605,18 +579,17 @@
 static int gNextMessageId = 1;
 static std::map<int, SmsMessage> gMessagesOnSimCard;
 
-static void request_write_sms_to_sim(void *data, size_t datalen, RIL_Token t) {
-  RIL_SMS_WriteArgs* p_args = (RIL_SMS_WriteArgs*) data;
+static void request_write_sms_to_sim(void* data, size_t datalen, RIL_Token t) {
+  RIL_SMS_WriteArgs* p_args = (RIL_SMS_WriteArgs*)data;
 
   SmsMessage message;
   message.status = SmsMessage::SmsStatus(p_args->status);
   message.message = p_args->pdu;
 
-  ALOGV("Storing SMS message: '%s' with state: %s.",
-        message.message.c_str(),
-        (message.status < SmsMessage::kUnsent) ?
-        ((message.status == SmsMessage::kRead) ? "READ" : "UNREAD") :
-        ((message.status == SmsMessage::kSent) ? "SENT" : "UNSENT"));
+  ALOGV("Storing SMS message: '%s' with state: %s.", message.message.c_str(),
+        (message.status < SmsMessage::kUnsent)
+            ? ((message.status == SmsMessage::kRead) ? "READ" : "UNREAD")
+            : ((message.status == SmsMessage::kSent) ? "SENT" : "UNSENT"));
 
   // TODO(ender): simulate SIM FULL?
   int index = gNextMessageId++;
@@ -639,8 +612,8 @@
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 }
 
-static void request_hangup(void *data, size_t datalen, RIL_Token t) {
-  int* p_line = (int*) data;
+static void request_hangup(void* data, size_t datalen, RIL_Token t) {
+  int* p_line = (int*)data;
 
   ALOGV("Hanging up call %d.", *p_line);
   std::map<int, CallState>::iterator iter = gActiveCalls.find(*p_line);
@@ -724,14 +697,14 @@
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 }
 
-static void request_combine_multiparty_call(
-    void* data, size_t datalen, RIL_Token t) {
+static void request_combine_multiparty_call(void* data, size_t datalen,
+                                            RIL_Token t) {
   ALOGW("Conference calls are not supported.");
   gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 }
 
-static void request_split_multiparty_call(
-    void* data, size_t datalen, RIL_Token t) {
+static void request_split_multiparty_call(void* data, size_t datalen,
+                                          RIL_Token t) {
   ALOGW("Conference calls are not supported.");
   gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
 }
@@ -756,7 +729,7 @@
 }
 
 static void request_send_dtmf(void* data, size_t datalen, RIL_Token t) {
-  char c = ((char *)data)[0];
+  char c = ((char*)data)[0];
   ALOGV("Sending DTMF digit '%c'", c);
 
   for (std::map<int, CallState>::iterator iter = gActiveCalls.begin();
@@ -792,7 +765,7 @@
 static int gEVDOSignalStrength = kEVDOSignalStrengthMax;
 static int gLTESignalStrength = kLTESignalStrengthMax;
 
-static void request_signal_strength(void *data, size_t datalen, RIL_Token t) {
+static void request_signal_strength(void* data, size_t datalen, RIL_Token t) {
   // TODO(ender): possible to support newer APIs here.
 #if VSOC_PLATFORM_SDK_AFTER(N_MR1)
   RIL_SignalStrength_v10 strength;
@@ -832,10 +805,10 @@
   strength.EVDO_SignalStrength.ecio = 0;  // Ec/Io; keep high to use dbm.
 
   strength.LTE_SignalStrength.signalStrength = gLTESignalStrength;
-  strength.LTE_SignalStrength.rsrp = INT_MAX;  // Invalid = Use signalStrength.
-  strength.LTE_SignalStrength.rsrq = INT_MAX;  // Invalid = Use signalStrength.
+  strength.LTE_SignalStrength.rsrp = INT_MAX;   // Invalid = Use signalStrength.
+  strength.LTE_SignalStrength.rsrq = INT_MAX;   // Invalid = Use signalStrength.
   strength.LTE_SignalStrength.rssnr = INT_MAX;  // Invalid = Use signalStrength.
-  strength.LTE_SignalStrength.cqi = INT_MAX;  // Invalid = Use signalStrength.
+  strength.LTE_SignalStrength.cqi = INT_MAX;    // Invalid = Use signalStrength.
 
   ALOGV("Reporting signal strength: GW=%d CDMA=%d EVDO=%d LTE=%d",
         gGatewaySignalStrength, gCDMASignalStrength, gEVDOSignalStrength,
@@ -850,8 +823,10 @@
   gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA] = MDM_GSM | MDM_WCDMA;
   gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_ONLY] = MDM_GSM;
   gModemSupportedNetworkTypes[PREF_NET_TYPE_WCDMA] = MDM_WCDMA;
-  gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA_AUTO] = MDM_GSM | MDM_WCDMA;
-  gModemSupportedNetworkTypes[PREF_NET_TYPE_CDMA_EVDO_AUTO] = MDM_CDMA | MDM_EVDO;
+  gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA_AUTO] =
+      MDM_GSM | MDM_WCDMA;
+  gModemSupportedNetworkTypes[PREF_NET_TYPE_CDMA_EVDO_AUTO] =
+      MDM_CDMA | MDM_EVDO;
   gModemSupportedNetworkTypes[PREF_NET_TYPE_CDMA_ONLY] = MDM_CDMA;
   gModemSupportedNetworkTypes[PREF_NET_TYPE_EVDO_ONLY] = MDM_EVDO;
   gModemSupportedNetworkTypes[PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO] =
@@ -865,54 +840,51 @@
   gModemSupportedNetworkTypes[PREF_NET_TYPE_LTE_ONLY] = MDM_LTE;
 }
 
-static std::map< RIL_PreferredNetworkType, int> gModemTechnologies;
+static std::map<RIL_PreferredNetworkType, int> gModemTechnologies;
 
 RIL_RadioTechnology gDataTechnologiesPreferenceOrder[] = {
-  RADIO_TECH_LTE, RADIO_TECH_EHRPD, RADIO_TECH_HSPAP, RADIO_TECH_HSPA,
-  RADIO_TECH_HSDPA, RADIO_TECH_HSUPA, RADIO_TECH_EVDO_B, RADIO_TECH_EVDO_A,
-  RADIO_TECH_EVDO_0, RADIO_TECH_1xRTT, RADIO_TECH_UMTS, RADIO_TECH_EDGE,
-  RADIO_TECH_GPRS
-};
+    RADIO_TECH_LTE,    RADIO_TECH_EHRPD, RADIO_TECH_HSPAP,  RADIO_TECH_HSPA,
+    RADIO_TECH_HSDPA,  RADIO_TECH_HSUPA, RADIO_TECH_EVDO_B, RADIO_TECH_EVDO_A,
+    RADIO_TECH_EVDO_0, RADIO_TECH_1xRTT, RADIO_TECH_UMTS,   RADIO_TECH_EDGE,
+    RADIO_TECH_GPRS};
 
 RIL_RadioTechnology gVoiceTechnologiesPreferenceOrder[] = {
-  RADIO_TECH_LTE, RADIO_TECH_EHRPD, RADIO_TECH_EVDO_B, RADIO_TECH_EVDO_A,
-  RADIO_TECH_EVDO_0, RADIO_TECH_1xRTT, RADIO_TECH_IS95B, RADIO_TECH_IS95A,
-  RADIO_TECH_UMTS, RADIO_TECH_GSM
-};
+    RADIO_TECH_LTE,    RADIO_TECH_EHRPD, RADIO_TECH_EVDO_B, RADIO_TECH_EVDO_A,
+    RADIO_TECH_EVDO_0, RADIO_TECH_1xRTT, RADIO_TECH_IS95B,  RADIO_TECH_IS95A,
+    RADIO_TECH_UMTS,   RADIO_TECH_GSM};
 
 static void init_modem_technologies() {
   gModemTechnologies[PREF_NET_TYPE_GSM_WCDMA] =
-      (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) |
-      (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
+      (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
+      (1 << RADIO_TECH_UMTS);
   gModemTechnologies[PREF_NET_TYPE_GSM_ONLY] =
       (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE);
   gModemTechnologies[PREF_NET_TYPE_WCDMA] =
       (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
   gModemTechnologies[PREF_NET_TYPE_GSM_WCDMA_AUTO] =
-      (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) |
-      (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
+      (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
+      (1 << RADIO_TECH_UMTS);
   gModemTechnologies[PREF_NET_TYPE_CDMA_EVDO_AUTO] =
       (1 << RADIO_TECH_IS95A) | (1 << RADIO_TECH_IS95B) |
       (1 << RADIO_TECH_1xRTT) | (1 << RADIO_TECH_EVDO_0) |
       (1 << RADIO_TECH_EVDO_A) | (1 << RADIO_TECH_HSDPA) |
       (1 << RADIO_TECH_HSUPA) | (1 << RADIO_TECH_HSPA) |
       (1 << RADIO_TECH_EVDO_B);
-  gModemTechnologies[PREF_NET_TYPE_CDMA_ONLY] =
-      (1 << RADIO_TECH_IS95A) | (1 << RADIO_TECH_IS95B) |
-      (1 << RADIO_TECH_1xRTT);
+  gModemTechnologies[PREF_NET_TYPE_CDMA_ONLY] = (1 << RADIO_TECH_IS95A) |
+                                                (1 << RADIO_TECH_IS95B) |
+                                                (1 << RADIO_TECH_1xRTT);
   gModemTechnologies[PREF_NET_TYPE_EVDO_ONLY] =
       (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
       (1 << RADIO_TECH_EVDO_A) | (1 << RADIO_TECH_HSDPA) |
       (1 << RADIO_TECH_HSUPA) | (1 << RADIO_TECH_HSPA) |
       (1 << RADIO_TECH_EVDO_B);
   gModemTechnologies[PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO] =
-      (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) |
-      (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS) |
-      (1 << RADIO_TECH_IS95A) | (1 << RADIO_TECH_IS95B) |
-      (1 << RADIO_TECH_1xRTT) | (1 << RADIO_TECH_EVDO_0) |
-      (1 << RADIO_TECH_EVDO_A) | (1 << RADIO_TECH_HSDPA) |
-      (1 << RADIO_TECH_HSUPA) | (1 << RADIO_TECH_HSPA) |
-      (1 << RADIO_TECH_EVDO_B);
+      (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
+      (1 << RADIO_TECH_UMTS) | (1 << RADIO_TECH_IS95A) |
+      (1 << RADIO_TECH_IS95B) | (1 << RADIO_TECH_1xRTT) |
+      (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
+      (1 << RADIO_TECH_HSDPA) | (1 << RADIO_TECH_HSUPA) |
+      (1 << RADIO_TECH_HSPA) | (1 << RADIO_TECH_EVDO_B);
   gModemTechnologies[PREF_NET_TYPE_LTE_CDMA_EVDO] =
       (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) |
       (1 << RADIO_TECH_EHRPD) | (1 << RADIO_TECH_IS95A) |
@@ -922,8 +894,8 @@
       (1 << RADIO_TECH_HSPA) | (1 << RADIO_TECH_EVDO_B);
   gModemTechnologies[PREF_NET_TYPE_LTE_GSM_WCDMA] =
       (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) |
-      (1 << RADIO_TECH_EHRPD) | (1 << RADIO_TECH_GSM) |
-      (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
+      (1 << RADIO_TECH_EHRPD) | (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) |
+      (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
 
   gModemTechnologies[PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA] =
       (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) |
@@ -932,8 +904,8 @@
       (1 << RADIO_TECH_EVDO_0) | (1 << RADIO_TECH_EVDO_A) |
       (1 << RADIO_TECH_HSDPA) | (1 << RADIO_TECH_HSUPA) |
       (1 << RADIO_TECH_HSPA) | (1 << RADIO_TECH_EVDO_B) |
-      (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) |
-      (1 << RADIO_TECH_EDGE) | (1 << RADIO_TECH_UMTS);
+      (1 << RADIO_TECH_GSM) | (1 << RADIO_TECH_GPRS) | (1 << RADIO_TECH_EDGE) |
+      (1 << RADIO_TECH_UMTS);
   gModemTechnologies[PREF_NET_TYPE_LTE_ONLY] =
       (1 << RADIO_TECH_HSPAP) | (1 << RADIO_TECH_LTE) | (1 << RADIO_TECH_EHRPD);
 }
@@ -944,7 +916,6 @@
 static RIL_RadioTechnology gModemTechnology = RADIO_TECH_LTE;
 static RIL_RadioTechnology gModemVoiceTechnology = RADIO_TECH_LTE;
 
-
 // Report technology change.
 // Select best technology from the list of supported techs.
 // Demotes RADIO_TECH_GSM as it's voice-only.
@@ -952,8 +923,8 @@
     RIL_PreferredNetworkType network_type) {
   RIL_RadioTechnology technology = RADIO_TECH_GPRS;
 
-  std::map<RIL_PreferredNetworkType, int>::iterator
-      iter = gModemTechnologies.find(network_type);
+  std::map<RIL_PreferredNetworkType, int>::iterator iter =
+      gModemTechnologies.find(network_type);
 
   ALOGV("Searching for best data technology for network type %d...",
         network_type);
@@ -961,7 +932,7 @@
   // Find which technology bits are lit. Pick the top most.
   for (size_t tech_index = 0;
        tech_index < sizeof(gDataTechnologiesPreferenceOrder) /
-           sizeof(gDataTechnologiesPreferenceOrder[0]);
+                        sizeof(gDataTechnologiesPreferenceOrder[0]);
        ++tech_index) {
     if (iter->second & (1 << gDataTechnologiesPreferenceOrder[tech_index])) {
       technology = gDataTechnologiesPreferenceOrder[tech_index];
@@ -977,8 +948,8 @@
     RIL_PreferredNetworkType network_type) {
   RIL_RadioTechnology technology = RADIO_TECH_GSM;
 
-  std::map<RIL_PreferredNetworkType, int>::iterator
-      iter = gModemTechnologies.find(network_type);
+  std::map<RIL_PreferredNetworkType, int>::iterator iter =
+      gModemTechnologies.find(network_type);
 
   ALOGV("Searching for best voice technology for network type %d...",
         network_type);
@@ -986,7 +957,7 @@
   // Find which technology bits are lit. Pick the top most.
   for (size_t tech_index = 0;
        tech_index < sizeof(gVoiceTechnologiesPreferenceOrder) /
-           sizeof(gVoiceTechnologiesPreferenceOrder[0]);
+                        sizeof(gVoiceTechnologiesPreferenceOrder[0]);
        ++tech_index) {
     if (iter->second & (1 << gVoiceTechnologiesPreferenceOrder[tech_index])) {
       technology = gVoiceTechnologiesPreferenceOrder[tech_index];
@@ -1003,9 +974,9 @@
 
   if (technology != gModemVoiceTechnology) {
     gModemVoiceTechnology = technology;
-    gce_ril_env->OnUnsolicitedResponse(
-        RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
-        &gModemVoiceTechnology, sizeof(gModemVoiceTechnology));
+    gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED,
+                                       &gModemVoiceTechnology,
+                                       sizeof(gModemVoiceTechnology));
   }
 }
 
@@ -1022,22 +993,22 @@
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &rc, sizeof(rc));
 }
 
-static void request_set_radio_capability(
-    void* data, size_t datalen, RIL_Token t) {
-  RIL_RadioCapability* rc = (RIL_RadioCapability *) data;
-  ALOGV("RadioCapability version %d session %d phase %d rat %d "
-        "logicalModemUuid %s status %d",
-        rc->version, rc->session, rc->phase, rc->rat,
-        rc->logicalModemUuid, rc->status);
+static void request_set_radio_capability(void* data, size_t datalen,
+                                         RIL_Token t) {
+  RIL_RadioCapability* rc = (RIL_RadioCapability*)data;
+  ALOGV(
+      "RadioCapability version %d session %d phase %d rat %d "
+      "logicalModemUuid %s status %d",
+      rc->version, rc->session, rc->phase, rc->rat, rc->logicalModemUuid,
+      rc->status);
   // TODO(ender): do something about these numbers.
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, rc, datalen);
 }
 #endif
 
-static void request_set_preferred_network_type(
-    int request, void *data, size_t datalen, RIL_Token t) {
-  RIL_PreferredNetworkType desired_type =
-      *(RIL_PreferredNetworkType*)(data);
+static void request_set_preferred_network_type(int request, void* data,
+                                               size_t datalen, RIL_Token t) {
+  RIL_PreferredNetworkType desired_type = *(RIL_PreferredNetworkType*)(data);
 
   // TODO(ender): telephony still believes this phone is GSM only.
   ALOGV("Requesting modem technology change -> %d", desired_type);
@@ -1056,8 +1027,8 @@
   int supported_technologies = gModemSupportedNetworkTypes[gModemDefaultType];
   int desired_technologies = gModemSupportedNetworkTypes[desired_type];
 
-  ALOGV("Requesting modem technology change %d -> %d",
-        gModemCurrentType, desired_type);
+  ALOGV("Requesting modem technology change %d -> %d", gModemCurrentType,
+        desired_type);
 
   // Check if we support this technology.
   if ((supported_technologies & desired_technologies) != desired_technologies) {
@@ -1072,8 +1043,8 @@
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 }
 
-static void request_get_preferred_network_type(
-    int request, void *data, size_t datalen, RIL_Token t) {
+static void request_get_preferred_network_type(int request, void* data,
+                                               size_t datalen, RIL_Token t) {
   gce_ril_env->OnRequestComplete(
       t, RIL_E_SUCCESS,
       const_cast<RIL_PreferredNetworkType*>(&gModemDefaultType),
@@ -1098,15 +1069,15 @@
 static const char kCdmaSID[] = "123";
 static const char kCdmaNID[] = "65535";  // special: indicates free roaming.
 
-static void request_registration_state(
-    int request, void *data, size_t datalen, RIL_Token t) {
+static void request_registration_state(int request, void* data, size_t datalen,
+                                       RIL_Token t) {
   char** responseStr = NULL;
   int numElements = 0;
 
   // See RIL_REQUEST_VOICE_REGISTRATION_STATE and
   // RIL_REQUEST_DATA_REGISTRATION_STATE.
   numElements = (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) ? 15 : 6;
-  responseStr = (char**)malloc(numElements * sizeof(char *));
+  responseStr = (char**)malloc(numElements * sizeof(char*));
 
   asprintf(&responseStr[0], "%d", kRegisteredInHomeNetwork);
   responseStr[1] = NULL;  // LAC - needed for GSM / WCDMA only.
@@ -1116,38 +1087,38 @@
   if (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) {
     ALOGV("Requesting voice registration state.");
     asprintf(&responseStr[3], "%d", getBestVoiceTechnology(gModemCurrentType));
-    responseStr[4] = strdup("1");  // BSID
-    responseStr[5] = strdup("123");  // Latitude
-    responseStr[6] = strdup("222");  // Longitude
-    responseStr[7] = strdup("0");  // CSS Indicator
+    responseStr[4] = strdup("1");       // BSID
+    responseStr[5] = strdup("123");     // Latitude
+    responseStr[6] = strdup("222");     // Longitude
+    responseStr[7] = strdup("0");       // CSS Indicator
     responseStr[8] = strdup(kCdmaSID);  // SID
     responseStr[9] = strdup(kCdmaNID);  // NID
-    responseStr[10] = strdup("0");  // Roaming indicator
-    responseStr[11] = strdup("1");  // System is in PRL
-    responseStr[12] = strdup("0");  // Default Roaming indicator
-    responseStr[13] = strdup("0");  // Reason for denial
-    responseStr[14] = strdup("0");  // Primary Scrambling Code of Current
+    responseStr[10] = strdup("0");      // Roaming indicator
+    responseStr[11] = strdup("1");      // System is in PRL
+    responseStr[12] = strdup("0");      // Default Roaming indicator
+    responseStr[13] = strdup("0");      // Reason for denial
+    responseStr[14] = strdup("0");      // Primary Scrambling Code of Current
   } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) {
     ALOGV("Requesting data registration state.");
     asprintf(&responseStr[3], "%d", getBestDataTechnology(gModemCurrentType));
-    responseStr[4] = strdup("");  // DataServiceDenyReason
+    responseStr[4] = strdup("");   // DataServiceDenyReason
     responseStr[5] = strdup("1");  // Max simultaneous data calls.
   } else {
     ALOGV("Unexpected request type: %d", request);
     return;
   }
 
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, responseStr, numElements * sizeof(responseStr));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, responseStr,
+                                 numElements * sizeof(responseStr));
 }
 
 static void request_baseband_version(RIL_Token t) {
-  const char *response_str = "AVD_R1.0.0";
+  const char* response_str = "AVD_R1.0.0";
 
   ALOGV("Requested phone baseband version.");
 
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, strdup(response_str), sizeof(response_str));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, strdup(response_str),
+                                 sizeof(response_str));
 }
 
 // Returns true, if modem is CDMA capable.
@@ -1200,27 +1171,28 @@
 }
 
 static const char gIdentityGsmImei[] = "12345678902468";  // Luhn cksum = 0.
-static const char gIdentityGsmImeiSv[] = "01";  // Arbitrary version.
-static const char gIdentityCdmaEsn[] = "A0123456";  // 8 digits, ^[A-F].*
-static const char gIdentityCdmaMeid[] = "A0123456789012";  // 14 digits, ^[A-F].*
+static const char gIdentityGsmImeiSv[] = "01";            // Arbitrary version.
+static const char gIdentityCdmaEsn[] = "A0123456";        // 8 digits, ^[A-F].*
+static const char gIdentityCdmaMeid[] =
+    "A0123456789012";  // 14 digits, ^[A-F].*
 
 static void request_get_imei(RIL_Token t) {
   ALOGV("Requesting IMEI");
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, const_cast<char*>(gIdentityGsmImei),
-      strlen(gIdentityGsmImei));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
+                                 const_cast<char*>(gIdentityGsmImei),
+                                 strlen(gIdentityGsmImei));
 }
 
 static void request_get_imei_sv(RIL_Token t) {
   ALOGV("Requesting IMEI SV");
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, const_cast<char*>(gIdentityGsmImeiSv),
-      strlen(gIdentityGsmImeiSv));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
+                                 const_cast<char*>(gIdentityGsmImeiSv),
+                                 strlen(gIdentityGsmImeiSv));
 }
 
-static void request_device_identity(
-    int request, void *data, size_t datalen, RIL_Token t) {
-  char* response[4] = { NULL };
+static void request_device_identity(int request, void* data, size_t datalen,
+                                    RIL_Token t) {
+  char* response[4] = {NULL};
 
   ALOGV("Requesting device identity...");
 
@@ -1245,8 +1217,8 @@
 static RIL_CdmaSubscriptionSource gCdmaSubscriptionType =
     CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM;
 
-static void request_cdma_get_subscription_source(
-    int request, void *data, size_t datalen, RIL_Token t) {
+static void request_cdma_get_subscription_source(int request, void* data,
+                                                 size_t datalen, RIL_Token t) {
   ALOGV("Requesting CDMA Subscription source.");
 
   if (!isCDMA()) {
@@ -1255,12 +1227,12 @@
     return;
   }
 
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, &gCdmaSubscriptionType, sizeof(gCdmaSubscriptionType));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gCdmaSubscriptionType,
+                                 sizeof(gCdmaSubscriptionType));
 }
 
-static void request_cdma_set_subscription_source(
-    int request, void *data, size_t datalen, RIL_Token t) {
+static void request_cdma_set_subscription_source(int request, void* data,
+                                                 size_t datalen, RIL_Token t) {
   ALOGV("Setting CDMA Subscription source.");
 
   if (!isCDMA()) {
@@ -1269,8 +1241,7 @@
     return;
   }
 
-  RIL_CdmaSubscriptionSource new_source =
-      *(RIL_CdmaSubscriptionSource*)(data);
+  RIL_CdmaSubscriptionSource new_source = *(RIL_CdmaSubscriptionSource*)(data);
 
   if (new_source == CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM && !gCdmaHasSim) {
     // No such radio.
@@ -1278,18 +1249,18 @@
     return;
   }
 
-  ALOGV("Changed CDMA subscription type from %d to %d",
-        gCdmaSubscriptionType, new_source);
+  ALOGV("Changed CDMA subscription type from %d to %d", gCdmaSubscriptionType,
+        new_source);
   gCdmaSubscriptionType = new_source;
 
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
-  gce_ril_env->OnUnsolicitedResponse(
-      RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
-      &gCdmaSubscriptionType, sizeof(gCdmaSubscriptionType));
+  gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED,
+                                     &gCdmaSubscriptionType,
+                                     sizeof(gCdmaSubscriptionType));
 }
 
-static void request_cdma_subscription(
-    int request, void *data, size_t datalen, RIL_Token t) {
+static void request_cdma_subscription(int request, void* data, size_t datalen,
+                                      RIL_Token t) {
   ALOGV("Requesting CDMA Subscription.");
 
   if (!isCDMA()) {
@@ -1298,14 +1269,14 @@
     return;
   }
 
-  char* responseStr[5] = { NULL };
-  responseStr[0] = strdup(&kCdmaMobileDeviceNumber[0]); // MDN
-  responseStr[1] = strdup(&kCdmaSID[0]); // SID
-  responseStr[2] = strdup(&kCdmaNID[0]); // NID
-  responseStr[3] = strdup(&kCdmaMobileDeviceNumber[0]); // MIN
-  responseStr[4] = strdup("1"); // PRL Version
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, responseStr, sizeof(responseStr));
+  char* responseStr[5] = {NULL};
+  responseStr[0] = strdup(&kCdmaMobileDeviceNumber[0]);  // MDN
+  responseStr[1] = strdup(&kCdmaSID[0]);                 // SID
+  responseStr[2] = strdup(&kCdmaNID[0]);                 // NID
+  responseStr[3] = strdup(&kCdmaMobileDeviceNumber[0]);  // MIN
+  responseStr[4] = strdup("1");                          // PRL Version
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, responseStr,
+                                 sizeof(responseStr));
 }
 
 static const int gMaxConcurrentVoiceCalls = 4;
@@ -1318,17 +1289,12 @@
 
   ALOGV("Requesting hardware configuration.");
 
-  strncpy(hw_cfg[0].uuid,
-          "com.google.avdgce1.modem",
-          sizeof(hw_cfg[0].uuid));
-  strncpy(hw_cfg[1].uuid,
-          "com.google.avdgce1.sim",
-          sizeof(hw_cfg[1].uuid));
-
+  strncpy(hw_cfg[0].uuid, "com.google.avdgce1.modem", sizeof(hw_cfg[0].uuid));
+  strncpy(hw_cfg[1].uuid, "com.google.avdgce1.sim", sizeof(hw_cfg[1].uuid));
 
   int technologies = 0;  // = unknown.
-  std::map<RIL_PreferredNetworkType, int>::iterator
-      iter = gModemTechnologies.find(gModemDefaultType);
+  std::map<RIL_PreferredNetworkType, int>::iterator iter =
+      gModemTechnologies.find(gModemDefaultType);
   if (iter != gModemTechnologies.end()) {
     technologies = iter->second;
   }
@@ -1353,8 +1319,8 @@
 // 0 = Home network only, 1 = preferred networks only, 2 = all networks.
 static int gCdmaRoamingPreference = 2;
 
-static void request_cdma_get_roaming_preference(
-    int request, void *data, size_t datalen, RIL_Token t) {
+static void request_cdma_get_roaming_preference(int request, void* data,
+                                                size_t datalen, RIL_Token t) {
   if (!isCDMA()) {
     // No such radio.
     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
@@ -1363,13 +1329,12 @@
 
   ALOGV("Requesting CDMA Roaming preference");
 
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, &gCdmaRoamingPreference,
-      sizeof(gCdmaRoamingPreference));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gCdmaRoamingPreference,
+                                 sizeof(gCdmaRoamingPreference));
 }
 
-static void request_cdma_set_roaming_preference(
-    int request, void *data, size_t datalen, RIL_Token t) {
+static void request_cdma_set_roaming_preference(int request, void* data,
+                                                size_t datalen, RIL_Token t) {
   if (!isCDMA()) {
     // No such radio.
     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
@@ -1377,8 +1342,8 @@
   }
 
   int pref = *(int*)data;
-  ALOGV("Changing CDMA roaming preference: %d -> %d",
-        gCdmaRoamingPreference, pref);
+  ALOGV("Changing CDMA roaming preference: %d -> %d", gCdmaRoamingPreference,
+        pref);
 
   if ((pref < 0) || (pref > 2)) {
     ALOGV("Unsupported roaming preference: %d", pref);
@@ -1390,7 +1355,7 @@
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 }
 
-static void request_send_ussd(void *data, size_t datalen, RIL_Token t) {
+static void request_send_ussd(void* data, size_t datalen, RIL_Token t) {
   ALOGV("Sending USSD code is currently not supported");
   // TODO(ender): support this feature
   gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
@@ -1402,8 +1367,8 @@
   gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
 }
 
-static void request_exit_emergency_mode(
-    void *data, size_t datalen, RIL_Token t) {
+static void request_exit_emergency_mode(void* data, size_t datalen,
+                                        RIL_Token t) {
   ALOGV("Exiting emergency callback mode.");
 
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
@@ -1423,7 +1388,7 @@
   ALOGE("Cancel operation not implemented");
 }
 
-static const char *gce_ril_get_version(void) {
+static const char* gce_ril_get_version(void) {
   ALOGV("Reporting GCE version " GCE_RIL_VERSION_STRING);
   return GCE_RIL_VERSION_STRING;
 }
@@ -1436,9 +1401,8 @@
 
 std::vector<RIL_NeighboringCell> gGSMNeighboringCells;
 
-static void request_get_neighboring_cell_ids(
-    void* data, size_t datalen, RIL_Token t) {
-
+static void request_get_neighboring_cell_ids(void* data, size_t datalen,
+                                             RIL_Token t) {
   ALOGV("Requesting GSM neighboring cell ids");
 
   if (!isGSM() || gGSMNeighboringCells.empty()) {
@@ -1453,14 +1417,14 @@
     cells[index] = &gGSMNeighboringCells[index];
   }
 
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, cells, sizeof(RIL_NeighboringCell*));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, cells,
+                                 sizeof(RIL_NeighboringCell*));
   delete[] cells;
 }
 
 #if VSOC_PLATFORM_SDK_AFTER(J_MR1)
-static void request_get_cell_info_list(
-    void *data, size_t datalen, RIL_Token t) {
+static void request_get_cell_info_list(void* data, size_t datalen,
+                                       RIL_Token t) {
   struct timespec now;
   uint64_t curTime;
 
@@ -1479,7 +1443,7 @@
     ci.cellInfoType = RIL_CELL_INFO_TYPE_GSM;
     ci.registered = 1;
     ci.timeStampType = RIL_TIMESTAMP_TYPE_ANTENNA;  // Our own timestamp.
-    ci.timeStamp = curTime - 1000;  // Fake time in the past.
+    ci.timeStamp = curTime - 1000;                  // Fake time in the past.
     ci.CellInfo.gsm.cellIdentityGsm.mcc = s_mcc;
     ci.CellInfo.gsm.cellIdentityGsm.mnc = s_mnc;
     ci.CellInfo.gsm.cellIdentityGsm.lac = s_lac;
@@ -1504,8 +1468,7 @@
 
   NetworkOperator() {}
 
-  NetworkOperator(const std::string& long_name,
-                  const std::string& short_name,
+  NetworkOperator(const std::string& long_name, const std::string& short_name,
                   bool is_accessible)
       : long_name(long_name),
         short_name(short_name),
@@ -1536,11 +1499,11 @@
 
 static OperatorSelectionMethod gOperatorSelectionMethod = kOperatorDeregistered;
 
-static void request_query_network_selection_mode(
-    void *data, size_t datalen, RIL_Token t) {
+static void request_query_network_selection_mode(void* data, size_t datalen,
+                                                 RIL_Token t) {
   ALOGV("Query operator selection mode (%d)", gOperatorSelectionMethod);
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, &gOperatorSelectionMethod, sizeof(gOperatorSelectionMethod));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gOperatorSelectionMethod,
+                                 sizeof(gOperatorSelectionMethod));
 }
 
 static void request_operator(void* data, size_t datalen, RIL_Token t) {
@@ -1554,18 +1517,17 @@
     return;
   }
 
-  const char* response[] = {
-    iter->second.long_name.c_str(),
-    iter->second.short_name.c_str(),
-    iter->first.c_str()
-  };
+  const char* response[] = {iter->second.long_name.c_str(),
+                            iter->second.short_name.c_str(),
+                            iter->first.c_str()};
 
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response));
 }
 
-static void request_query_available_networks(
-    void* data, size_t datalen, RIL_Token t) {
-  const char** available_networks = new const char*[gNetworkOperators.size() * 4];
+static void request_query_available_networks(void* data, size_t datalen,
+                                             RIL_Token t) {
+  const char** available_networks =
+      new const char*[gNetworkOperators.size() * 4];
 
   ALOGV("Querying available networks.");
 
@@ -1573,7 +1535,8 @@
   // registered.
   int index = 0;
   for (std::map<std::string, NetworkOperator>::iterator iter =
-       gNetworkOperators.begin(); iter != gNetworkOperators.end(); ++iter) {
+           gNetworkOperators.begin();
+       iter != gNetworkOperators.end(); ++iter) {
     // TODO(ender): wrap in a neat structure maybe?
     available_networks[index++] = iter->second.long_name.c_str();
     available_networks[index++] = iter->second.short_name.c_str();
@@ -1587,8 +1550,8 @@
     }
   }
 
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, &available_networks, 4 * gNetworkOperators.size());
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &available_networks,
+                                 4 * gNetworkOperators.size());
   delete[] available_networks;
 }
 
@@ -1599,8 +1562,8 @@
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 }
 
-static void request_set_manual_network_selection(
-    void* data, size_t datalen, RIL_Token t) {
+static void request_set_manual_network_selection(void* data, size_t datalen,
+                                                 RIL_Token t) {
   char* mccmnc = (char*)data;
 
   ALOGV("Requesting manual operator selection: %s", mccmnc);
@@ -1619,12 +1582,11 @@
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 }
 
-
 static const char kDefaultSMSC[] = "00";
 static int gNextSmsMessageId = 1;
 
 static void request_cdma_send_SMS(void* data, RIL_Token t) {
-  RIL_SMS_Response response = { 0, 0, 0 };
+  RIL_SMS_Response response = {0, 0, 0};
   // RIL_CDMA_SMS_Message* rcsm = (RIL_CDMA_SMS_Message*) data;
 
   ALOGW("CDMA SMS Send is currently not implemented.");
@@ -1633,12 +1595,12 @@
   // But it is not implemented yet.
   memset(&response, 0, sizeof(response));
   response.messageRef = -1;  // This must be BearerData MessageId.
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response,
+                                 sizeof(response));
 }
 
-static void request_send_SMS(void *data, RIL_Token t) {
-  RIL_SMS_Response response = { 0, 0, 0 };
+static void request_send_SMS(void* data, RIL_Token t) {
+  RIL_SMS_Response response = {0, 0, 0};
 
   ALOGV("Send GSM SMS Message");
 
@@ -1648,7 +1610,7 @@
 
   // PDU in hex-encoded string.
   const char* pdu = ((const char**)data)[1];
-  int pdu_length = strlen(pdu)/2;
+  int pdu_length = strlen(pdu) / 2;
 
   response.messageRef = gNextSmsMessageId++;
   response.ackPDU = NULL;
@@ -1662,19 +1624,19 @@
 }
 
 #if VSOC_PLATFORM_SDK_AFTER(J_MR1)
-static void request_set_cell_info_list_rate(
-    void *data, size_t datalen, RIL_Token t) {
+static void request_set_cell_info_list_rate(void* data, size_t datalen,
+                                            RIL_Token t) {
   // For now we'll save the rate but no RIL_UNSOL_CELL_INFO_LIST messages
   // will be sent.
   ALOGV("Setting cell info list rate.");
-  s_cell_info_rate_ms = ((int *) data)[0];
+  s_cell_info_rate_ms = ((int*)data)[0];
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 }
 #endif
 #if VSOC_PLATFORM_SDK_AFTER(J_MR2)
-static void request_ims_send_SMS(void *data, size_t datalen, RIL_Token t) {
+static void request_ims_send_SMS(void* data, size_t datalen, RIL_Token t) {
   RIL_IMS_SMS_Message* args = (RIL_IMS_SMS_Message*)data;
-  RIL_SMS_Response response = { 0 };
+  RIL_SMS_Response response = {0};
 
   ALOGV("Send IMS SMS Message");
 
@@ -1688,23 +1650,21 @@
     default:
       ALOGE("Invalid SMS format value: %d", args->tech);
       response.messageRef = -2;
-      gce_ril_env->OnRequestComplete(
-          t, RIL_E_GENERIC_FAILURE, &response, sizeof(response));
+      gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, &response,
+                                     sizeof(response));
   }
 }
 #endif
 
-static void request_SMS_acknowledge(void *data, size_t datalen, RIL_Token t) {
+static void request_SMS_acknowledge(void* data, size_t datalen, RIL_Token t) {
   int* ack = (int*)data;
 
   // TODO(ender): we should retain "incoming" sms for later reception.
-  ALOGV("SMS receipt %ssuccessful (reason %d).",
-        ack[0] ? "" : "un", ack[1]);
+  ALOGV("SMS receipt %ssuccessful (reason %d).", ack[0] ? "" : "un", ack[1]);
 
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
 }
 
-
 struct SimFileCommand {
   uint8_t command;
   uint16_t efid;
@@ -1712,21 +1672,17 @@
   uint8_t param2;
   uint8_t param3;
 
-  bool operator< (const SimFileCommand& other) const {
+  bool operator<(const SimFileCommand& other) const {
     uint64_t sum1, sum2;
-    sum1 = (command * 1ull << 40) | (efid  * 1ull << 24) |
-           (param1 << 16) | (param2 << 8) | (param3);
+    sum1 = (command * 1ull << 40) | (efid * 1ull << 24) | (param1 << 16) |
+           (param2 << 8) | (param3);
     sum2 = (other.command * 1ull << 40) | (other.efid * 1ull << 24) |
            (other.param1 << 16) | (other.param2 << 8) | (other.param3);
     return sum1 < sum2;
   }
 
   SimFileCommand(uint8_t cmd, uint16_t efid, uint8_t p1, uint8_t p2, uint8_t p3)
-      : command(cmd),
-        efid(efid),
-        param1(p1),
-        param2(p2),
-        param3(p3) {}
+      : command(cmd), efid(efid), param1(p1), param2(p2), param3(p3) {}
 };
 
 struct SimFileResponse {
@@ -1734,15 +1690,10 @@
   uint8_t sw2;
   const char* data;
 
-  SimFileResponse()
-      : sw1(0),
-        sw2(0),
-        data(NULL) {}
+  SimFileResponse() : sw1(0), sw2(0), data(NULL) {}
 
   SimFileResponse(uint8_t sw1, uint8_t sw2, const char* data)
-      : sw1(sw1),
-        sw2(sw2),
-        data(data) {}
+      : sw1(sw1), sw2(sw2), data(data) {}
 };
 
 // TODO(ender): Double check & rewrite these.
@@ -1791,21 +1742,23 @@
       SimFileResponse(148, 4, NULL);
   gSimFileSystem[SimFileCommand(192, 28613, 0, 0, 15)] =
       SimFileResponse(144, 0, "000000f06fc504000aa0aa01020118");
-  gSimFileSystem[SimFileCommand(178, 28613, 1, 4, 24)] =
-      SimFileResponse(144, 0, "43058441aa890affffffffffffffffffffffffffffffffff");
+  gSimFileSystem[SimFileCommand(178, 28613, 1, 4, 24)] = SimFileResponse(
+      144, 0, "43058441aa890affffffffffffffffffffffffffffffffff");
   gSimFileSystem[SimFileCommand(192, 28480, 0, 0, 15)] =
       SimFileResponse(144, 0, "000000806f40040011a0aa01020120");
   // Primary phone number encapsulated
   // [51][55][21][43][65][f7] = 1 555 1234 567$
-  gSimFileSystem[SimFileCommand(178, 28480, 1, 4, 32)] =
-      SimFileResponse(144, 0, "ffffffffffffffffffffffffffffffffffff07915155214365f7ffffffffffff");
+  gSimFileSystem[SimFileCommand(178, 28480, 1, 4, 32)] = SimFileResponse(
+      144, 0,
+      "ffffffffffffffffffffffffffffffffffff07915155214365f7ffffffffffff");
   gSimFileSystem[SimFileCommand(192, 28615, 0, 0, 15)] =
       SimFileResponse(144, 0, "000000406fc7040011a0aa01020120");
   // Voice mail number encapsulated
   // [56][6f][69][63][65][6d][61][69][6c] = 'Voicemail'
   // [51][55][67][45][23][f1] = 1 555 7654 321$
-  gSimFileSystem[SimFileCommand(178, 28615, 1, 4, 32)] =
-      SimFileResponse(144, 0, "566f6963656d61696cffffffffffffffffff07915155674523f1ffffffffffff");
+  gSimFileSystem[SimFileCommand(178, 28615, 1, 4, 32)] = SimFileResponse(
+      144, 0,
+      "566f6963656d61696cffffffffffffffffff07915155674523f1ffffffffffff");
   gSimFileSystem[SimFileCommand(192, 12037, 0, 0, 15)] =
       SimFileResponse(148, 4, NULL);
   gSimFileSystem[SimFileCommand(192, 28437, 0, 0, 15)] =
@@ -1830,14 +1783,15 @@
       SimFileResponse(144, 0, "00000013");
 }
 
-static void request_SIM_IO(void *data, size_t datalen, RIL_Token t) {
+static void request_SIM_IO(void* data, size_t datalen, RIL_Token t) {
   const RIL_SIM_IO_v6& args = *(RIL_SIM_IO_v6*)data;
-  RIL_SIM_IO_Response sr = { 0, 0, 0 };
+  RIL_SIM_IO_Response sr = {0, 0, 0};
 
-  ALOGV("Requesting SIM File IO: %d EFID %x, Params: %d, %d, %d, path: %s, "
-        "data %s PIN: %s AID: %s",
-        args.command, args.fileid, args.p1, args.p2, args.p3, args.path,
-        args.data, args.pin2, args.aidPtr);
+  ALOGV(
+      "Requesting SIM File IO: %d EFID %x, Params: %d, %d, %d, path: %s, "
+      "data %s PIN: %s AID: %s",
+      args.command, args.fileid, args.p1, args.p2, args.p3, args.path,
+      args.data, args.pin2, args.aidPtr);
 
   SimFileCommand cmd(args.command, args.fileid, args.p1, args.p2, args.p3);
 
@@ -1884,15 +1838,14 @@
       } else {
         ALOGV("PIN and PUK verification failed; locking SIM card.");
         gSimStatus = SIM_NOT_READY;
-        gce_ril_env->OnRequestComplete(
-            t, RIL_E_GENERIC_FAILURE, NULL, 0);
+        gce_ril_env->OnRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0);
         return;
       }
     }
 
-    gce_ril_env->OnRequestComplete(
-        t, RIL_E_PASSWORD_INCORRECT,
-        &remaining_attempts, sizeof(remaining_attempts));
+    gce_ril_env->OnRequestComplete(t, RIL_E_PASSWORD_INCORRECT,
+                                   &remaining_attempts,
+                                   sizeof(remaining_attempts));
   } else {
     if (gSimStatus == SIM_PUK) {
       ALOGV("Resetting SIM PIN to %s", pin_aid[1]);
@@ -1901,9 +1854,8 @@
 
     gSimPINAttempts = 0;
     gSimStatus = SIM_READY;
-    gce_ril_env->OnRequestComplete(
-        t, RIL_E_SUCCESS,
-        &remaining_attempts, sizeof(remaining_attempts));
+    gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &remaining_attempts,
+                                   sizeof(remaining_attempts));
   }
 
   pollSIMState(NULL);
@@ -1912,12 +1864,12 @@
 /**
  * No longer POLL.
  */
-static void pollSIMState(void *param) {
+static void pollSIMState(void* param) {
   // TODO(ender): check radio state?
 
   ALOGV("Polling SIM Status.");
 
-  switch(gSimStatus) {
+  switch (gSimStatus) {
     case SIM_ABSENT:
     case SIM_PIN:
     case SIM_PUK:
@@ -1933,8 +1885,7 @@
         gCurrentNetworkOperator = "310260";
       }
 
-      gce_ril_env->RequestTimedCallback(
-          pollSIMState, NULL, &TIMEVAL_SIMPOLL);
+      gce_ril_env->RequestTimedCallback(pollSIMState, NULL, &TIMEVAL_SIMPOLL);
       break;
 
     case SIM_READY:
@@ -1943,9 +1894,9 @@
   }
 
   if (gRadioPowerState != RADIO_STATE_OFF) {
+    gce_ril_env->OnUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED,
+                                       NULL, 0);
     gce_ril_env->OnUnsolicitedResponse(
-        RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0);
-    gce_ril_env->OnUnsolicitedResponse (
         RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, NULL, 0);
   }
 }
@@ -1953,56 +1904,107 @@
 std::map<SIM_Status, RIL_AppStatus> gRilAppStatus;
 
 static void init_sim_status() {
-  gRilAppStatus[SIM_ABSENT] = (RIL_AppStatus) {
-    RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN,
-    NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN
+  gRilAppStatus[SIM_ABSENT] = (RIL_AppStatus){RIL_APPTYPE_UNKNOWN,
+                                              RIL_APPSTATE_UNKNOWN,
+                                              RIL_PERSOSUBSTATE_UNKNOWN,
+                                              NULL,
+                                              NULL,
+                                              0,
+                                              RIL_PINSTATE_UNKNOWN,
+                                              RIL_PINSTATE_UNKNOWN};
+  gRilAppStatus[SIM_NOT_READY] =
+      (RIL_AppStatus){RIL_APPTYPE_SIM,
+                      RIL_APPSTATE_DETECTED,
+                      RIL_PERSOSUBSTATE_UNKNOWN,
+                      NULL,
+                      NULL,
+                      0,
+                      RIL_PINSTATE_ENABLED_NOT_VERIFIED,
+                      RIL_PINSTATE_ENABLED_NOT_VERIFIED};
+  gRilAppStatus[SIM_READY] = (RIL_AppStatus){
+      RIL_APPTYPE_SIM,
+      RIL_APPSTATE_READY,
+      RIL_PERSOSUBSTATE_READY,
+      NULL,
+      NULL,
+      0,
+      RIL_PINSTATE_ENABLED_VERIFIED,
+      RIL_PINSTATE_ENABLED_VERIFIED,
   };
-  gRilAppStatus[SIM_NOT_READY] = (RIL_AppStatus) {
-    RIL_APPTYPE_SIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN,
-        NULL, NULL, 0,
-        RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_ENABLED_NOT_VERIFIED
-  };
-  gRilAppStatus[SIM_READY] = (RIL_AppStatus) {
-    RIL_APPTYPE_SIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY,
-        NULL, NULL, 0,
-        RIL_PINSTATE_ENABLED_VERIFIED, RIL_PINSTATE_ENABLED_VERIFIED,
-  };
-  gRilAppStatus[SIM_PIN] = (RIL_AppStatus) {
-    RIL_APPTYPE_SIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN,
-        NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN
-  };
-  gRilAppStatus[SIM_PUK] = (RIL_AppStatus) {
-    RIL_APPTYPE_SIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN,
-        NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN
-  };
-  gRilAppStatus[SIM_NETWORK_PERSONALIZATION] = (RIL_AppStatus) {
-    RIL_APPTYPE_SIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK,
-        NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN
-  };
-  gRilAppStatus[RUIM_ABSENT] = (RIL_AppStatus) {
-    RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN,
-        NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN
-  };
-  gRilAppStatus[RUIM_NOT_READY] = (RIL_AppStatus) {
-    RIL_APPTYPE_RUIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN,
-        NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN
-  };
-  gRilAppStatus[RUIM_READY] = (RIL_AppStatus) {
-    RIL_APPTYPE_RUIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY,
-        NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN
-  };
-  gRilAppStatus[RUIM_PIN] = (RIL_AppStatus) {
-    RIL_APPTYPE_RUIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN,
-        NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN
-  };
-  gRilAppStatus[RUIM_PUK] = (RIL_AppStatus) {
-    RIL_APPTYPE_RUIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN,
-        NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN
-  };
-  gRilAppStatus[RUIM_NETWORK_PERSONALIZATION] = (RIL_AppStatus) {
-    RIL_APPTYPE_RUIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK,
-        NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN
-  };
+  gRilAppStatus[SIM_PIN] = (RIL_AppStatus){RIL_APPTYPE_SIM,
+                                           RIL_APPSTATE_PIN,
+                                           RIL_PERSOSUBSTATE_UNKNOWN,
+                                           NULL,
+                                           NULL,
+                                           0,
+                                           RIL_PINSTATE_ENABLED_NOT_VERIFIED,
+                                           RIL_PINSTATE_UNKNOWN};
+  gRilAppStatus[SIM_PUK] = (RIL_AppStatus){RIL_APPTYPE_SIM,
+                                           RIL_APPSTATE_PUK,
+                                           RIL_PERSOSUBSTATE_UNKNOWN,
+                                           NULL,
+                                           NULL,
+                                           0,
+                                           RIL_PINSTATE_ENABLED_BLOCKED,
+                                           RIL_PINSTATE_UNKNOWN};
+  gRilAppStatus[SIM_NETWORK_PERSONALIZATION] =
+      (RIL_AppStatus){RIL_APPTYPE_SIM,
+                      RIL_APPSTATE_SUBSCRIPTION_PERSO,
+                      RIL_PERSOSUBSTATE_SIM_NETWORK,
+                      NULL,
+                      NULL,
+                      0,
+                      RIL_PINSTATE_ENABLED_NOT_VERIFIED,
+                      RIL_PINSTATE_UNKNOWN};
+  gRilAppStatus[RUIM_ABSENT] = (RIL_AppStatus){RIL_APPTYPE_UNKNOWN,
+                                               RIL_APPSTATE_UNKNOWN,
+                                               RIL_PERSOSUBSTATE_UNKNOWN,
+                                               NULL,
+                                               NULL,
+                                               0,
+                                               RIL_PINSTATE_UNKNOWN,
+                                               RIL_PINSTATE_UNKNOWN};
+  gRilAppStatus[RUIM_NOT_READY] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
+                                                  RIL_APPSTATE_DETECTED,
+                                                  RIL_PERSOSUBSTATE_UNKNOWN,
+                                                  NULL,
+                                                  NULL,
+                                                  0,
+                                                  RIL_PINSTATE_UNKNOWN,
+                                                  RIL_PINSTATE_UNKNOWN};
+  gRilAppStatus[RUIM_READY] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
+                                              RIL_APPSTATE_READY,
+                                              RIL_PERSOSUBSTATE_READY,
+                                              NULL,
+                                              NULL,
+                                              0,
+                                              RIL_PINSTATE_UNKNOWN,
+                                              RIL_PINSTATE_UNKNOWN};
+  gRilAppStatus[RUIM_PIN] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
+                                            RIL_APPSTATE_PIN,
+                                            RIL_PERSOSUBSTATE_UNKNOWN,
+                                            NULL,
+                                            NULL,
+                                            0,
+                                            RIL_PINSTATE_ENABLED_NOT_VERIFIED,
+                                            RIL_PINSTATE_UNKNOWN};
+  gRilAppStatus[RUIM_PUK] = (RIL_AppStatus){RIL_APPTYPE_RUIM,
+                                            RIL_APPSTATE_PUK,
+                                            RIL_PERSOSUBSTATE_UNKNOWN,
+                                            NULL,
+                                            NULL,
+                                            0,
+                                            RIL_PINSTATE_ENABLED_BLOCKED,
+                                            RIL_PINSTATE_UNKNOWN};
+  gRilAppStatus[RUIM_NETWORK_PERSONALIZATION] =
+      (RIL_AppStatus){RIL_APPTYPE_RUIM,
+                      RIL_APPSTATE_SUBSCRIPTION_PERSO,
+                      RIL_PERSOSUBSTATE_SIM_NETWORK,
+                      NULL,
+                      NULL,
+                      0,
+                      RIL_PINSTATE_ENABLED_NOT_VERIFIED,
+                      RIL_PINSTATE_UNKNOWN};
 }
 
 /**
@@ -2042,8 +2044,8 @@
     //        gRilAppStatus[SIM_Status(gSimStatus + RUIM_ABSENT)];
   }
 
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, &card_status, sizeof(card_status));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &card_status,
+                                 sizeof(card_status));
 }
 
 struct SimSession {
@@ -2084,14 +2086,14 @@
 
 #if VSOC_PLATFORM_SDK_AFTER(K)
 static void request_sim_apdu(void* data, size_t datalen, RIL_Token t) {
-  RIL_SIM_APDU* apdu = (RIL_SIM_APDU*) data;
+  RIL_SIM_APDU* apdu = (RIL_SIM_APDU*)data;
 
   ALOGV("Requesting APDU: Session %d CLA %d INST %d Params: %d %d %d, data %s",
-        apdu->sessionid, apdu->cla, apdu->instruction,
-        apdu->p1, apdu->p2, apdu->p3, apdu->data);
+        apdu->sessionid, apdu->cla, apdu->instruction, apdu->p1, apdu->p2,
+        apdu->p3, apdu->data);
 
   if (gSimSessions.find(apdu->sessionid) != gSimSessions.end()) {
-    RIL_SIM_IO_Response sr = { 0 };
+    RIL_SIM_IO_Response sr = {0};
 
     // Fallback / default behavior.
     sr.sw1 = 144;
@@ -2125,24 +2127,22 @@
   ALOGV("Query Facility Lock Code: %s PIN2: %s Service(s): %s AID: %s",
         data_vec[0], data_vec[1], data_vec[2], data_vec[3]);
 
-
   // TODO(ender): there should be a bit vector of responses for each of the
   // services requested.
   // Depending on lock code, facilities may be unlocked or locked. We report
   // these are all unlocked, regardless of the query.
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, const_cast<int*>(&kFacilityLockAllDisabled),
-      sizeof(kFacilityLockAllDisabled));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
+                                 const_cast<int*>(&kFacilityLockAllDisabled),
+                                 sizeof(kFacilityLockAllDisabled));
 }
 
-
 static void request_international_subscriber_id_number(RIL_Token t) {
   // TODO(ender): Reuse MCC and MNC.
   std::string subscriber_id = gCurrentNetworkOperator.c_str();
   subscriber_id += "123456789";
 
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, strdup(subscriber_id.c_str()), sizeof(char*));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS,
+                                 strdup(subscriber_id.c_str()), sizeof(char*));
 }
 
 static bool gScreenIsOn = true;
@@ -2170,8 +2170,8 @@
 
 static void request_get_tty_mode(RIL_Token t) {
   ALOGV("Querying TTY mode");
-  gce_ril_env->OnRequestComplete(
-      t, RIL_E_SUCCESS, &gModemTtyMode, sizeof(gModemTtyMode));
+  gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, &gModemTtyMode,
+                                 sizeof(gModemTtyMode));
 }
 
 static bool gImsRegistered = false;
@@ -2183,29 +2183,29 @@
   reply[0] = gImsRegistered;
   reply[1] = gImsFormat;
 
-  ALOGV("Requesting IMS Registration state: %d, format=%d ",
-        reply[0], reply[1]);
+  ALOGV("Requesting IMS Registration state: %d, format=%d ", reply[0],
+        reply[1]);
 
   gce_ril_env->OnRequestComplete(t, RIL_E_SUCCESS, reply, sizeof(reply));
 }
 
-static void gce_ril_on_request(
-    int request, void* data, size_t datalen, RIL_Token t) {
+static void gce_ril_on_request(int request, void* data, size_t datalen,
+                               RIL_Token t) {
   int err;
 
   // Ignore all requests except RIL_REQUEST_GET_SIM_STATUS
   // when RADIO_STATE_UNAVAILABLE.
-  if (gRadioPowerState == RADIO_STATE_UNAVAILABLE
-      && request != RIL_REQUEST_GET_SIM_STATUS) {
+  if (gRadioPowerState == RADIO_STATE_UNAVAILABLE &&
+      request != RIL_REQUEST_GET_SIM_STATUS) {
     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
     return;
   }
 
   // Ignore all non-power requests when RADIO_STATE_OFF (except
   // RIL_REQUEST_GET_SIM_STATUS)
-  if (gRadioPowerState == RADIO_STATE_OFF
-      && !(request == RIL_REQUEST_RADIO_POWER
-           || request == RIL_REQUEST_GET_SIM_STATUS)) {
+  if (gRadioPowerState == RADIO_STATE_OFF &&
+      !(request == RIL_REQUEST_RADIO_POWER ||
+        request == RIL_REQUEST_GET_SIM_STATUS)) {
     gce_ril_env->OnRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0);
     return;
   }
@@ -2332,7 +2332,7 @@
     case RIL_REQUEST_OEM_HOOK_RAW:
     case RIL_REQUEST_OEM_HOOK_STRINGS:
       ALOGV("OEM Hooks not supported!");
-      gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL ,0);
+      gce_ril_env->OnRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0);
       break;
     case RIL_REQUEST_WRITE_SMS_TO_SIM:
       request_write_sms_to_sim(data, datalen, t);
@@ -2450,18 +2450,13 @@
 #define GCE_RIL_VERSION 6
 
 static const RIL_RadioFunctions ril_callbacks = {
-  GCE_RIL_VERSION,
-  gce_ril_on_request,
-  gce_ril_current_state,
-  gce_ril_on_supports,
-  gce_ril_on_cancel,
-  gce_ril_get_version
-};
+    GCE_RIL_VERSION,     gce_ril_on_request, gce_ril_current_state,
+    gce_ril_on_supports, gce_ril_on_cancel,  gce_ril_get_version};
 
 extern "C" {
 
-const RIL_RadioFunctions *RIL_Init(
-    const struct RIL_Env *env, int argc, char **argv) {
+const RIL_RadioFunctions* RIL_Init(const struct RIL_Env* env, int argc,
+                                   char** argv) {
   time(&gce_ril_start_time);
   gce_ril_env = env;
 
@@ -2477,4 +2472,3 @@
 }
 
 }  // extern "C"
-