/*
* Copyright (C) 2006 The Android Open Source Project
- * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
+import android.hardware.display.DisplayManager;
import android.net.ConnectivityManager;
import android.net.LocalSocket;
import android.net.LocalSocketAddress;
import android.os.Message;
import android.os.Parcel;
import android.os.PowerManager;
+import android.os.BatteryManager;
import android.os.SystemProperties;
import android.os.PowerManager.WakeLock;
+import android.os.SystemClock;
+import android.provider.Settings.SettingNotFoundException;
import android.telephony.CellInfo;
import android.telephony.NeighboringCellInfo;
import android.telephony.PhoneNumberUtils;
+import android.telephony.RadioAccessFamily;
import android.telephony.Rlog;
import android.telephony.SignalStrength;
import android.telephony.SmsManager;
import android.telephony.SmsMessage;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+import android.telephony.ModemActivityInfo;
import android.text.TextUtils;
import android.util.SparseArray;
+import android.view.Display;
import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo;
+import com.android.internal.telephony.gsm.SsData;
import com.android.internal.telephony.gsm.SuppServiceNotification;
import com.android.internal.telephony.uicc.IccCardApplicationStatus;
import com.android.internal.telephony.uicc.IccCardStatus;
import com.android.internal.telephony.cdma.CdmaSmsBroadcastConfigInfo;
import com.android.internal.telephony.dataconnection.DcFailCause;
import com.android.internal.telephony.dataconnection.DataCallResponse;
+import com.android.internal.telephony.dataconnection.DataProfile;
+import com.android.internal.telephony.RadioCapability;
+import com.android.internal.telephony.TelephonyDevController;
+import com.android.internal.telephony.HardwareConfig;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
private static RILRequest sPool = null;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 4;
+ private Context mContext;
//***** Instance Variables
int mSerial;
if (RIL.RILJ_LOGD) Rlog.d(LOG_TAG, serialString() + "< "
+ RIL.requestToString(mRequest)
- + " error: " + ex);
+ + " error: " + ex + " ret=" + RIL.retToString(mRequest, ret));
if (mResult != null) {
AsyncResult.forMessage(mResult, ret, ex);
static final String RILJ_LOG_TAG = "RILJ";
static final boolean RILJ_LOGD = true;
static final boolean RILJ_LOGV = false; // STOPSHIP if true
+ static final int RADIO_SCREEN_UNSET = -1;
+ static final int RADIO_SCREEN_OFF = 0;
+ static final int RADIO_SCREEN_ON = 1;
+
/**
* Wake lock timeout should be longer than the longest timeout in
RILSender mSender;
Thread mReceiverThread;
RILReceiver mReceiver;
+ Display mDefaultDisplay;
+ int mDefaultDisplayState = Display.STATE_UNKNOWN;
+ int mRadioScreenState = RADIO_SCREEN_UNSET;
+ boolean mIsDevicePlugged = false;
WakeLock mWakeLock;
final int mWakeLockTimeout;
// The number of wakelock requests currently active. Don't release the lock
// When we are testing emergency calls
AtomicBoolean mTestingEmergencyCall = new AtomicBoolean(false);
+ private Integer mInstanceId;
+
//***** Events
static final int EVENT_SEND = 1;
static final int RESPONSE_SOLICITED = 0;
static final int RESPONSE_UNSOLICITED = 1;
- static final String SOCKET_NAME_RIL = "rild";
+ static final String[] SOCKET_NAME_RIL = {"rild", "rild2", "rild3"};
static final int SOCKET_OPEN_RETRY_MILLIS = 4 * 1000;
private static final int CDMA_BROADCAST_SMS_NO_OF_SERVICE_CATEGORIES = 31;
- BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
+ private final DisplayManager.DisplayListener mDisplayListener =
+ new DisplayManager.DisplayListener() {
+ @Override
+ public void onDisplayAdded(int displayId) { }
+
+ @Override
+ public void onDisplayRemoved(int displayId) { }
+
+ @Override
+ public void onDisplayChanged(int displayId) {
+ if (displayId == Display.DEFAULT_DISPLAY) {
+ final int oldState = mDefaultDisplayState;
+ mDefaultDisplayState = mDefaultDisplay.getState();
+ if (mDefaultDisplayState != oldState) {
+ updateScreenState();
+ }
+ }
+ }
+ };
+
+ private final BroadcastReceiver mBatteryStateListener = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
- if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
- sendScreenState(true);
- } else if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
- sendScreenState(false);
- } else {
- Rlog.w(RILJ_LOG_TAG, "RIL received unexpected Intent: " + intent.getAction());
+ boolean oldState = mIsDevicePlugged;
+ // 0 means it's on battery
+ mIsDevicePlugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0) != 0;
+ if (mIsDevicePlugged != oldState) {
+ updateScreenState();
}
}
};
public void
run() {
int retryCount = 0;
+ String rilSocket = "rild";
try {for (;;) {
LocalSocket s = null;
LocalSocketAddress l;
+ if (mInstanceId == null || mInstanceId == 0 ) {
+ rilSocket = SOCKET_NAME_RIL[0];
+ } else {
+ rilSocket = SOCKET_NAME_RIL[mInstanceId];
+ }
+
try {
s = new LocalSocket();
- l = new LocalSocketAddress(SOCKET_NAME_RIL,
+ l = new LocalSocketAddress(rilSocket,
LocalSocketAddress.Namespace.RESERVED);
s.connect(l);
} catch (IOException ex){
if (retryCount == 8) {
Rlog.e (RILJ_LOG_TAG,
- "Couldn't find '" + SOCKET_NAME_RIL
+ "Couldn't find '" + rilSocket
+ "' socket after " + retryCount
+ " times, continuing to retry silently");
- } else if (retryCount > 0 && retryCount < 8) {
+ } else if (retryCount >= 0 && retryCount < 8) {
Rlog.i (RILJ_LOG_TAG,
- "Couldn't find '" + SOCKET_NAME_RIL
+ "Couldn't find '" + rilSocket
+ "' socket; retrying after timeout");
}
retryCount = 0;
mSocket = s;
- Rlog.i(RILJ_LOG_TAG, "Connected to '" + SOCKET_NAME_RIL + "' socket");
+ Rlog.i(RILJ_LOG_TAG, "(" + mInstanceId + ") Connected to '"
+ + rilSocket + "' socket");
int length = 0;
try {
p.recycle();
}
} catch (java.io.IOException ex) {
- Rlog.i(RILJ_LOG_TAG, "'" + SOCKET_NAME_RIL + "' socket closed",
+ Rlog.i(RILJ_LOG_TAG, "'" + rilSocket + "' socket closed",
ex);
} catch (Throwable tr) {
Rlog.e(RILJ_LOG_TAG, "Uncaught exception read length=" + length +
"Exception:" + tr.toString());
}
- Rlog.i(RILJ_LOG_TAG, "Disconnected from '" + SOCKET_NAME_RIL
+ Rlog.i(RILJ_LOG_TAG, "(" + mInstanceId + ") Disconnected from '" + rilSocket
+ "' socket");
setRadioState (RadioState.RADIO_UNAVAILABLE);
//***** Constructors
public RIL(Context context, int preferredNetworkType, int cdmaSubscription) {
+ this(context, preferredNetworkType, cdmaSubscription, null);
+ }
+
+ public RIL(Context context, int preferredNetworkType,
+ int cdmaSubscription, Integer instanceId) {
super(context);
if (RILJ_LOGD) {
riljLog("RIL(context, preferredNetworkType=" + preferredNetworkType +
" cdmaSubscription=" + cdmaSubscription + ")");
}
+ mContext = context;
mCdmaSubscription = cdmaSubscription;
mPreferredNetworkType = preferredNetworkType;
mPhoneType = RILConstants.NO_PHONE;
+ mInstanceId = instanceId;
PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, RILJ_LOG_TAG);
DEFAULT_WAKE_LOCK_TIMEOUT);
mWakeLockCount = 0;
- mSenderThread = new HandlerThread("RILSender");
+ mSenderThread = new HandlerThread("RILSender" + mInstanceId);
mSenderThread.start();
Looper looper = mSenderThread.getLooper();
if (cm.isNetworkSupported(ConnectivityManager.TYPE_MOBILE) == false) {
riljLog("Not starting RILReceiver: wifi-only");
} else {
- riljLog("Starting RILReceiver");
+ riljLog("Starting RILReceiver" + mInstanceId);
mReceiver = new RILReceiver();
- mReceiverThread = new Thread(mReceiver, "RILReceiver");
+ mReceiverThread = new Thread(mReceiver, "RILReceiver" + mInstanceId);
mReceiverThread.start();
- IntentFilter filter = new IntentFilter();
- filter.addAction(Intent.ACTION_SCREEN_ON);
- filter.addAction(Intent.ACTION_SCREEN_OFF);
- context.registerReceiver(mIntentReceiver, filter);
+ DisplayManager dm = (DisplayManager)context.getSystemService(
+ Context.DISPLAY_SERVICE);
+ mDefaultDisplay = dm.getDisplay(Display.DEFAULT_DISPLAY);
+ dm.registerDisplayListener(mDisplayListener, null);
+
+ IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
+ Intent batteryStatus = context.registerReceiver(mBatteryStateListener, filter);
+ if (batteryStatus != null) {
+ // 0 means it's on battery
+ mIsDevicePlugged = batteryStatus.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0) != 0;
+ }
}
+
+ TelephonyDevController tdc = TelephonyDevController.getInstance();
+ tdc.registerRIL(this);
}
//***** CommandsInterface implementation
mNITZTimeRegistrant
.notifyRegistrant(
new AsyncResult (null, mLastNITZTimeInfo, null));
- mLastNITZTimeInfo = null;
}
}
send(rr);
}
+ public void setUiccSubscription(int slotId, int appIndex, int subId,
+ int subStatus, Message result) {
+ //Note: This RIL request is also valid for SIM and RUIM (ICC card)
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_UICC_SUBSCRIPTION, result);
+
+ if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
+ + " slot: " + slotId + " appIndex: " + appIndex
+ + " subId: " + subId + " subStatus: " + subStatus);
+
+ rr.mParcel.writeInt(slotId);
+ rr.mParcel.writeInt(appIndex);
+ rr.mParcel.writeInt(subId);
+ rr.mParcel.writeInt(subStatus);
+
+ send(rr);
+ }
+
+ // FIXME This API should take an AID and slot ID
+ public void setDataAllowed(boolean allowed, Message result) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_ALLOW_DATA, result);
+ if (RILJ_LOGD) {
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) +
+ " allowed: " + allowed);
+ }
+
+ rr.mParcel.writeInt(1);
+ rr.mParcel.writeInt(allowed ? 1 : 0);
+ send(rr);
+ }
+
@Override public void
supplyIccPin(String pin, Message result) {
supplyIccPinForApp(pin, null, result);
send(rr);
}
+ @Override
+ public void
+ getHardwareConfig (Message result) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_HARDWARE_CONFIG, result);
+
+ if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+
+ send(rr);
+ }
+
@Override
public void
sendDtmf(char c, Message result) {
send(rr);
}
+ @Override
+ public void
+ sendSMSExpectMore (String smscPDU, String pdu, Message result) {
+ RILRequest rr
+ = RILRequest.obtain(RIL_REQUEST_SEND_SMS_EXPECT_MORE, result);
+
+ constructGsmSendSmsRilRequest(rr, smscPDU, pdu);
+
+ if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+
+ send(rr);
+ }
+
private void
constructCdmaSendSmsRilRequest(RILRequest rr, byte[] pdu) {
int address_nbr_of_digits;
Message result) {
RILRequest rr = RILRequest.obtain(RIL_REQUEST_IMS_SEND_SMS, result);
- rr.mParcel.writeInt(1); //RIL_IMS_SMS_Format.FORMAT_3GPP
+ rr.mParcel.writeInt(RILConstants.GSM_PHONE);
rr.mParcel.writeByte((byte)retry);
rr.mParcel.writeInt(messageRef);
sendImsCdmaSms(byte[] pdu, int retry, int messageRef, Message result) {
RILRequest rr = RILRequest.obtain(RIL_REQUEST_IMS_SEND_SMS, result);
- rr.mParcel.writeInt(2); //RIL_IMS_SMS_Format.FORMAT_3GPP2
+ rr.mParcel.writeInt(RILConstants.CDMA_PHONE);
rr.mParcel.writeByte((byte)retry);
rr.mParcel.writeInt(messageRef);
send(rr);
}
+ @Override
+ public void requestShutdown(Message result) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_SHUTDOWN, result);
+
+ if (RILJ_LOGD)
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+
+ send(rr);
+ }
+
@Override
public void
setSuppServiceNotifications(boolean enable, Message result) {
* Query the list of band mode supported by RF.
*
* @param response is callback message
- * ((AsyncResult)response.obj).result is an int[] with every
- * element representing one avialable BM_*_BAND
+ * ((AsyncResult)response.obj).result is an int[] where int[0] is
+ * the size of the array and the rest of each element representing
+ * one available BM_*_BAND
*/
@Override
public void queryAvailableBandMode (Message response) {
send(rr);
}
- /**
- * {@inheritDoc}
- */
- @Override
- public void setCurrentPreferredNetworkType() {
- if (RILJ_LOGD) riljLog("setCurrentPreferredNetworkType: " + mSetPreferredNetworkType);
- setPreferredNetworkType(mSetPreferredNetworkType, null);
- }
- private int mSetPreferredNetworkType;
-
/**
* {@inheritDoc}
*/
rr.mParcel.writeInt(1);
rr.mParcel.writeInt(networkType);
- mSetPreferredNetworkType = networkType;
mPreferredNetworkType = networkType;
if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
//***** Private Methods
+ // TODO(jeffbrown): Delete me.
+ // The RIL should *not* be listening for screen state changes since they are
+ // becoming increasingly ambiguous on our devices. The RIL_REQUEST_SCREEN_STATE
+ // message should be deleted and replaced with more precise messages to control
+ // behavior such as signal strength reporting or power managements based on
+ // more robust signals.
+ /**
+ * Update the screen state. Send screen state ON if the default display is ON or the device
+ * is plugged.
+ */
+ private void updateScreenState() {
+ final int oldState = mRadioScreenState;
+ mRadioScreenState = (mDefaultDisplayState == Display.STATE_ON || mIsDevicePlugged)
+ ? RADIO_SCREEN_ON : RADIO_SCREEN_OFF;
+ if (mRadioScreenState != oldState) {
+ if (RILJ_LOGV) {
+ riljLog("defaultDisplayState: " + mDefaultDisplayState
+ + ", isDevicePlugged: " + mIsDevicePlugged);
+ }
+ sendScreenState(mRadioScreenState == RADIO_SCREEN_ON);
+ }
+ }
+
private void sendScreenState(boolean on) {
RILRequest rr = RILRequest.obtain(RIL_REQUEST_SCREEN_STATE, null);
rr.mParcel.writeInt(1);
onRadioAvailable() {
// In case screen state was lost (due to process crash),
// this ensures that the RIL knows the correct screen state.
-
- PowerManager pm = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE);
- sendScreenState(pm.isScreenOn());
+ updateScreenState();
}
private RadioState getRadioStateFromInt(int stateInt) {
case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: ret = responseVoid(p); break;
case RIL_REQUEST_CONFERENCE: ret = responseVoid(p); break;
case RIL_REQUEST_UDUB: ret = responseVoid(p); break;
- case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: ret = responseInts(p); break;
+ case RIL_REQUEST_LAST_CALL_FAIL_CAUSE: ret = responseFailCause(p); break;
case RIL_REQUEST_SIGNAL_STRENGTH: ret = responseSignalStrength(p); break;
case RIL_REQUEST_VOICE_REGISTRATION_STATE: ret = responseStrings(p); break;
case RIL_REQUEST_DATA_REGISTRATION_STATE: ret = responseStrings(p); break;
case RIL_REQUEST_GET_CELL_INFO_LIST: ret = responseCellInfoList(p); break;
case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: ret = responseVoid(p); break;
case RIL_REQUEST_SET_INITIAL_ATTACH_APN: ret = responseVoid(p); break;
+ case RIL_REQUEST_SET_DATA_PROFILE: ret = responseVoid(p); break;
case RIL_REQUEST_IMS_REGISTRATION_STATE: ret = responseInts(p); break;
case RIL_REQUEST_IMS_SEND_SMS: ret = responseSMS(p); break;
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: ret = responseICC_IO(p); break;
+ case RIL_REQUEST_SIM_OPEN_CHANNEL: ret = responseInts(p); break;
+ case RIL_REQUEST_SIM_CLOSE_CHANNEL: ret = responseVoid(p); break;
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: ret = responseICC_IO(p); break;
+ case RIL_REQUEST_NV_READ_ITEM: ret = responseString(p); break;
+ case RIL_REQUEST_NV_WRITE_ITEM: ret = responseVoid(p); break;
+ case RIL_REQUEST_NV_WRITE_CDMA_PRL: ret = responseVoid(p); break;
+ case RIL_REQUEST_NV_RESET_CONFIG: ret = responseVoid(p); break;
+ case RIL_REQUEST_SET_UICC_SUBSCRIPTION: ret = responseVoid(p); break;
+ case RIL_REQUEST_ALLOW_DATA: ret = responseVoid(p); break;
+ case RIL_REQUEST_GET_HARDWARE_CONFIG: ret = responseHardwareConfig(p); break;
+ case RIL_REQUEST_SIM_AUTHENTICATION: ret = responseICC_IOBase64(p); break;
+ case RIL_REQUEST_SHUTDOWN: ret = responseVoid(p); break;
+ case RIL_REQUEST_GET_RADIO_CAPABILITY: ret = responseRadioCapability(p); break;
+ case RIL_REQUEST_SET_RADIO_CAPABILITY: ret = responseRadioCapability(p); break;
+ case RIL_REQUEST_START_LCE: ret = responseLceStatus(p); break;
+ case RIL_REQUEST_STOP_LCE: ret = responseLceStatus(p); break;
+ case RIL_REQUEST_PULL_LCEDATA: ret = responseLceData(p); break;
+ case RIL_REQUEST_GET_ACTIVITY_INFO: ret = responseActivityData(p); break;
default:
throw new RuntimeException("Unrecognized solicited response: " + rr.mRequest);
//break;
}
}
+ if (rr.mRequest == RIL_REQUEST_SHUTDOWN) {
+ // Set RADIO_STATE to RADIO_UNAVAILABLE to continue shutdown process
+ // regardless of error code to continue shutdown procedure.
+ riljLog("Response to RIL_REQUEST_SHUTDOWN received. Error is " +
+ error + " Setting Radio State to Unavailable regardless of error.");
+ setRadioState(RadioState.RADIO_UNAVAILABLE);
+ }
+
// Here and below fake RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, see b/7255789.
// This is needed otherwise we don't automatically transition to the main lock
// screen when the pin or puk is entered incorrectly.
mIccStatusChangedRegistrants.notifyRegistrants();
}
break;
+ case RIL_REQUEST_GET_RADIO_CAPABILITY: {
+ // Ideally RIL's would support this or at least give NOT_SUPPORTED
+ // but the hammerhead RIL reports GENERIC :(
+ // TODO - remove GENERIC_FAILURE catching: b/21079604
+ if (REQUEST_NOT_SUPPORTED == error ||
+ GENERIC_FAILURE == error) {
+ // we should construct the RAF bitmask the radio
+ // supports based on preferred network bitmasks
+ ret = makeStaticRadioCapability();
+ error = 0;
+ }
+ break;
+ }
+ case RIL_REQUEST_GET_ACTIVITY_INFO:
+ ret = new ModemActivityInfo(0, 0, 0,
+ new int [ModemActivityInfo.TX_POWER_LEVELS], 0, 0);
+ error = 0;
+ break;
}
- rr.onError(error, ret);
- } else {
+ if (error != 0) rr.onError(error, ret);
+ }
+ if (error == 0) {
if (RILJ_LOGD) riljLog(rr.serialString() + "< " + requestToString(rr.mRequest)
+ " " + retToString(rr.mRequest, ret));
return rr;
}
- private String
+ private RadioCapability makeStaticRadioCapability() {
+ // default to UNKNOWN so we fail fast.
+ int raf = RadioAccessFamily.RAF_UNKNOWN;
+
+ String rafString = mContext.getResources().getString(
+ com.android.internal.R.string.config_radio_access_family);
+ if (TextUtils.isEmpty(rafString) == false) {
+ raf = RadioAccessFamily.rafTypeFromString(rafString);
+ }
+ RadioCapability rc = new RadioCapability(mInstanceId.intValue(), 0, 0, raf,
+ "", RadioCapability.RC_STATUS_SUCCESS);
+ if (RILJ_LOGD) riljLog("Faking RIL_REQUEST_GET_RADIO_CAPABILITY response using " + raf);
+ return rc;
+ }
+
+ static String
retToString(int req, Object ret) {
if (ret == null) return "";
switch (req) {
case RIL_REQUEST_GET_IMSI:
case RIL_REQUEST_GET_IMEI:
case RIL_REQUEST_GET_IMEISV:
+ case RIL_REQUEST_SIM_OPEN_CHANNEL:
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL:
+
if (!RILJ_LOGV) {
// If not versbose logging just return and don't display IMSI and IMEI, IMEISV
return "";
s = sb.toString();
}else if (req == RIL_REQUEST_GET_CURRENT_CALLS) {
ArrayList<DriverCall> calls = (ArrayList<DriverCall>) ret;
- sb = new StringBuilder(" ");
+ sb = new StringBuilder("{");
for (DriverCall dc : calls) {
sb.append("[").append(dc).append("] ");
}
+ sb.append("}");
s = sb.toString();
} else if (req == RIL_REQUEST_GET_NEIGHBORING_CELL_IDS) {
- ArrayList<NeighboringCellInfo> cells;
- cells = (ArrayList<NeighboringCellInfo>) ret;
- sb = new StringBuilder(" ");
+ ArrayList<NeighboringCellInfo> cells = (ArrayList<NeighboringCellInfo>) ret;
+ sb = new StringBuilder("{");
for (NeighboringCellInfo cell : cells) {
- sb.append(cell).append(" ");
+ sb.append("[").append(cell).append("] ");
+ }
+ sb.append("}");
+ s = sb.toString();
+ } else if (req == RIL_REQUEST_QUERY_CALL_FORWARD_STATUS) {
+ CallForwardInfo[] cinfo = (CallForwardInfo[]) ret;
+ length = cinfo.length;
+ sb = new StringBuilder("{");
+ for(int i = 0; i < length; i++) {
+ sb.append("[").append(cinfo[i]).append("] ");
+ }
+ sb.append("}");
+ s = sb.toString();
+ } else if (req == RIL_REQUEST_GET_HARDWARE_CONFIG) {
+ ArrayList<HardwareConfig> hwcfgs = (ArrayList<HardwareConfig>) ret;
+ sb = new StringBuilder(" ");
+ for (HardwareConfig hwcfg : hwcfgs) {
+ sb.append("[").append(hwcfg).append("] ");
}
s = sb.toString();
} else {
case RIL_UNSOL_VOICE_RADIO_TECH_CHANGED: ret = responseInts(p); break;
case RIL_UNSOL_CELL_INFO_LIST: ret = responseCellInfoList(p); break;
case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: ret = responseVoid(p); break;
+ case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: ret = responseInts(p); break;
+ case RIL_UNSOL_SRVCC_STATE_NOTIFY: ret = responseInts(p); break;
+ case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: ret = responseHardwareConfig(p); break;
+ case RIL_UNSOL_RADIO_CAPABILITY:
+ ret = responseRadioCapability(p); break;
+ case RIL_UNSOL_ON_SS: ret = responseSsData(p); break;
+ case RIL_UNSOL_STK_CC_ALPHA_NOTIFY: ret = responseString(p); break;
+ case RIL_UNSOL_LCEDATA_RECV: ret = responseLceData(p); break;
default:
throw new RuntimeException("Unrecognized unsol response: " + response);
mNITZTimeRegistrant
.notifyRegistrant(new AsyncResult (null, result, null));
- } else {
- // in case NITZ time registrant isnt registered yet
- mLastNITZTimeInfo = result;
}
+ // in case NITZ time registrant isn't registered yet, or a new registrant
+ // registers later
+ mLastNITZTimeInfo = result;
}
break;
break;
case RIL_UNSOL_STK_PROACTIVE_COMMAND:
- if (RILJ_LOGD) unsljLogRet(response, ret);
+ if (RILJ_LOGD) unsljLog(response);
if (mCatProCmdRegistrant != null) {
mCatProCmdRegistrant.notifyRegistrant(
break;
case RIL_UNSOL_STK_EVENT_NOTIFY:
- if (RILJ_LOGD) unsljLogRet(response, ret);
+ if (RILJ_LOGD) unsljLog(response);
if (mCatEventRegistrant != null) {
mCatEventRegistrant.notifyRegistrant(
break;
case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS:
- if (RILJ_LOGD) unsljLog(response);
+ if (RILJ_LOGD) unsljLogvRet(response, IccUtils.bytesToHexString((byte[])ret));
if (mGsmBroadcastSmsRegistrant != null) {
mGsmBroadcastSmsRegistrant
break;
case RIL_UNSOL_OEM_HOOK_RAW:
- if (RILJ_LOGD) unsljLogvRet(response, IccUtils.bytesToHexString((byte[])ret));
+ if (RILJ_LOGD) unsljLogvRet(response, IccUtils.bytesToHexString((byte[]) ret));
if (mUnsolOemHookRawRegistrant != null) {
mUnsolOemHookRawRegistrant.notifyRegistrant(new AsyncResult(null, ret, null));
}
// Initial conditions
setRadioPower(false, null);
- setPreferredNetworkType(mPreferredNetworkType, null);
setCdmaSubscriptionSource(mCdmaSubscription, null);
setCellInfoListRate(Integer.MAX_VALUE, null);
notifyRegistrantsRilConnectionChanged(((int[])ret)[0]);
}
break;
}
+ case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED: {
+ if (RILJ_LOGD) unsljLogRet(response, ret);
+
+ if (mSubscriptionStatusRegistrants != null) {
+ mSubscriptionStatusRegistrants.notifyRegistrants(
+ new AsyncResult (null, ret, null));
+ }
+ break;
+ }
+ case RIL_UNSOL_SRVCC_STATE_NOTIFY: {
+ if (RILJ_LOGD) unsljLogRet(response, ret);
+
+ if (mSrvccStateRegistrants != null) {
+ mSrvccStateRegistrants
+ .notifyRegistrants(new AsyncResult(null, ret, null));
+ }
+ break;
+ }
+ case RIL_UNSOL_HARDWARE_CONFIG_CHANGED:
+ if (RILJ_LOGD) unsljLogRet(response, ret);
+
+ if (mHardwareConfigChangeRegistrants != null) {
+ mHardwareConfigChangeRegistrants.notifyRegistrants(
+ new AsyncResult (null, ret, null));
+ }
+ break;
+ case RIL_UNSOL_RADIO_CAPABILITY:
+ if (RILJ_LOGD) unsljLogRet(response, ret);
+
+ if (mPhoneRadioCapabilityChangedRegistrants != null) {
+ mPhoneRadioCapabilityChangedRegistrants.notifyRegistrants(
+ new AsyncResult(null, ret, null));
+ }
+ break;
+ case RIL_UNSOL_ON_SS:
+ if (RILJ_LOGD) unsljLogRet(response, ret);
+
+ if (mSsRegistrant != null) {
+ mSsRegistrant.notifyRegistrant(
+ new AsyncResult (null, ret, null));
+ }
+ break;
+ case RIL_UNSOL_STK_CC_ALPHA_NOTIFY:
+ if (RILJ_LOGD) unsljLogRet(response, ret);
+
+ if (mCatCcAlphaRegistrant != null) {
+ mCatCcAlphaRegistrant.notifyRegistrant(
+ new AsyncResult (null, ret, null));
+ }
+ break;
+ case RIL_UNSOL_LCEDATA_RECV:
+ if (RILJ_LOGD) unsljLogRet(response, ret);
+
+ if (mLceInfoRegistrant != null) {
+ mLceInfoRegistrant.notifyRegistrant(new AsyncResult(null, ret, null));
+ }
+ break;
}
}
return response;
}
+ private Object
+ responseFailCause(Parcel p) {
+ LastCallFailCause failCause = new LastCallFailCause();
+ failCause.causeCode = p.readInt();
+ if (p.dataAvail() > 0) {
+ failCause.vendorCause = p.readString();
+ }
+ return failCause;
+ }
private Object
responseVoid(Parcel p) {
return new IccIoResult(sw1, sw2, s);
}
+ private Object
+ responseICC_IOBase64(Parcel p) {
+ int sw1, sw2;
+ Message ret;
+
+ sw1 = p.readInt();
+ sw2 = p.readInt();
+
+ String s = p.readString();
+
+ if (RILJ_LOGV) riljLog("< iccIO: "
+ + " 0x" + Integer.toHexString(sw1)
+ + " 0x" + Integer.toHexString(sw2) + " "
+ + s);
+
+ return new IccIoResult(sw1, sw2, (s != null)
+ ? android.util.Base64.decode(s, android.util.Base64.DEFAULT) : (byte[]) null);
+ }
+
private Object
responseIccCardStatus(Parcel p) {
IccCardApplicationStatus appStatus;
int np = p.readInt();
dc.numberPresentation = DriverCall.presentationFromCLIP(np);
dc.name = p.readString();
- dc.namePresentation = p.readInt();
+ // according to ril.h, namePresentation should be handled as numberPresentation;
+ dc.namePresentation = DriverCall.presentationFromCLIP(p.readInt());
int uusInfoPresent = p.readInt();
if (uusInfoPresent == 1) {
dc.uusInfo = new UUSInfo();
if (!TextUtils.isEmpty(gateways)) {
dataCall.gateways = gateways.split(" ");
}
+ if (version >= 10) {
+ String pcscf = p.readString();
+ if (!TextUtils.isEmpty(pcscf)) {
+ dataCall.pcscf = pcscf.split(" ");
+ }
+ }
+ if (version >= 11) {
+ dataCall.mtu = p.readInt();
+ }
}
return dataCall;
}
dataCall.gateways = gateways.split(" ");
}
}
+ if (num >= 6) {
+ String pcscf = p.readString();
+ if (RILJ_LOGD) riljLog("responseSetupDataCall got pcscf=" + pcscf);
+ if (!TextUtils.isEmpty(pcscf)) {
+ dataCall.pcscf = pcscf.split(" ");
+ }
+ }
} else {
if (num != 1) {
throw new RuntimeException(
response = new ArrayList<NeighboringCellInfo>();
// Determine the radio access type
- String radioString = SystemProperties.get(
- TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE, "unknown");
- int radioType;
- if (radioString.equals("GPRS")) {
- radioType = NETWORK_TYPE_GPRS;
- } else if (radioString.equals("EDGE")) {
- radioType = NETWORK_TYPE_EDGE;
- } else if (radioString.equals("UMTS")) {
- radioType = NETWORK_TYPE_UMTS;
- } else if (radioString.equals("HSDPA")) {
- radioType = NETWORK_TYPE_HSDPA;
- } else if (radioString.equals("HSUPA")) {
- radioType = NETWORK_TYPE_HSUPA;
- } else if (radioString.equals("HSPA")) {
- radioType = NETWORK_TYPE_HSPA;
- } else {
- radioType = NETWORK_TYPE_UNKNOWN;
- }
+ int[] subId = SubscriptionManager.getSubId(mInstanceId);
+ int radioType =
+ ((TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE)).
+ getDataNetworkType(subId[0]);
// Interpret the location based on radio access type
if (radioType != NETWORK_TYPE_UNKNOWN) {
return response;
}
+ private Object
+ responseHardwareConfig(Parcel p) {
+ int num;
+ ArrayList<HardwareConfig> response;
+ HardwareConfig hw;
+
+ num = p.readInt();
+ response = new ArrayList<HardwareConfig>(num);
+
+ if (RILJ_LOGV) {
+ riljLog("responseHardwareConfig: num=" + num);
+ }
+ for (int i = 0 ; i < num ; i++) {
+ int type = p.readInt();
+ switch(type) {
+ case HardwareConfig.DEV_HARDWARE_TYPE_MODEM: {
+ hw = new HardwareConfig(type);
+ hw.assignModem(p.readString(), p.readInt(), p.readInt(),
+ p.readInt(), p.readInt(), p.readInt(), p.readInt());
+ break;
+ }
+ case HardwareConfig.DEV_HARDWARE_TYPE_SIM: {
+ hw = new HardwareConfig(type);
+ hw.assignSim(p.readString(), p.readInt(), p.readString());
+ break;
+ }
+ default: {
+ throw new RuntimeException(
+ "RIL_REQUEST_GET_HARDWARE_CONFIG invalid hardward type:" + type);
+ }
+ }
+
+ response.add(hw);
+ }
+
+ return response;
+ }
+
+ private Object
+ responseRadioCapability(Parcel p) {
+ int version = p.readInt();
+ int session = p.readInt();
+ int phase = p.readInt();
+ int rat = p.readInt();
+ String logicModemUuid = p.readString();
+ int status = p.readInt();
+
+ riljLog("responseRadioCapability: version= " + version +
+ ", session=" + session +
+ ", phase=" + phase +
+ ", rat=" + rat +
+ ", logicModemUuid=" + logicModemUuid +
+ ", status=" + status);
+ RadioCapability rc = new RadioCapability(
+ mInstanceId.intValue(), session, phase, rat, logicModemUuid, status);
+ return rc;
+ }
+
+ private Object responseLceData(Parcel p) {
+ final ArrayList<Integer> capacityResponse = new ArrayList<Integer>();
+ final int capacityDownKbps = p.readInt();
+ final int confidenceLevel = p.readByte();
+ final int lceSuspended = p.readByte();
+
+ riljLog("LCE capacity information received:" +
+ " capacity=" + capacityDownKbps +
+ " confidence=" + confidenceLevel +
+ " lceSuspended=" + lceSuspended);
+
+ capacityResponse.add(capacityDownKbps);
+ capacityResponse.add(confidenceLevel);
+ capacityResponse.add(lceSuspended);
+ return capacityResponse;
+ }
+
+ private Object responseLceStatus(Parcel p) {
+ final ArrayList<Integer> statusResponse = new ArrayList<Integer>();
+ final int lceStatus = (int)p.readByte();
+ final int actualInterval = p.readInt();
+
+ riljLog("LCE status information received:" +
+ " lceStatus=" + lceStatus +
+ " actualInterval=" + actualInterval);
+ statusResponse.add(lceStatus);
+ statusResponse.add(actualInterval);
+ return statusResponse;
+ }
+
+ private Object responseActivityData(Parcel p) {
+ final int sleepModeTimeMs = p.readInt();
+ final int idleModeTimeMs = p.readInt();
+ int [] txModeTimeMs = new int[ModemActivityInfo.TX_POWER_LEVELS];
+ for (int i = 0; i < ModemActivityInfo.TX_POWER_LEVELS; i++) {
+ txModeTimeMs[i] = p.readInt();
+ }
+ final int rxModeTimeMs = p.readInt();
+
+ riljLog("Modem activity info received:" +
+ " sleepModeTimeMs=" + sleepModeTimeMs +
+ " idleModeTimeMs=" + idleModeTimeMs +
+ " txModeTimeMs[]=" + Arrays.toString(txModeTimeMs) +
+ " rxModeTimeMs=" + rxModeTimeMs);
+
+ return new ModemActivityInfo(SystemClock.elapsedRealtime(), sleepModeTimeMs,
+ idleModeTimeMs, txModeTimeMs, rxModeTimeMs, 0);
+ }
+
static String
requestToString(int request) {
/*
case RIL_REQUEST_GET_CELL_INFO_LIST: return "RIL_REQUEST_GET_CELL_INFO_LIST";
case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: return "RIL_REQUEST_SET_CELL_INFO_LIST_RATE";
case RIL_REQUEST_SET_INITIAL_ATTACH_APN: return "RIL_REQUEST_SET_INITIAL_ATTACH_APN";
+ case RIL_REQUEST_SET_DATA_PROFILE: return "RIL_REQUEST_SET_DATA_PROFILE";
case RIL_REQUEST_IMS_REGISTRATION_STATE: return "RIL_REQUEST_IMS_REGISTRATION_STATE";
case RIL_REQUEST_IMS_SEND_SMS: return "RIL_REQUEST_IMS_SEND_SMS";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC: return "RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC";
+ case RIL_REQUEST_SIM_OPEN_CHANNEL: return "RIL_REQUEST_SIM_OPEN_CHANNEL";
+ case RIL_REQUEST_SIM_CLOSE_CHANNEL: return "RIL_REQUEST_SIM_CLOSE_CHANNEL";
+ case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: return "RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL";
+ case RIL_REQUEST_NV_READ_ITEM: return "RIL_REQUEST_NV_READ_ITEM";
+ case RIL_REQUEST_NV_WRITE_ITEM: return "RIL_REQUEST_NV_WRITE_ITEM";
+ case RIL_REQUEST_NV_WRITE_CDMA_PRL: return "RIL_REQUEST_NV_WRITE_CDMA_PRL";
+ case RIL_REQUEST_NV_RESET_CONFIG: return "RIL_REQUEST_NV_RESET_CONFIG";
+ case RIL_REQUEST_SET_UICC_SUBSCRIPTION: return "RIL_REQUEST_SET_UICC_SUBSCRIPTION";
+ case RIL_REQUEST_ALLOW_DATA: return "RIL_REQUEST_ALLOW_DATA";
+ case RIL_REQUEST_GET_HARDWARE_CONFIG: return "GET_HARDWARE_CONFIG";
+ case RIL_REQUEST_SIM_AUTHENTICATION: return "RIL_REQUEST_SIM_AUTHENTICATION";
+ case RIL_REQUEST_SHUTDOWN: return "RIL_REQUEST_SHUTDOWN";
+ case RIL_REQUEST_SET_RADIO_CAPABILITY:
+ return "RIL_REQUEST_SET_RADIO_CAPABILITY";
+ case RIL_REQUEST_GET_RADIO_CAPABILITY:
+ return "RIL_REQUEST_GET_RADIO_CAPABILITY";
+ case RIL_REQUEST_START_LCE: return "RIL_REQUEST_START_LCE";
+ case RIL_REQUEST_STOP_LCE: return "RIL_REQUEST_STOP_LCE";
+ case RIL_REQUEST_PULL_LCEDATA: return "RIL_REQUEST_PULL_LCEDATA";
+ case RIL_REQUEST_GET_ACTIVITY_INFO: return "RIL_REQUEST_GET_ACTIVITY_INFO";
default: return "<unknown request>";
}
}
case RIL_UNSOL_CELL_INFO_LIST: return "UNSOL_CELL_INFO_LIST";
case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED:
return "UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED";
+ case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED:
+ return "RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED";
+ case RIL_UNSOL_SRVCC_STATE_NOTIFY:
+ return "UNSOL_SRVCC_STATE_NOTIFY";
+ case RIL_UNSOL_HARDWARE_CONFIG_CHANGED: return "RIL_UNSOL_HARDWARE_CONFIG_CHANGED";
+ case RIL_UNSOL_RADIO_CAPABILITY:
+ return "RIL_UNSOL_RADIO_CAPABILITY";
+ case RIL_UNSOL_ON_SS: return "UNSOL_ON_SS";
+ case RIL_UNSOL_STK_CC_ALPHA_NOTIFY: return "UNSOL_STK_CC_ALPHA_NOTIFY";
+ case RIL_UNSOL_LCEDATA_RECV: return "UNSOL_LCE_INFO_RECV";
default: return "<unknown response>";
}
}
private void riljLog(String msg) {
- Rlog.d(RILJ_LOG_TAG, msg);
+ Rlog.d(RILJ_LOG_TAG, msg
+ + (mInstanceId != null ? (" [SUB" + mInstanceId + "]") : ""));
}
private void riljLogv(String msg) {
- Rlog.v(RILJ_LOG_TAG, msg);
+ Rlog.v(RILJ_LOG_TAG, msg
+ + (mInstanceId != null ? (" [SUB" + mInstanceId + "]") : ""));
}
private void unsljLog(int response) {
riljLogv("[UNSL]< " + responseToString(response) + " " + retToString(response, ret));
}
+ private Object
+ responseSsData(Parcel p) {
+ int num;
+ SsData ssData = new SsData();
+
+ ssData.serviceType = ssData.ServiceTypeFromRILInt(p.readInt());
+ ssData.requestType = ssData.RequestTypeFromRILInt(p.readInt());
+ ssData.teleserviceType = ssData.TeleserviceTypeFromRILInt(p.readInt());
+ ssData.serviceClass = p.readInt(); // This is service class sent in the SS request.
+ ssData.result = p.readInt(); // This is the result of the SS request.
+ num = p.readInt();
+
+ if (ssData.serviceType.isTypeCF() &&
+ ssData.requestType.isTypeInterrogation()) {
+ ssData.cfInfo = new CallForwardInfo[num];
+
+ for (int i = 0; i < num; i++) {
+ ssData.cfInfo[i] = new CallForwardInfo();
+
+ ssData.cfInfo[i].status = p.readInt();
+ ssData.cfInfo[i].reason = p.readInt();
+ ssData.cfInfo[i].serviceClass = p.readInt();
+ ssData.cfInfo[i].toa = p.readInt();
+ ssData.cfInfo[i].number = p.readString();
+ ssData.cfInfo[i].timeSeconds = p.readInt();
+
+ riljLog("[SS Data] CF Info " + i + " : " + ssData.cfInfo[i]);
+ }
+ } else {
+ ssData.ssInfo = new int[num];
+ for (int i = 0; i < num; i++) {
+ ssData.ssInfo[i] = p.readInt();
+ riljLog("[SS Data] SS Info " + i + " : " + ssData.ssInfo[i]);
+ }
+ }
+
+ return ssData;
+ }
+
// ***** Methods for CDMA support
@Override
send(rr);
}
+ @Override
+ public void requestIccSimAuthentication(int authContext, String data, String aid,
+ Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIM_AUTHENTICATION, response);
+
+ rr.mParcel.writeInt(authContext);
+ rr.mParcel.writeString(data);
+ rr.mParcel.writeString(aid);
+
+ if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+
+ send(rr);
+ }
+
/**
* {@inheritDoc}
*/
send(rr);
}
+ public void setDataProfile(DataProfile[] dps, Message result) {
+ if (RILJ_LOGD) riljLog("Set RIL_REQUEST_SET_DATA_PROFILE");
+
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_DATA_PROFILE, null);
+ DataProfile.toParcel(rr.mParcel, dps);
+
+ if (RILJ_LOGD) {
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
+ + " with " + dps + " Data Profiles : ");
+ for (int i = 0; i < dps.length; i++) {
+ riljLog(dps[i].toString());
+ }
+ }
+
+ send(rr);
+ }
+
/* (non-Javadoc)
* @see com.android.internal.telephony.BaseCommands#testingEmergencyCall()
*/
pw.println(" mLastNITZTimeInfo=" + mLastNITZTimeInfo);
pw.println(" mTestingEmergencyCall=" + mTestingEmergencyCall.get());
}
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void iccOpenLogicalChannel(String AID, Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIM_OPEN_CHANNEL, response);
+ rr.mParcel.writeString(AID);
+
+ if (RILJ_LOGD)
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+
+ send(rr);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void iccCloseLogicalChannel(int channel, Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIM_CLOSE_CHANNEL, response);
+ rr.mParcel.writeInt(1);
+ rr.mParcel.writeInt(channel);
+
+ if (RILJ_LOGD)
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+
+ send(rr);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void iccTransmitApduLogicalChannel(int channel, int cla, int instruction,
+ int p1, int p2, int p3, String data, Message response) {
+ if (channel <= 0) {
+ throw new RuntimeException(
+ "Invalid channel in iccTransmitApduLogicalChannel: " + channel);
+ }
+
+ iccTransmitApduHelper(RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL, channel, cla,
+ instruction, p1, p2, p3, data, response);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void iccTransmitApduBasicChannel(int cla, int instruction, int p1, int p2,
+ int p3, String data, Message response) {
+ iccTransmitApduHelper(RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC, 0, cla, instruction,
+ p1, p2, p3, data, response);
+ }
+
+ /*
+ * Helper function for the iccTransmitApdu* commands above.
+ */
+ private void iccTransmitApduHelper(int rilCommand, int channel, int cla,
+ int instruction, int p1, int p2, int p3, String data, Message response) {
+ RILRequest rr = RILRequest.obtain(rilCommand, response);
+ rr.mParcel.writeInt(channel);
+ rr.mParcel.writeInt(cla);
+ rr.mParcel.writeInt(instruction);
+ rr.mParcel.writeInt(p1);
+ rr.mParcel.writeInt(p2);
+ rr.mParcel.writeInt(p3);
+ rr.mParcel.writeString(data);
+
+ if (RILJ_LOGD)
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+
+ send(rr);
+ }
+
+ @Override
+ public void nvReadItem(int itemID, Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_NV_READ_ITEM, response);
+
+ rr.mParcel.writeInt(itemID);
+
+ if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
+ + ' ' + itemID);
+
+ send(rr);
+ }
+
+ @Override
+ public void nvWriteItem(int itemID, String itemValue, Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_NV_WRITE_ITEM, response);
+
+ rr.mParcel.writeInt(itemID);
+ rr.mParcel.writeString(itemValue);
+
+ if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
+ + ' ' + itemID + ": " + itemValue);
+
+ send(rr);
+ }
+
+ @Override
+ public void nvWriteCdmaPrl(byte[] preferredRoamingList, Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_NV_WRITE_CDMA_PRL, response);
+
+ rr.mParcel.writeByteArray(preferredRoamingList);
+
+ if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
+ + " (" + preferredRoamingList.length + " bytes)");
+
+ send(rr);
+ }
+
+ @Override
+ public void nvResetConfig(int resetType, Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_NV_RESET_CONFIG, response);
+
+ rr.mParcel.writeInt(1);
+ rr.mParcel.writeInt(resetType);
+
+ if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
+ + ' ' + resetType);
+
+ send(rr);
+ }
+
+ @Override
+ public void setRadioCapability(RadioCapability rc, Message response) {
+ RILRequest rr = RILRequest.obtain(
+ RIL_REQUEST_SET_RADIO_CAPABILITY, response);
+
+ rr.mParcel.writeInt(rc.getVersion());
+ rr.mParcel.writeInt(rc.getSession());
+ rr.mParcel.writeInt(rc.getPhase());
+ rr.mParcel.writeInt(rc.getRadioAccessFamily());
+ rr.mParcel.writeString(rc.getLogicalModemUuid());
+ rr.mParcel.writeInt(rc.getStatus());
+
+ if (RILJ_LOGD) {
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)
+ + " " + rc.toString());
+ }
+
+ send(rr);
+ }
+
+ @Override
+ public void getRadioCapability(Message response) {
+ RILRequest rr = RILRequest.obtain(
+ RIL_REQUEST_GET_RADIO_CAPABILITY, response);
+
+ if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+
+ send(rr);
+ }
+
+ @Override
+ public void startLceService(int reportIntervalMs, boolean pullMode, Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_START_LCE, response);
+ /** solicited command argument: reportIntervalMs, pullMode. */
+ rr.mParcel.writeInt(2);
+ rr.mParcel.writeInt(reportIntervalMs);
+ rr.mParcel.writeInt(pullMode ? 1: 0); // PULL mode: 1; PUSH mode: 0;
+
+ if (RILJ_LOGD) {
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+ }
+
+ send(rr);
+ }
+
+ @Override
+ public void stopLceService(Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_STOP_LCE, response);
+ if (RILJ_LOGD) {
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+ }
+ send(rr);
+ }
+
+ @Override
+ public void pullLceData(Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_PULL_LCEDATA, response);
+ if (RILJ_LOGD) {
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+ }
+ send(rr);
+ }
+
+ /**
+ * @hide
+ */
+ public void getModemActivityInfo(Message response) {
+ RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_ACTIVITY_INFO, response);
+ if (RILJ_LOGD) {
+ riljLog(rr.serialString() + "> " + requestToString(rr.mRequest));
+ }
+ send(rr);
+ }
}
Code Review / android / platform / frameworks / opt / telephony.git / blobdiff