Merge "telephony: reconcile Sony RIL with QualcommShared" into jellybean (c4a132ee) · Commits · e / os / android_frameworks_base

telephony/java/com/android/internal/telephony/SonyQualcommRIL.java

+12 −326

Original line number	Diff line number	Diff line
		@@ -19,91 +19,28 @@ package com.android.internal.telephony;
		import static com.android.internal.telephony.RILConstants.*;

		import android.content.Context;
		import android.content.res.Resources;
		import android.os.AsyncResult;
		import android.os.Handler;
		import android.os.HandlerThread;
		import android.os.Looper;
		import android.os.Message;
		import android.os.Parcel;
		import android.os.SystemProperties;
		import android.telephony.SmsMessage;
		import android.text.TextUtils;
		import android.util.Log;

		import java.util.ArrayList;

		/**
		/*
		* Qualcomm RIL class for basebands that do not send the SIM status
		* piggybacked in RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED. Instead,
		* these radios will send radio state and we have to query for SIM
		* status separately.
		* Custom Qualcomm No SimReady RIL for Sony
		*
		* {@hide}
		*/

		public class SonyQualcommRIL extends RIL implements CommandsInterface {
		protected String mAid = "";
		protected HandlerThread mIccThread;
		protected IccHandler mIccHandler;
		public class SonyQualcommRIL extends QualcommSharedRIL implements CommandsInterface {
		boolean RILJ_LOGV = true;
		boolean RILJ_LOGD = true;

		private final int RIL_INT_RADIO_OFF = 0;
		private final int RIL_INT_RADIO_UNAVALIABLE = 1;
		private final int RIL_INT_RADIO_ON = 10;

		public SonyQualcommRIL(Context context, int networkMode, int cdmaSubscription) {
		super(context, networkMode, cdmaSubscription);
		mQANElements = 5;
		}

		@Override
		public void
		iccIO (int command, int fileid, String path, int p1, int p2, int p3,
		String data, String pin2, Message result) {
		iccIOForApp(command, fileid, path, p1, p2, p3, data, pin2, mAid, result);
		}

		@Override public void
		supplyIccPin(String pin, Message result) {
		supplyIccPinForApp(pin, mAid, result);
		}

		@Override public void
		changeIccPin(String oldPin, String newPin, Message result) {
		changeIccPinForApp(oldPin, newPin, mAid, result);
		}

		@Override public void
		supplyIccPin2(String pin, Message result) {
		supplyIccPin2ForApp(pin, mAid, result);
		}

		@Override public void
		changeIccPin2(String oldPin2, String newPin2, Message result) {
		changeIccPin2ForApp(oldPin2, newPin2, mAid, result);
		}

		@Override public void
		supplyIccPuk(String puk, String newPin, Message result) {
		supplyIccPukForApp(puk, newPin, mAid, result);
		}

		@Override public void
		supplyIccPuk2(String puk2, String newPin2, Message result) {
		supplyIccPuk2ForApp(puk2, newPin2, mAid, result);
		}

		@Override
		public void
		queryFacilityLock(String facility, String password, int serviceClass,
		Message response) {
		queryFacilityLockForApp(facility, password, serviceClass, mAid, response);
		}

		@Override
		public void
		setFacilityLock (String facility, boolean lockState, String password,
		int serviceClass, Message response) {
		setFacilityLockForApp(facility, lockState, password, serviceClass, mAid, response);
		}

		@Override
		@@ -151,17 +88,16 @@ public class SonyQualcommRIL extends RIL implements CommandsInterface {
		appType = status.getGsmUmtsSubscriptionAppIndex();

		IccCardApplication application = status.getApplication(appType);
		mUSIM = application.app_type
		== IccCardApplication.AppType.APPTYPE_USIM;
		mSetPreferredNetworkType = mPreferredNetworkType;
		mAid = application.aid;
		if (TextUtils.isEmpty(mAid))
		mAid = "";
		Log.d(LOG_TAG, "Picked default AID: " + mAid);
		}
		}

		@Override
		public void
		getIMSI(Message result) {
		getIMSIForApp(mAid, result);
		}

		@Override
		public void
		dial(String address, int clirMode, UUSInfo uusInfo, Message result) {
		@@ -212,254 +148,4 @@ public class SonyQualcommRIL extends RIL implements CommandsInterface {
		setNetworkSelectionMode(operatorNumeric, response);
		}

		@Override
		protected void
		switchToRadioState(RadioState newState) {
		if (newState.isOn() && !getRadioState().isOn())
		getVoiceRadioTechnology(null);
		setRadioState(newState);
		}


		@Override
		protected Object
		responseSignalStrength(Parcel p) {
		int numInts = 12;
		int response[];

		boolean noLte = false;

		/* TODO: Add SignalStrength class to match RIL_SignalStrength */
		response = new int[numInts];
		for (int i = 0 ; i < numInts ; i++) {
		if (noLte && i > 6 && i < 12) {
		response[i] = -1;
		} else {
		response[i] = p.readInt();
		}
		if (i == 7 && response[i] == 99) {
		response[i] = -1;
		noLte = true;
		}
		if (i == 8 && !noLte) {
		response[i] *= -1;
		}
		}

		return response;
		}

		@Override
		protected DataCallState getDataCallState(Parcel p, int version) {
		DataCallState dataCall = new DataCallState();

		dataCall.version = version;
		if (version < 5) {
		dataCall.cid = p.readInt();
		dataCall.active = p.readInt();
		dataCall.type = p.readString();
		if (version < 4) {
		p.readString(); // APN - not used
		}
		String addresses = p.readString();
		if (!TextUtils.isEmpty(addresses)) {
		dataCall.addresses = addresses.split(" ");
		}
		// DataCallState needs an ifname. Since we don't have one use the name from the ThrottleService resource (default=rmnet0).
		dataCall.ifname = Resources.getSystem().getString(com.android.internal.R.string.config_datause_iface);
		} else {
		dataCall.status = p.readInt();
		dataCall.suggestedRetryTime = p.readInt();
		dataCall.cid = p.readInt();
		dataCall.active = p.readInt();
		dataCall.type = p.readString();
		dataCall.ifname = p.readString();
		if ((dataCall.status == DataConnection.FailCause.NONE.getErrorCode()) &&
		TextUtils.isEmpty(dataCall.ifname) && dataCall.active != 0) {
		throw new RuntimeException("getDataCallState, no ifname");
		}
		String addresses = p.readString();
		if (!TextUtils.isEmpty(addresses)) {
		dataCall.addresses = addresses.split(" ");
		}
		String dnses = p.readString();
		if (!TextUtils.isEmpty(dnses)) {
		dataCall.dnses = dnses.split(" ");
		}
		String gateways = p.readString();
		if (!TextUtils.isEmpty(gateways)) {
		dataCall.gateways = gateways.split(" ");
		}
		}
		return dataCall;
		}

		@Override
		protected void
		processUnsolicited (Parcel p) {
		Object ret;
		int dataPosition = p.dataPosition(); // save off position within the Parcel
		int response = p.readInt();

		switch(response) {
		case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: ret = responseVoid(p); break;
		case 1038: ret = responseVoid(p); break; // RIL_UNSOL_DATA_NETWORK_STATE_CHANGED

		default:
		// Rewind the Parcel
		p.setDataPosition(dataPosition);

		// Forward responses that we are not overriding to the super class
		super.processUnsolicited(p);
		return;
		}

		switch(response) {
		case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED:
		int state = p.readInt();
		setRadioStateFromRILInt(state);
		break;
		case 1038:
		break;
		}
		}

		private void setRadioStateFromRILInt (int stateCode) {
		CommandsInterface.RadioState radioState;
		HandlerThread handlerThread;
		Looper looper;
		IccHandler iccHandler;

		switch (stateCode) {
		case RIL_INT_RADIO_OFF:
		radioState = CommandsInterface.RadioState.RADIO_OFF;
		if (mIccHandler != null) {
		mIccThread = null;
		mIccHandler = null;
		}
		break;
		case RIL_INT_RADIO_UNAVALIABLE:
		radioState = CommandsInterface.RadioState.RADIO_UNAVAILABLE;
		break;
		case RIL_INT_RADIO_ON:
		if (mIccHandler == null) {
		handlerThread = new HandlerThread("IccHandler");
		mIccThread = handlerThread;

		mIccThread.start();

		looper = mIccThread.getLooper();
		mIccHandler = new IccHandler(this,looper);
		mIccHandler.run();
		}
		radioState = CommandsInterface.RadioState.RADIO_ON;
		break;
		default:
		throw new RuntimeException("Unrecognized RIL_RadioState: " + stateCode);
		}

		switchToRadioState(radioState);
		}

		class IccHandler extends Handler implements Runnable {
		private static final int EVENT_GET_ICC_STATUS_DONE = 1;
		private static final int EVENT_ICC_STATUS_CHANGED = 2;
		private static final int EVENT_RADIO_ON = 3;
		private static final int EVENT_RADIO_OFF_OR_UNAVAILABLE = 4;

		private RIL mRil;
		private boolean mRadioOn = false;

		public IccHandler (RIL ril, Looper looper) {
		super (looper);
		mRil = ril;
		}

		public void handleMessage (Message paramMessage) {
		switch (paramMessage.what) {
		case EVENT_RADIO_ON:
		mRadioOn = true;
		Log.d(LOG_TAG, "Radio on -> Forcing sim status update");
		sendMessage(obtainMessage(EVENT_ICC_STATUS_CHANGED));
		break;
		case EVENT_GET_ICC_STATUS_DONE:
		AsyncResult asyncResult = (AsyncResult) paramMessage.obj;
		if (asyncResult.exception != null) {
		Log.e (LOG_TAG, "IccCardStatusDone shouldn't return exceptions!", asyncResult.exception);
		break;
		}
		IccCardStatus status = (IccCardStatus) asyncResult.result;
		if (status.getNumApplications() == 0) {
		if (!mRil.getRadioState().isOn()) {
		break;
		}

		mRil.setRadioState(CommandsInterface.RadioState.RADIO_ON);
		} else {
		int appIndex = -1;
		if (mPhoneType == RILConstants.CDMA_PHONE) {
		appIndex = status.getCdmaSubscriptionAppIndex();
		Log.d(LOG_TAG, "This is a CDMA PHONE " + appIndex);
		} else {
		appIndex = status.getGsmUmtsSubscriptionAppIndex();
		Log.d(LOG_TAG, "This is a GSM PHONE " + appIndex);
		}

		IccCardApplication application = status.getApplication(appIndex);
		IccCardApplication.AppState app_state = application.app_state;
		IccCardApplication.AppType app_type = application.app_type;
		switch (app_state) {
		case APPSTATE_PIN:
		case APPSTATE_PUK:
		switch (app_type) {
		case APPTYPE_SIM:
		case APPTYPE_USIM:
		case APPTYPE_RUIM:
		mRil.setRadioState(CommandsInterface.RadioState.RADIO_ON);
		break;
		default:
		Log.e(LOG_TAG, "Currently we don't handle SIMs of type: " + app_type);
		return;
		}
		break;
		case APPSTATE_READY:
		switch (app_type) {
		case APPTYPE_SIM:
		case APPTYPE_USIM:
		case APPTYPE_RUIM:
		mRil.setRadioState(CommandsInterface.RadioState.RADIO_ON);
		break;
		default:
		Log.e(LOG_TAG, "Currently we don't handle SIMs of type: " + app_type);
		return;
		}
		break;
		default:
		return;
		}
		}
		break;
		case EVENT_ICC_STATUS_CHANGED:
		if (mRadioOn) {
		Log.d(LOG_TAG, "Received EVENT_ICC_STATUS_CHANGED, calling getIccCardStatus");
		mRil.getIccCardStatus(obtainMessage(EVENT_GET_ICC_STATUS_DONE, paramMessage.obj));
		} else {
		Log.d(LOG_TAG, "Received EVENT_ICC_STATUS_CHANGED while radio is not ON. Ignoring");
		}
		break;
		case EVENT_RADIO_OFF_OR_UNAVAILABLE:
		mRadioOn = false;
		// disposeCards(); // to be verified;
		default:
		Log.e(LOG_TAG, " Unknown Event " + paramMessage.what);
		break;
		}
		}

		public void run () {
		mRil.registerForIccStatusChanged(this, EVENT_ICC_STATUS_CHANGED, null);
		Message msg = obtainMessage(EVENT_RADIO_ON);
		mRil.getIccCardStatus(msg);
		}
		}
		}