diff options
author | Wink Saville <> | 2009-04-02 01:37:02 -0700 |
---|---|---|
committer | The Android Open Source Project <initial-contribution@android.com> | 2009-04-02 01:37:02 -0700 |
commit | 767a662ecde33c3979bf02b793d392aca0403162 (patch) | |
tree | f55548c33a8267c39acc60f72051f9856e95e672 /telephony | |
parent | e9c08056fafab720856ab8516ea0e623a5c0e360 (diff) | |
download | frameworks_base-767a662ecde33c3979bf02b793d392aca0403162.zip frameworks_base-767a662ecde33c3979bf02b793d392aca0403162.tar.gz frameworks_base-767a662ecde33c3979bf02b793d392aca0403162.tar.bz2 |
AI 144185: Integrate cdma into the main code base.
Automated import of CL 144185
Diffstat (limited to 'telephony')
141 files changed, 23904 insertions, 7871 deletions
diff --git a/telephony/java/android/telephony/CellLocation.java b/telephony/java/android/telephony/CellLocation.java index 464085f..dd98608 100644 --- a/telephony/java/android/telephony/CellLocation.java +++ b/telephony/java/android/telephony/CellLocation.java @@ -19,8 +19,14 @@ package android.telephony; import android.os.Bundle; import android.os.RemoteException; import android.os.ServiceManager; +import android.os.SystemProperties; +import android.provider.Settings; + + +import android.telephony.cdma.CdmaCellLocation; import android.telephony.gsm.GsmCellLocation; import com.android.internal.telephony.ITelephony; +import com.android.internal.telephony.RILConstants; /** * Abstract class that represents the location of the device. Currently the only @@ -56,7 +62,17 @@ public abstract class CellLocation { * @hide */ public static CellLocation newFromBundle(Bundle bundle) { - return new GsmCellLocation(bundle); + // TODO: My need to be use: Settings.Secure.getInt(mContext, Settings.Secure.CURRENT_ACTIVE_PHONE, 0)) + // instead of SystemProperties??? + + // NOTE here TelephonyManager.getDefault().getPhoneType() cannot be used since at startup + // ITelephony have not been created + if (RILConstants.CDMA_PHONE == + SystemProperties.getInt(Settings.Secure.CURRENT_ACTIVE_PHONE, 0)) { + return new CdmaCellLocation(bundle); + } else { + return new GsmCellLocation(bundle); + } } /** @@ -66,8 +82,20 @@ public abstract class CellLocation { /** * Return a new CellLocation object representing an unknown location. + * */ public static CellLocation getEmpty() { - return new GsmCellLocation(); + // TODO: My need to be use: Settings.Secure.getInt(mContext, Settings.Secure.CURRENT_ACTIVE_PHONE, 0)) + // instead of SystemProperties??? + + // NOTE here TelephonyManager.getDefault().getPhoneType() cannot be used since at startup + // ITelephony have not been created + if (RILConstants.CDMA_PHONE == + SystemProperties.getInt(Settings.Secure.CURRENT_ACTIVE_PHONE, 0)) { + return new CdmaCellLocation(); + } else { + return new GsmCellLocation(); + } } + } diff --git a/telephony/java/android/telephony/PhoneNumberFormattingTextWatcher.java b/telephony/java/android/telephony/PhoneNumberFormattingTextWatcher.java index 0bc6c04..8a47339 100644 --- a/telephony/java/android/telephony/PhoneNumberFormattingTextWatcher.java +++ b/telephony/java/android/telephony/PhoneNumberFormattingTextWatcher.java @@ -25,7 +25,7 @@ import java.util.Locale; /** * Watches a {@link TextView} and if a phone number is entered will format it using - * {@link PhoneNumberUtils#formatNumber(Editable, int)}. The formatting is based on + * {@link PhoneNumberUtils#formatNumber(Editable, int)}. The formatting is based on * the current system locale when this object is created and future locale changes * may not take effect on this instance. */ @@ -35,7 +35,7 @@ public class PhoneNumberFormattingTextWatcher implements TextWatcher { static private Locale sCachedLocale; private boolean mFormatting; private boolean mDeletingHyphen; - private int mHyphenStart; + private int mHyphenStart; private boolean mDeletingBackward; public PhoneNumberFormattingTextWatcher() { @@ -60,7 +60,7 @@ public class PhoneNumberFormattingTextWatcher implements TextWatcher { text.delete(mHyphenStart, mHyphenStart + 1); } } - + PhoneNumberUtils.formatNumber(text, sFormatType); mFormatting = false; @@ -73,8 +73,8 @@ public class PhoneNumberFormattingTextWatcher implements TextWatcher { // Make sure user is deleting one char, without a selection final int selStart = Selection.getSelectionStart(s); final int selEnd = Selection.getSelectionEnd(s); - if (s.length() > 1 // Can delete another character - && count == 1 // Deleting only one character + if (s.length() > 1 // Can delete another character + && count == 1 // Deleting only one character && after == 0 // Deleting && s.charAt(start) == '-' // a hyphen && selStart == selEnd) { // no selection @@ -89,7 +89,7 @@ public class PhoneNumberFormattingTextWatcher implements TextWatcher { } else { mDeletingHyphen = false; } - } + } } public void onTextChanged(CharSequence s, int start, int before, int count) { diff --git a/telephony/java/android/telephony/PhoneStateListener.java b/telephony/java/android/telephony/PhoneStateListener.java index 8a8a675..df6860b 100644 --- a/telephony/java/android/telephony/PhoneStateListener.java +++ b/telephony/java/android/telephony/PhoneStateListener.java @@ -11,18 +11,18 @@ import com.android.internal.telephony.IPhoneStateListener; /** * A listener class for monitoring changes in specific telephony states - * on the device, including service state, signal strength, message + * on the device, including service state, signal strength, message * waiting indicator (voicemail), and others. * <p> - * Override the methods for the state that you wish to receive updates for, and + * Override the methods for the state that you wish to receive updates for, and * pass your PhoneStateListener object, along with bitwise-or of the LISTEN_ * flags to {@link TelephonyManager#listen TelephonyManager.listen()}. * <p> * Note that access to some telephony information is - * permission-protected. Your application won't receive updates for protected - * information unless it has the appropriate permissions declared in + * permission-protected. Your application won't receive updates for protected + * information unless it has the appropriate permissions declared in * its manifest file. Where permissions apply, they are noted in the - * appropriate LISTEN_ flags. + * appropriate LISTEN_ flags. */ public class PhoneStateListener { @@ -67,17 +67,17 @@ public class PhoneStateListener { public static final int LISTEN_CALL_FORWARDING_INDICATOR = 0x00000008; /** - * Listen for changes to the device's cell location. Note that + * Listen for changes to the device's cell location. Note that * this will result in frequent callbacks to the listener. * {@more} * Requires Permission: {@link android.Manifest.permission#ACCESS_COARSE_LOCATION * ACCESS_COARSE_LOCATION} * <p> - * If you need regular location updates but want more control over - * the update interval or location precision, you can set up a listener - * through the {@link android.location.LocationManager location manager} - * instead. - * + * If you need regular location updates but want more control over + * the update interval or location precision, you can set up a listener + * through the {@link android.location.LocationManager location manager} + * instead. + * * @see #onCellLocationChanged */ public static final int LISTEN_CELL_LOCATION = 0x00000010; @@ -100,7 +100,7 @@ public class PhoneStateListener { * Listen for changes to the direction of data traffic on the data * connection (cellular). * - * Example: The status bar uses this to display the appropriate + * Example: The status bar uses this to display the appropriate * data-traffic icon. * * @see #onDataActivity @@ -111,7 +111,7 @@ public class PhoneStateListener { } /** - * Callback invoked when device service state changes. + * Callback invoked when device service state changes. * * @see ServiceState#STATE_EMERGENCY_ONLY * @see ServiceState#STATE_IN_SERVICE @@ -135,28 +135,28 @@ public class PhoneStateListener { } /** - * Callback invoked when the message-waiting indicator changes. + * Callback invoked when the message-waiting indicator changes. */ public void onMessageWaitingIndicatorChanged(boolean mwi) { // default implementation empty } /** - * Callback invoked when the call-forwarding indicator changes. + * Callback invoked when the call-forwarding indicator changes. */ public void onCallForwardingIndicatorChanged(boolean cfi) { // default implementation empty } /** - * Callback invoked when device cell location changes. + * Callback invoked when device cell location changes. */ public void onCellLocationChanged(CellLocation location) { // default implementation empty } /** - * Callback invoked when device call state changes. + * Callback invoked when device call state changes. * * @see TelephonyManager#CALL_STATE_IDLE * @see TelephonyManager#CALL_STATE_RINGING @@ -167,7 +167,7 @@ public class PhoneStateListener { } /** - * Callback invoked when connection state changes. + * Callback invoked when connection state changes. * * @see TelephonyManager#DATA_DISCONNECTED * @see TelephonyManager#DATA_CONNECTING @@ -179,7 +179,7 @@ public class PhoneStateListener { } /** - * Callback invoked when data activity state changes. + * Callback invoked when data activity state changes. * * @see TelephonyManager#DATA_ACTIVITY_NONE * @see TelephonyManager#DATA_ACTIVITY_IN diff --git a/telephony/java/android/telephony/ServiceState.aidl b/telephony/java/android/telephony/ServiceState.aidl index b1cf379..8522889 100644 --- a/telephony/java/android/telephony/ServiceState.aidl +++ b/telephony/java/android/telephony/ServiceState.aidl @@ -2,16 +2,16 @@ ** ** Copyright 2007, The Android Open Source Project ** -** Licensed under the Apache License, Version 2.0 (the "License"); -** you may not use this file except in compliance with the License. -** You may obtain a copy of the License at +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at ** -** http://www.apache.org/licenses/LICENSE-2.0 +** http://www.apache.org/licenses/LICENSE-2.0 ** -** Unless required by applicable law or agreed to in writing, software -** distributed under the License is distributed on an "AS IS" BASIS, -** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -** See the License for the specific language governing permissions and +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and ** limitations under the License. */ diff --git a/telephony/java/android/telephony/ServiceState.java b/telephony/java/android/telephony/ServiceState.java index 2c58051..4de0954 100644 --- a/telephony/java/android/telephony/ServiceState.java +++ b/telephony/java/android/telephony/ServiceState.java @@ -19,7 +19,7 @@ package android.telephony; import android.os.Bundle; import android.os.Parcel; import android.os.Parcelable; -import com.android.internal.telephony.Phone; +import android.util.Log; /** * Contains phone state and service related information. @@ -35,6 +35,8 @@ import com.android.internal.telephony.Phone; */ public class ServiceState implements Parcelable { + static final String LOG_TAG = "PHONE"; + /** * Normal operation condition, the phone is registered * with an operator either in home network or in roaming. @@ -59,13 +61,61 @@ public class ServiceState implements Parcelable { */ public static final int STATE_POWER_OFF = 3; + + /** + * Available radio technologies for GSM, UMTS and CDMA. + */ + /** @hide */ + public static final int RADIO_TECHNOLOGY_UNKNOWN = 0; + /** @hide */ + public static final int RADIO_TECHNOLOGY_GPRS = 1; + /** @hide */ + public static final int RADIO_TECHNOLOGY_EDGE = 2; + /** @hide */ + public static final int RADIO_TECHNOLOGY_UMTS = 3; + /** @hide */ + public static final int RADIO_TECHNOLOGY_IS95A = 4; + /** @hide */ + public static final int RADIO_TECHNOLOGY_IS95B = 5; + /** @hide */ + public static final int RADIO_TECHNOLOGY_1xRTT = 6; + /** @hide */ + public static final int RADIO_TECHNOLOGY_EVDO_0 = 7; + /** @hide */ + public static final int RADIO_TECHNOLOGY_EVDO_A = 8; + + /** + * Available registration states for GSM, UMTS and CDMA. + */ + /** @hide */ + public static final int REGISTRATION_STATE_NOT_REGISTERED_AND_NOT_SEARCHING = 0; + /** @hide */ + public static final int REGISTRATION_STATE_HOME_NETWORK = 1; + /** @hide */ + public static final int REGISTRATION_STATE_NOT_REGISTERED_AND_SEARCHING = 2; + /** @hide */ + public static final int REGISTRATION_STATE_REGISTRATION_DENIED = 3; + /** @hide */ + public static final int REGISTRATION_STATE_UNKNOWN = 4; + /** @hide */ + public static final int REGISTRATION_STATE_ROAMING = 5; + /** @hide */ + public static final int REGISTRATION_STATE_ROAMING_AFFILIATE = 6; + private int mState = STATE_OUT_OF_SERVICE; private boolean mRoaming; + private int mExtendedCdmaRoaming; private String mOperatorAlphaLong; private String mOperatorAlphaShort; private String mOperatorNumeric; private boolean mIsManualNetworkSelection; + //***** CDMA + private int mRadioTechnology; + private boolean mCssIndicator; + private int mNetworkId; + private int mSystemId; + /** * Create a new ServiceState from a intent notifier Bundle * @@ -105,6 +155,11 @@ public class ServiceState implements Parcelable { mOperatorAlphaShort = s.mOperatorAlphaShort; mOperatorNumeric = s.mOperatorNumeric; mIsManualNetworkSelection = s.mIsManualNetworkSelection; + mRadioTechnology = s.mRadioTechnology; + mCssIndicator = s.mCssIndicator; + mNetworkId = s.mNetworkId; + mSystemId = s.mSystemId; + mExtendedCdmaRoaming = s.mExtendedCdmaRoaming; } /** @@ -117,6 +172,11 @@ public class ServiceState implements Parcelable { mOperatorAlphaShort = in.readString(); mOperatorNumeric = in.readString(); mIsManualNetworkSelection = in.readInt() != 0; + mRadioTechnology = in.readInt(); + mCssIndicator = (in.readInt() != 0); + mNetworkId = in.readInt(); + mSystemId = in.readInt(); + mExtendedCdmaRoaming = in.readInt(); } public void writeToParcel(Parcel out, int flags) { @@ -126,6 +186,11 @@ public class ServiceState implements Parcelable { out.writeString(mOperatorAlphaShort); out.writeString(mOperatorNumeric); out.writeInt(mIsManualNetworkSelection ? 1 : 0); + out.writeInt(mRadioTechnology); + out.writeInt(mCssIndicator ? 1 : 0); + out.writeInt(mNetworkId); + out.writeInt(mSystemId); + out.writeInt(mExtendedCdmaRoaming); } public int describeContents() { @@ -166,6 +231,11 @@ public class ServiceState implements Parcelable { return mRoaming; } + /** @hide */ + public int getExtendedCdmaRoaming(){ + return this.mExtendedCdmaRoaming; + } + /** * Get current registered operator name in long alphanumeric format * @@ -213,18 +283,19 @@ public class ServiceState implements Parcelable { @Override public int hashCode() { - return (mState * 0x1234) + return ((mState * 0x1234) + (mRoaming ? 1 : 0) + (mIsManualNetworkSelection ? 1 : 0) + ((null == mOperatorAlphaLong) ? 0 : mOperatorAlphaLong.hashCode()) + ((null == mOperatorAlphaShort) ? 0 : mOperatorAlphaShort.hashCode()) - + ((null == mOperatorNumeric) ? 0 : mOperatorNumeric.hashCode()); + + ((null == mOperatorNumeric) ? 0 : mOperatorNumeric.hashCode()) + + (mExtendedCdmaRoaming)); } @Override public boolean equals (Object o) { ServiceState s; - + try { s = (ServiceState) o; } catch (ClassCastException ex) { @@ -235,21 +306,66 @@ public class ServiceState implements Parcelable { return false; } - return mState == s.mState + return (mState == s.mState && mRoaming == s.mRoaming && mIsManualNetworkSelection == s.mIsManualNetworkSelection && equalsHandlesNulls(mOperatorAlphaLong, s.mOperatorAlphaLong) && equalsHandlesNulls(mOperatorAlphaShort, s.mOperatorAlphaShort) - && equalsHandlesNulls(mOperatorNumeric, s.mOperatorNumeric); + && equalsHandlesNulls(mOperatorNumeric, s.mOperatorNumeric) + && equalsHandlesNulls(mRadioTechnology, s.mRadioTechnology) + && equalsHandlesNulls(mCssIndicator, s.mCssIndicator) + && equalsHandlesNulls(mNetworkId, s.mNetworkId) + && equalsHandlesNulls(mSystemId, s.mSystemId) + && equalsHandlesNulls(mExtendedCdmaRoaming, s.mExtendedCdmaRoaming)); } @Override public String toString() { - return mState + " " + (mRoaming ? "roaming" : "home") + String radioTechnology = new String("Error in radioTechnology"); + + switch(this.mRadioTechnology) { + case 0: + radioTechnology = "Unknown"; + break; + case 1: + radioTechnology = "GPRS"; + break; + case 2: + radioTechnology = "EDGE"; + break; + case 3: + radioTechnology = "UMTS"; + break; + case 4: + radioTechnology = "IS95A"; + break; + case 5: + radioTechnology = "IS95B"; + break; + case 6: + radioTechnology = "1xRTT"; + break; + case 7: + radioTechnology = "EvDo rev. 0"; + break; + case 8: + radioTechnology = "EvDo rev. A"; + break; + default: + Log.w(LOG_TAG, "mRadioTechnology variable out of range."); + break; + } + + return (mState + " " + (mRoaming ? "roaming" : "home") + " " + mOperatorAlphaLong + " " + mOperatorAlphaShort + " " + mOperatorNumeric - + " " + (mIsManualNetworkSelection ? "(manual)" : ""); + + " " + (mIsManualNetworkSelection ? "(manual)" : "") + + " " + radioTechnology + + " " + (mCssIndicator ? "CSS supported" : "CSS not supported") + + "NetworkId: " + mNetworkId + + "SystemId: " + mSystemId + + "ExtendedCdmaRoaming: " + mExtendedCdmaRoaming); } public void setStateOutOfService() { @@ -259,6 +375,11 @@ public class ServiceState implements Parcelable { mOperatorAlphaShort = null; mOperatorNumeric = null; mIsManualNetworkSelection = false; + mRadioTechnology = 0; + mCssIndicator = false; + mNetworkId = -1; + mSystemId = -1; + mExtendedCdmaRoaming = -1; } public void setStateOff() { @@ -268,6 +389,11 @@ public class ServiceState implements Parcelable { mOperatorAlphaShort = null; mOperatorNumeric = null; mIsManualNetworkSelection = false; + mRadioTechnology = 0; + mCssIndicator = false; + mNetworkId = -1; + mSystemId = -1; + mExtendedCdmaRoaming = -1; } public void setState(int state) { @@ -278,6 +404,11 @@ public class ServiceState implements Parcelable { mRoaming = roaming; } + /** @hide */ + public void setExtendedCdmaRoaming (int roaming) { + this.mExtendedCdmaRoaming = roaming; + } + public void setOperatorName(String longName, String shortName, String numeric) { mOperatorAlphaLong = longName; mOperatorAlphaShort = shortName; @@ -287,7 +418,7 @@ public class ServiceState implements Parcelable { public void setIsManualSelection(boolean isManual) { mIsManualNetworkSelection = isManual; } - + /** * Test whether two objects hold the same data values or both are null * @@ -312,6 +443,11 @@ public class ServiceState implements Parcelable { mOperatorAlphaShort = m.getString("operator-alpha-short"); mOperatorNumeric = m.getString("operator-numeric"); mIsManualNetworkSelection = m.getBoolean("manual"); + mRadioTechnology = m.getInt("radioTechnology"); + mCssIndicator = m.getBoolean("cssIndicator"); + mNetworkId = m.getInt("networkId"); + mSystemId = m.getInt("systemId"); + mExtendedCdmaRoaming = m.getInt("extendedCdmaRoaming"); } /** @@ -327,5 +463,47 @@ public class ServiceState implements Parcelable { m.putString("operator-alpha-short", mOperatorAlphaShort); m.putString("operator-numeric", mOperatorNumeric); m.putBoolean("manual", Boolean.valueOf(mIsManualNetworkSelection)); + m.putInt("radioTechnology", mRadioTechnology); + m.putBoolean("cssIndicator", mCssIndicator); + m.putInt("networkId", mNetworkId); + m.putInt("systemId", mSystemId); + m.putInt("extendedCdmaRoaming", mExtendedCdmaRoaming); + } + + //***** CDMA + /** @hide */ + public void setRadioTechnology(int state) { + this.mRadioTechnology = state; + } + + /** @hide */ + public void setCssIndicator(int css) { + this.mCssIndicator = (css != 0); + } + + /** @hide */ + public void setSystemAndNetworkId(int systemId, int networkId) { + this.mSystemId = systemId; + this.mNetworkId = networkId; + } + + /** @hide */ + public int getRadioTechnology() { + return this.mRadioTechnology; + } + + /** @hide */ + public int getCssIndicator() { + return this.mCssIndicator ? 1 : 0; + } + + /** @hide */ + public int getNetworkId() { + return this.mNetworkId; + } + + /** @hide */ + public int getSystemId() { + return this.mSystemId; } } diff --git a/telephony/java/android/telephony/SmsManager.java b/telephony/java/android/telephony/SmsManager.java new file mode 100644 index 0000000..9395d66 --- /dev/null +++ b/telephony/java/android/telephony/SmsManager.java @@ -0,0 +1,441 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.telephony; + +import android.app.PendingIntent; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.text.TextUtils; + +import com.android.internal.telephony.EncodeException; +import com.android.internal.telephony.GsmAlphabet; +import com.android.internal.telephony.ISms; +import com.android.internal.telephony.IccConstants; +import com.android.internal.telephony.SmsRawData; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import static android.telephony.SmsMessage.ENCODING_7BIT; +import static android.telephony.SmsMessage.ENCODING_8BIT; +import static android.telephony.SmsMessage.ENCODING_16BIT; +import static android.telephony.SmsMessage.ENCODING_UNKNOWN; +import static android.telephony.SmsMessage.MAX_USER_DATA_BYTES; +import static android.telephony.SmsMessage.MAX_USER_DATA_BYTES_WITH_HEADER; +import static android.telephony.SmsMessage.MAX_USER_DATA_SEPTETS; +import static android.telephony.SmsMessage.MAX_USER_DATA_SEPTETS_WITH_HEADER; + +/** + * Manages SMS operations such as sending data, text, and pdu SMS messages. + * Get this object by calling the static method SmsManager.getDefault(). + * @hide + */ +public final class SmsManager { + private static SmsManager sInstance; + + /** + * Send a text based SMS. + * + * @param destinationAddress the address to send the message to + * @param scAddress is the service center address or null to use + * the current default SMSC + * @param text the body of the message to send + * @param sentIntent if not NULL this <code>PendingIntent</code> is + * broadcast when the message is sucessfully sent, or failed. + * The result code will be <code>Activity.RESULT_OK<code> for success, + * or one of these errors: + * <code>RESULT_ERROR_GENERIC_FAILURE</code> + * <code>RESULT_ERROR_RADIO_OFF</code> + * <code>RESULT_ERROR_NULL_PDU</code>. + * The per-application based SMS control checks sentIntent. If sentIntent + * is NULL the caller will be checked against all unknown applications, + * which cause smaller number of SMS to be sent in checking period. + * @param deliveryIntent if not NULL this <code>PendingIntent</code> is + * broadcast when the message is delivered to the recipient. The + * raw pdu of the status report is in the extended data ("pdu"). + * + * @throws IllegalArgumentException if destinationAddress or text are empty + */ + public void sendTextMessage( + String destinationAddress, String scAddress, String text, + PendingIntent sentIntent, PendingIntent deliveryIntent) { + if (TextUtils.isEmpty(destinationAddress)) { + throw new IllegalArgumentException("Invalid destinationAddress"); + } + + if (TextUtils.isEmpty(text)) { + throw new IllegalArgumentException("Invalid message body"); + } + + SmsMessage.SubmitPdu pdus = SmsMessage.getSubmitPdu( + scAddress, destinationAddress, text, (deliveryIntent != null)); + sendRawPdu(pdus.encodedScAddress, pdus.encodedMessage, sentIntent, deliveryIntent); + } + + /** + * Divide a text message into several messages, none bigger than + * the maximum SMS message size. + * + * @param text the original message. Must not be null. + * @return an <code>ArrayList</code> of strings that, in order, + * comprise the original message + */ + public ArrayList<String> divideMessage(String text) { + int size = text.length(); + int[] params = SmsMessage.calculateLength(text, false); + /* SmsMessage.calculateLength returns an int[4] with: + * int[0] being the number of SMS's required, + * int[1] the number of code units used, + * int[2] is the number of code units remaining until the next message. + * int[3] is the encoding type that should be used for the message. + */ + int messageCount = params[0]; + int encodingType = params[3]; + ArrayList<String> result = new ArrayList<String>(messageCount); + + int start = 0; + int limit; + + if (messageCount > 1) { + limit = (encodingType == ENCODING_7BIT)? + MAX_USER_DATA_SEPTETS_WITH_HEADER: MAX_USER_DATA_BYTES_WITH_HEADER; + } else { + limit = (encodingType == ENCODING_7BIT)? + MAX_USER_DATA_SEPTETS: MAX_USER_DATA_BYTES; + } + + try { + while (start < size) { + int end = GsmAlphabet.findLimitIndex(text, start, limit, encodingType); + result.add(text.substring(start, end)); + start = end; + } + } + catch (EncodeException e) { + // ignore it. + } + return result; + } + + /** + * Send a multi-part text based SMS. The callee should have already + * divided the message into correctly sized parts by calling + * <code>divideMessage</code>. + * + * @param destinationAddress the address to send the message to + * @param scAddress is the service center address or null to use + * the current default SMSC + * @param parts an <code>ArrayList</code> of strings that, in order, + * comprise the original message + * @param sentIntents if not null, an <code>ArrayList</code> of + * <code>PendingIntent</code>s (one for each message part) that is + * broadcast when the corresponding message part has been sent. + * The result code will be <code>Activity.RESULT_OK<code> for success, + * or one of these errors: + * <code>RESULT_ERROR_GENERIC_FAILURE</code> + * <code>RESULT_ERROR_RADIO_OFF</code> + * <code>RESULT_ERROR_NULL_PDU</code>. + * The per-application based SMS control checks sentIntent. If sentIntent + * is NULL the caller will be checked against all unknown applicaitons, + * which cause smaller number of SMS to be sent in checking period. + * @param deliveryIntents if not null, an <code>ArrayList</code> of + * <code>PendingIntent</code>s (one for each message part) that is + * broadcast when the corresponding message part has been delivered + * to the recipient. The raw pdu of the status report is in the + * extended data ("pdu"). + * + * @throws IllegalArgumentException if destinationAddress or data are empty + */ + public void sendMultipartTextMessage( + String destinationAddress, String scAddress, ArrayList<String> parts, + ArrayList<PendingIntent> sentIntents, ArrayList<PendingIntent> deliveryIntents) { + if (TextUtils.isEmpty(destinationAddress)) { + throw new IllegalArgumentException("Invalid destinationAddress"); + } + if (parts == null || parts.size() < 1) { + throw new IllegalArgumentException("Invalid message body"); + } + + if (parts.size() > 1) { + try { + ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); + if (iccISms != null) { + iccISms.sendMultipartText(destinationAddress, scAddress, parts, + sentIntents, deliveryIntents); + } + } catch (RemoteException ex) { + // ignore it + } + } else { + PendingIntent sentIntent = null; + PendingIntent deliveryIntent = null; + if (sentIntents != null && sentIntents.size() > 0) { + sentIntent = sentIntents.get(0); + } + if (deliveryIntents != null && deliveryIntents.size() > 0) { + deliveryIntent = deliveryIntents.get(0); + } + sendTextMessage(destinationAddress, scAddress, parts.get(0), + sentIntent, deliveryIntent); + } + } + + /** + * Send a data based SMS to a specific application port. + * + * @param destinationAddress the address to send the message to + * @param scAddress is the service center address or null to use + * the current default SMSC + * @param destinationPort the port to deliver the message to + * @param data the body of the message to send + * @param sentIntent if not NULL this <code>PendingIntent</code> is + * broadcast when the message is sucessfully sent, or failed. + * The result code will be <code>Activity.RESULT_OK<code> for success, + * or one of these errors: + * <code>RESULT_ERROR_GENERIC_FAILURE</code> + * <code>RESULT_ERROR_RADIO_OFF</code> + * <code>RESULT_ERROR_NULL_PDU</code>. + * The per-application based SMS control checks sentIntent. If sentIntent + * is NULL the caller will be checked against all unknown applicaitons, + * which cause smaller number of SMS to be sent in checking period. + * @param deliveryIntent if not NULL this <code>PendingIntent</code> is + * broadcast when the message is delivered to the recipient. The + * raw pdu of the status report is in the extended data ("pdu"). + * + * @throws IllegalArgumentException if destinationAddress or data are empty + */ + public void sendDataMessage( + String destinationAddress, String scAddress, short destinationPort, + byte[] data, PendingIntent sentIntent, PendingIntent deliveryIntent) { + if (TextUtils.isEmpty(destinationAddress)) { + throw new IllegalArgumentException("Invalid destinationAddress"); + } + + if (data == null || data.length == 0) { + throw new IllegalArgumentException("Invalid message data"); + } + + SmsMessage.SubmitPdu pdus = SmsMessage.getSubmitPdu( + scAddress, destinationAddress, + destinationPort, data, (deliveryIntent != null)); + sendRawPdu(pdus.encodedScAddress, pdus.encodedMessage, sentIntent, deliveryIntent); + } + + /** + * Send a raw SMS PDU. + * + * @param smsc the SMSC to send the message through, or NULL for the + * default SMSC + * @param pdu the raw PDU to send + * @param sentIntent if not NULL this <code>PendingIntent</code> is + * broadcast when the message is successfully sent, or failed. + * The result code will be <code>Activity.RESULT_OK<code> for success, + * or one of these errors: + * <code>RESULT_ERROR_GENERIC_FAILURE</code> + * <code>RESULT_ERROR_RADIO_OFF</code> + * <code>RESULT_ERROR_NULL_PDU</code>. + * The per-application based SMS control checks sentIntent. If sentIntent + * is NULL the caller will be checked against all unknown applications, + * which cause smaller number of SMS to be sent in checking period. + * @param deliveryIntent if not NULL this <code>PendingIntent</code> is + * broadcast when the message is delivered to the recipient. The + * raw pdu of the status report is in the extended data ("pdu"). + * + * @hide + */ + private void sendRawPdu(byte[] smsc, byte[] pdu, PendingIntent sentIntent, + PendingIntent deliveryIntent) { + try { + ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); + if (iccISms != null) { + iccISms.sendRawPdu(smsc, pdu, sentIntent, deliveryIntent); + } + } catch (RemoteException ex) { + // ignore it + } + } + + /** + * Get the default instance of the SmsManager + * + * @return the default instance of the SmsManager + */ + public static SmsManager getDefault() { + if (sInstance == null) { + sInstance = new SmsManager(); + } + return sInstance; + } + + private SmsManager() { + //nothing + } + + /** + * Copy a raw SMS PDU to the ICC. + * + * @param smsc the SMSC for this message, or NULL for the default SMSC + * @param pdu the raw PDU to store + * @param status message status (STATUS_ON_ICC_READ, STATUS_ON_ICC_UNREAD, + * STATUS_ON_ICC_SENT, STATUS_ON_ICC_UNSENT) + * @return true for success + * + * {@hide} + */ + public boolean copyMessageToIcc(byte[] smsc, byte[] pdu, int status) { + boolean success = false; + + try { + ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); + if (iccISms != null) { + success = iccISms.copyMessageToIccEf(status, pdu, smsc); + } + } catch (RemoteException ex) { + // ignore it + } + + return success; + } + + /** + * Delete the specified message from the ICC. + * + * @param messageIndex is the record index of the message on ICC + * @return true for success + * + * {@hide} + */ + public boolean + deleteMessageFromIcc(int messageIndex) { + boolean success = false; + byte[] pdu = new byte[IccConstants.SMS_RECORD_LENGTH-1]; + Arrays.fill(pdu, (byte)0xff); + + try { + ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); + if (iccISms != null) { + success = iccISms.updateMessageOnIccEf(messageIndex, STATUS_ON_ICC_FREE, pdu); + } + } catch (RemoteException ex) { + // ignore it + } + + return success; + } + + /** + * Update the specified message on the ICC. + * + * @param messageIndex record index of message to update + * @param newStatus new message status (STATUS_ON_ICC_READ, + * STATUS_ON_ICC_UNREAD, STATUS_ON_ICC_SENT, + * STATUS_ON_ICC_UNSENT, STATUS_ON_ICC_FREE) + * @param pdu the raw PDU to store + * @return true for success + * + * {@hide} + */ + public boolean updateMessageOnIcc(int messageIndex, int newStatus, byte[] pdu) { + boolean success = false; + + try { + ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); + if (iccISms != null) { + success = iccISms.updateMessageOnIccEf(messageIndex, newStatus, pdu); + } + } catch (RemoteException ex) { + // ignore it + } + + return success; + } + + /** + * Retrieves all messages currently stored on ICC. + * + * @return <code>ArrayList</code> of <code>SmsMessage</code> objects + * + * {@hide} + */ + public ArrayList<SmsMessage> getAllMessagesFromIcc() { + List<SmsRawData> records = null; + + try { + ISms iccISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); + if (iccISms != null) { + records = iccISms.getAllMessagesFromIccEf(); + } + } catch (RemoteException ex) { + // ignore it + } + + return createMessageListFromRawRecords(records); + } + + /** + * Create a list of <code>SmsMessage</code>s from a list of RawSmsData + * records returned by <code>getAllMessagesFromIcc()</code> + * + * @param records SMS EF records, returned by + * <code>getAllMessagesFromIcc</code> + * @return <code>ArrayList</code> of <code>SmsMessage</code> objects. + */ + private ArrayList<SmsMessage> createMessageListFromRawRecords(List records) { + ArrayList<SmsMessage> messages = new ArrayList<SmsMessage>(); + if (records != null) { + int count = records.size(); + for (int i = 0; i < count; i++) { + SmsRawData data = (SmsRawData)records.get(i); + // List contains all records, including "free" records (null) + if (data != null) { + SmsMessage sms = SmsMessage.createFromEfRecord(i+1, data.getBytes()); + messages.add(sms); + } + } + } + return messages; + } + + // see SmsMessage.getStatusOnIcc + + /** Free space (TS 51.011 10.5.3 / 3GPP2 C.S0023 3.4.27). */ + static public final int STATUS_ON_ICC_FREE = 0; + + /** Received and read (TS 51.011 10.5.3 / 3GPP2 C.S0023 3.4.27). */ + static public final int STATUS_ON_ICC_READ = 1; + + /** Received and unread (TS 51.011 10.5.3 / 3GPP2 C.S0023 3.4.27). */ + static public final int STATUS_ON_ICC_UNREAD = 3; + + /** Stored and sent (TS 51.011 10.5.3 / 3GPP2 C.S0023 3.4.27). */ + static public final int STATUS_ON_ICC_SENT = 5; + + /** Stored and unsent (TS 51.011 10.5.3 / 3GPP2 C.S0023 3.4.27). */ + static public final int STATUS_ON_ICC_UNSENT = 7; + + // SMS send failure result codes + + /** Generic failure cause */ + static public final int RESULT_ERROR_GENERIC_FAILURE = 1; + /** Failed because radio was explicitly turned off */ + static public final int RESULT_ERROR_RADIO_OFF = 2; + /** Failed because no pdu provided */ + static public final int RESULT_ERROR_NULL_PDU = 3; + /** Failed because service is currently unavailable */ + static public final int RESULT_ERROR_NO_SERVICE = 4; +} diff --git a/telephony/java/android/telephony/SmsMessage.java b/telephony/java/android/telephony/SmsMessage.java new file mode 100644 index 0000000..3b7f4b5 --- /dev/null +++ b/telephony/java/android/telephony/SmsMessage.java @@ -0,0 +1,628 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.telephony; + +import android.os.Parcel; + +import com.android.internal.telephony.GsmAlphabet; +import com.android.internal.telephony.EncodeException; +import com.android.internal.telephony.SmsMessageBase; +import com.android.internal.telephony.SmsMessageBase.SubmitPduBase; + +import static android.telephony.TelephonyManager.PHONE_TYPE_CDMA; + + +/** + * A Short Message Service message. + * @hide + */ +public class SmsMessage { + private static final boolean LOCAL_DEBUG = true; + private static final String LOG_TAG = "SMS"; + + /** + * SMS Class enumeration. + * See TS 23.038. + * + */ + public enum MessageClass{ + UNKNOWN, CLASS_0, CLASS_1, CLASS_2, CLASS_3; + } + + /** Unknown encoding scheme (see TS 23.038) */ + public static final int ENCODING_UNKNOWN = 0; + /** 7-bit encoding scheme (see TS 23.038) */ + public static final int ENCODING_7BIT = 1; + /** 8-bit encoding scheme (see TS 23.038) */ + public static final int ENCODING_8BIT = 2; + /** 16-bit encoding scheme (see TS 23.038) */ + public static final int ENCODING_16BIT = 3; + + /** The maximum number of payload bytes per message */ + public static final int MAX_USER_DATA_BYTES = 140; + + /** + * The maximum number of payload bytes per message if a user data header + * is present. This assumes the header only contains the + * CONCATENATED_8_BIT_REFERENCE element. + * + * @hide pending API Council approval to extend the public API + */ + public static final int MAX_USER_DATA_BYTES_WITH_HEADER = 134; + + /** The maximum number of payload septets per message */ + public static final int MAX_USER_DATA_SEPTETS = 160; + + /** + * The maximum number of payload septets per message if a user data header + * is present. This assumes the header only contains the + * CONCATENATED_8_BIT_REFERENCE element. + */ + public static final int MAX_USER_DATA_SEPTETS_WITH_HEADER = 153; + + /** Contains actual SmsMessage. Only public for debugging and for framework layer. + * {@hide} + */ + public SmsMessageBase mWrappedSmsMessage; + + public static class SubmitPdu extends SubmitPduBase { + + //Constructor + public SubmitPdu() { + } + + /* {@hide} */ + protected SubmitPdu(SubmitPduBase spb) { + this.encodedMessage = spb.encodedMessage; + this.encodedScAddress = spb.encodedScAddress; + } + + } + + // Constructor + public SmsMessage() { + this(getSmsFacility()); + } + + private SmsMessage(SmsMessageBase smb) { + mWrappedSmsMessage = smb; + } + + /** + * Create an SmsMessage from a raw PDU. + */ + public static SmsMessage createFromPdu(byte[] pdu) { + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.createFromPdu(pdu); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.createFromPdu(pdu); + } + + return new SmsMessage(wrappedMessage); + } + + /** + * TS 27.005 3.4.1 lines[0] and lines[1] are the two lines read from the + * +CMT unsolicited response (PDU mode, of course) + * +CMT: [<alpha>],<length><CR><LF><pdu> + * + * Only public for debugging and for RIL + * + * {@hide} + */ + public static SmsMessage newFromCMT(String[] lines){ + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.newFromCMT(lines); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.newFromCMT(lines); + } + + return new SmsMessage(wrappedMessage); + } + + /** @hide */ + protected static SmsMessage newFromCMTI(String line) { + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.newFromCMTI(line); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.newFromCMTI(line); + } + + return new SmsMessage(wrappedMessage); + } + + /** @hide */ + public static SmsMessage newFromCDS(String line) { + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.newFromCDS(line); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.newFromCDS(line); + } + + return new SmsMessage(wrappedMessage); + } + + /** @hide */ + public static SmsMessage newFromParcel(Parcel p) { + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.newFromParcel(p); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.newFromParcel(p); + } + + return new SmsMessage(wrappedMessage); + } + + /** + * Create an SmsMessage from an SMS EF record. + * + * @param index Index of SMS record. This should be index in ArrayList + * returned by SmsManager.getAllMessagesFromSim + 1. + * @param data Record data. + * @return An SmsMessage representing the record. + * + * @hide + */ + public static SmsMessage createFromEfRecord(int index, byte[] data) { + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.createFromEfRecord( + index, data); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.createFromEfRecord( + index, data); + } + + return new SmsMessage(wrappedMessage); + } + + /** + * Get the TP-Layer-Length for the given SMS-SUBMIT PDU Basically, the + * length in bytes (not hex chars) less the SMSC header + */ + public static int getTPLayerLengthForPDU(String pdu) { + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + return com.android.internal.telephony.cdma.SmsMessage.getTPLayerLengthForPDU(pdu); + } else { + return com.android.internal.telephony.gsm.SmsMessage.getTPLayerLengthForPDU(pdu); + } + } + + /** + * Calculates the number of SMS's required to encode the message body and + * the number of characters remaining until the next message, given the + * current encoding. + * + * @param messageBody the message to encode + * @param use7bitOnly if true, characters that are not part of the GSM + * alphabet are counted as a single space char. If false, a + * messageBody containing non-GSM alphabet characters is calculated + * for 16-bit encoding. + * @return an int[4] with int[0] being the number of SMS's required, int[1] + * the number of code units used, and int[2] is the number of code + * units remaining until the next message. int[3] is the encoding + * type that should be used for the message. + */ + public static int[] calculateLength(CharSequence messageBody, boolean use7bitOnly) { + int ret[] = new int[4]; + + try { + // Try GSM alphabet + int septets = GsmAlphabet.countGsmSeptets(messageBody, !use7bitOnly); + ret[1] = septets; + if (septets > MAX_USER_DATA_SEPTETS) { + ret[0] = (septets / MAX_USER_DATA_SEPTETS_WITH_HEADER) + 1; + ret[2] = MAX_USER_DATA_SEPTETS_WITH_HEADER + - (septets % MAX_USER_DATA_SEPTETS_WITH_HEADER); + } else { + ret[0] = 1; + ret[2] = MAX_USER_DATA_SEPTETS - septets; + } + ret[3] = ENCODING_7BIT; + } catch (EncodeException ex) { + // fall back to UCS-2 + int octets = messageBody.length() * 2; + ret[1] = messageBody.length(); + if (octets > MAX_USER_DATA_BYTES) { + // 6 is the size of the user data header + ret[0] = (octets / MAX_USER_DATA_BYTES_WITH_HEADER) + 1; + ret[2] = (MAX_USER_DATA_BYTES_WITH_HEADER + - (octets % MAX_USER_DATA_BYTES_WITH_HEADER))/2; + } else { + ret[0] = 1; + ret[2] = (MAX_USER_DATA_BYTES - octets)/2; + } + ret[3] = ENCODING_16BIT; + } + + return ret; + } + + /** + * Calculates the number of SMS's required to encode the message body and + * the number of characters remaining until the next message, given the + * current encoding. + * + * @param messageBody the message to encode + * @param use7bitOnly if true, characters that are not part of the GSM + * alphabet are counted as a single space char. If false, a + * messageBody containing non-GSM alphabet characters is calculated + * for 16-bit encoding. + * @return an int[4] with int[0] being the number of SMS's required, int[1] + * the number of code units used, and int[2] is the number of code + * units remaining until the next message. int[3] is the encoding + * type that should be used for the message. + */ + public static int[] calculateLength(String messageBody, boolean use7bitOnly) { + return calculateLength((CharSequence)messageBody, use7bitOnly); + } + + /** + * Get an SMS-SUBMIT PDU for a destination address and a message + * + * @param scAddress Service Centre address. Null means use default. + * @return a <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message. + * Returns null on encode error. + * @hide + */ + public static SubmitPdu getSubmitPdu(String scAddress, + String destinationAddress, String message, + boolean statusReportRequested, byte[] header) { + SubmitPduBase spb; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + spb = com.android.internal.telephony.cdma.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, message, statusReportRequested, header); + } else { + spb = com.android.internal.telephony.gsm.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, message, statusReportRequested, header); + } + + return new SubmitPdu(spb); + } + + /** + * Get an SMS-SUBMIT PDU for a destination address and a message + * + * @param scAddress Service Centre address. Null means use default. + * @return a <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message. + * Returns null on encode error. + */ + public static SubmitPdu getSubmitPdu(String scAddress, + String destinationAddress, String message, boolean statusReportRequested) { + SubmitPduBase spb; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + spb = com.android.internal.telephony.cdma.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, message, statusReportRequested); + } else { + spb = com.android.internal.telephony.gsm.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, message, statusReportRequested); + } + + return new SubmitPdu(spb); + } + + /** + * Get an SMS-SUBMIT PDU for a data message to a destination address & port + * + * @param scAddress Service Centre address. null == use default + * @param destinationAddress the address of the destination for the message + * @param destinationPort the port to deliver the message to at the + * destination + * @param data the dat for the message + * @return a <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message. + * Returns null on encode error. + */ + public static SubmitPdu getSubmitPdu(String scAddress, + String destinationAddress, short destinationPort, byte[] data, + boolean statusReportRequested) { + SubmitPduBase spb; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + spb = com.android.internal.telephony.cdma.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, destinationPort, data, statusReportRequested); + } else { + spb = com.android.internal.telephony.gsm.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, destinationPort, data, statusReportRequested); + } + + return new SubmitPdu(spb); + } + + /** + * Returns the address of the SMS service center that relayed this message + * or null if there is none. + */ + public String getServiceCenterAddress() { + return mWrappedSmsMessage.getServiceCenterAddress(); + } + + /** + * Returns the originating address (sender) of this SMS message in String + * form or null if unavailable + */ + public String getOriginatingAddress() { + return mWrappedSmsMessage.getOriginatingAddress(); + } + + /** + * Returns the originating address, or email from address if this message + * was from an email gateway. Returns null if originating address + * unavailable. + */ + public String getDisplayOriginatingAddress() { + return mWrappedSmsMessage.getDisplayOriginatingAddress(); + } + + /** + * Returns the message body as a String, if it exists and is text based. + * @return message body is there is one, otherwise null + */ + public String getMessageBody() { + return mWrappedSmsMessage.getMessageBody(); + } + + /** + * Returns the class of this message. + */ + public MessageClass getMessageClass() { + return mWrappedSmsMessage.getMessageClass(); + } + + /** + * Returns the message body, or email message body if this message was from + * an email gateway. Returns null if message body unavailable. + */ + public String getDisplayMessageBody() { + return mWrappedSmsMessage.getDisplayMessageBody(); + } + + /** + * Unofficial convention of a subject line enclosed in parens empty string + * if not present + */ + public String getPseudoSubject() { + return mWrappedSmsMessage.getPseudoSubject(); + } + + /** + * Returns the service centre timestamp in currentTimeMillis() format + */ + public long getTimestampMillis() { + return mWrappedSmsMessage.getTimestampMillis(); + } + + /** + * Returns true if message is an email. + * + * @return true if this message came through an email gateway and email + * sender / subject / parsed body are available + */ + public boolean isEmail() { + return mWrappedSmsMessage.isEmail(); + } + + /** + * @return if isEmail() is true, body of the email sent through the gateway. + * null otherwise + */ + public String getEmailBody() { + return mWrappedSmsMessage.getEmailBody(); + } + + /** + * @return if isEmail() is true, email from address of email sent through + * the gateway. null otherwise + */ + public String getEmailFrom() { + return mWrappedSmsMessage.getEmailFrom(); + } + + /** + * Get protocol identifier. + */ + public int getProtocolIdentifier() { + return mWrappedSmsMessage.getProtocolIdentifier(); + } + + /** + * See TS 23.040 9.2.3.9 returns true if this is a "replace short message" + * SMS + */ + public boolean isReplace() { + return mWrappedSmsMessage.isReplace(); + } + + /** + * Returns true for CPHS MWI toggle message. + * + * @return true if this is a CPHS MWI toggle message See CPHS 4.2 section + * B.4.2 + */ + public boolean isCphsMwiMessage() { + return mWrappedSmsMessage.isCphsMwiMessage(); + } + + /** + * returns true if this message is a CPHS voicemail / message waiting + * indicator (MWI) clear message + */ + public boolean isMWIClearMessage() { + return mWrappedSmsMessage.isMWIClearMessage(); + } + + /** + * returns true if this message is a CPHS voicemail / message waiting + * indicator (MWI) set message + */ + public boolean isMWISetMessage() { + return mWrappedSmsMessage.isMWISetMessage(); + } + + /** + * returns true if this message is a "Message Waiting Indication Group: + * Discard Message" notification and should not be stored. + */ + public boolean isMwiDontStore() { + return mWrappedSmsMessage.isMwiDontStore(); + } + + /** + * returns the user data section minus the user data header if one was + * present. + */ + public byte[] getUserData() { + return mWrappedSmsMessage.getUserData(); + } + + /* Not part of the SDK interface and only needed by specific classes: + protected SmsHeader getUserDataHeader() + */ + + /** + * Returns the raw PDU for the message. + * + * @return the raw PDU for the message. + */ + public byte[] getPdu() { + return mWrappedSmsMessage.getPdu(); + } + + /** + * Returns the status of the message on the SIM (read, unread, sent, unsent). + * + * @return the status of the message on the SIM. These are: + * SmsManager.STATUS_ON_SIM_FREE + * SmsManager.STATUS_ON_SIM_READ + * SmsManager.STATUS_ON_SIM_UNREAD + * SmsManager.STATUS_ON_SIM_SEND + * SmsManager.STATUS_ON_SIM_UNSENT + * @deprecated Use getStatusOnIcc instead. + */ + @Deprecated public int getStatusOnSim() { + return mWrappedSmsMessage.getStatusOnIcc(); + } + + /** + * Returns the status of the message on the ICC (read, unread, sent, unsent). + * + * @return the status of the message on the ICC. These are: + * SmsManager.STATUS_ON_ICC_FREE + * SmsManager.STATUS_ON_ICC_READ + * SmsManager.STATUS_ON_ICC_UNREAD + * SmsManager.STATUS_ON_ICC_SEND + * SmsManager.STATUS_ON_ICC_UNSENT + */ + public int getStatusOnIcc() { + + return mWrappedSmsMessage.getStatusOnIcc(); + } + + /** + * Returns the record index of the message on the SIM (1-based index). + * @return the record index of the message on the SIM, or -1 if this + * SmsMessage was not created from a SIM SMS EF record. + * @deprecated Use getIndexOnIcc instead. + */ + @Deprecated public int getIndexOnSim() { + return mWrappedSmsMessage.getIndexOnIcc(); + } + + /** + * Returns the record index of the message on the ICC (1-based index). + * @return the record index of the message on the ICC, or -1 if this + * SmsMessage was not created from a ICC SMS EF record. + */ + public int getIndexOnIcc() { + + return mWrappedSmsMessage.getIndexOnIcc(); + } + + /** + * GSM: + * For an SMS-STATUS-REPORT message, this returns the status field from + * the status report. This field indicates the status of a previously + * submitted SMS, if requested. See TS 23.040, 9.2.3.15 TP-Status for a + * description of values. + * CDMA: + * For not interfering with status codes from GSM, the value is + * shifted to the bits 31-16. + * The value is composed of an error class (bits 25-24) and a status code (bits 23-16). + * Possible codes are described in C.S0015-B, v2.0, 4.5.21. + * + * @return 0 indicates the previously sent message was received. + * See TS 23.040, 9.9.2.3.15 and C.S0015-B, v2.0, 4.5.21 + * for a description of other possible values. + */ + public int getStatus() { + return mWrappedSmsMessage.getStatus(); + } + + /** + * Return true iff the message is a SMS-STATUS-REPORT message. + */ + public boolean isStatusReportMessage() { + return mWrappedSmsMessage.isStatusReportMessage(); + } + + /** + * Returns true iff the <code>TP-Reply-Path</code> bit is set in + * this message. + */ + public boolean isReplyPathPresent() { + return mWrappedSmsMessage.isReplyPathPresent(); + } + + /** This method returns the reference to a specific + * SmsMessage object, which is used for accessing its static methods. + * @return Specific SmsMessage. + */ + private static final SmsMessageBase getSmsFacility(){ + int activePhone = TelephonyManager.getDefault().getPhoneType(); + if (PHONE_TYPE_CDMA == activePhone) { + return new com.android.internal.telephony.cdma.SmsMessage(); + } else { + return new com.android.internal.telephony.gsm.SmsMessage(); + } + } +} diff --git a/telephony/java/android/telephony/TelephonyManager.java b/telephony/java/android/telephony/TelephonyManager.java index c5b1b73..921ce77 100644 --- a/telephony/java/android/telephony/TelephonyManager.java +++ b/telephony/java/android/telephony/TelephonyManager.java @@ -28,25 +28,31 @@ import android.os.Bundle; import android.os.RemoteException; import android.os.ServiceManager; import android.os.SystemProperties; +import android.telephony.CellLocation; +import com.android.internal.telephony.IPhoneSubInfo; +import com.android.internal.telephony.ITelephony; +import com.android.internal.telephony.ITelephonyRegistry; +import com.android.internal.telephony.RILConstants; +import com.android.internal.telephony.TelephonyProperties; /** * Provides access to information about the telephony services on * the device. Applications can use the methods in this class to * determine telephony services and states, as well as to access some - * types of subscriber information. Applications can also register - * a listener to receive notification of telephony state changes. + * types of subscriber information. Applications can also register + * a listener to receive notification of telephony state changes. * <p> * You do not instantiate this class directly; instead, you retrieve - * a reference to an instance through + * a reference to an instance through * {@link android.content.Context#getSystemService * Context.getSystemService(Context.TELEPHONY_SERVICE)}. * <p> * Note that acess to some telephony information is - * permission-protected. Your application cannot access the protected - * information unless it has the appropriate permissions declared in - * its manifest file. Where permissions apply, they are noted in the - * the methods through which you access the protected information. + * permission-protected. Your application cannot access the protected + * information unless it has the appropriate permissions declared in + * its manifest file. Where permissions apply, they are noted in the + * the methods through which you access the protected information. */ public class TelephonyManager { private static final String TAG = "TelephonyManager"; @@ -166,10 +172,10 @@ public class TelephonyManager { // /** - * Returns the software version number for the device, for example, + * Returns the software version number for the device, for example, * the IMEI/SV for GSM phones. * - * <p>Requires Permission: + * <p>Requires Permission: * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} */ public String getDeviceSoftwareVersion() { @@ -181,10 +187,10 @@ public class TelephonyManager { } /** - * Returns the unique device ID, for example,the IMEI for GSM + * Returns the unique device ID, for example, the IMEI for GSM and the MEID for CDMA * phones. * - * <p>Requires Permission: + * <p>Requires Permission: * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} */ public String getDeviceId() { @@ -214,7 +220,7 @@ public class TelephonyManager { * Enables location update notifications. {@link PhoneStateListener#onCellLocationChanged * PhoneStateListener.onCellLocationChanged} will be called on location updates. * - * <p>Requires Permission: {@link android.Manifest.permission#CONTROL_LOCATION_UPDATES + * <p>Requires Permission: {@link android.Manifest.permission#CONTROL_LOCATION_UPDATES * CONTROL_LOCATION_UPDATES} * * @hide @@ -270,23 +276,37 @@ public class TelephonyManager { public static final int PHONE_TYPE_GSM = 1; /** - * Returns a constant indicating the device phone type. - * + * CDMA phone + * @hide + */ + public static final int PHONE_TYPE_CDMA = 2; + + /** + * Returns a constant indicating the device phone type. + * * @see #PHONE_TYPE_NONE * @see #PHONE_TYPE_GSM + * @see #PHONE_TYPE_CDMA */ public int getPhoneType() { - // in the future, we should really check this - return PHONE_TYPE_GSM; + try{ + if(getITelephony().getActivePhoneType() == RILConstants.CDMA_PHONE) { + return PHONE_TYPE_CDMA; + } else { + return PHONE_TYPE_GSM; + } + }catch(RemoteException ex){ + return PHONE_TYPE_NONE; + } } // - // + // // Current Network // // - /** + /** * Returns the alphabetic name of current registered operator. * <p> * Availability: Only when user is registered to a network @@ -295,7 +315,7 @@ public class TelephonyManager { return SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_ALPHA); } - /** + /** * Returns the numeric name (MCC+MNC) of current registered operator. * <p> * Availability: Only when user is registered to a network @@ -304,7 +324,7 @@ public class TelephonyManager { return SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_NUMERIC); } - /** + /** * Returns true if the device is considered roaming on the current * network, for GSM purposes. * <p> @@ -314,7 +334,7 @@ public class TelephonyManager { return "true".equals(SystemProperties.get(TelephonyProperties.PROPERTY_OPERATOR_ISROAMING)); } - /** + /** * Returns the ISO country code equivilent of the current registered * operator's MCC (Mobile Country Code). * <p> @@ -332,9 +352,20 @@ public class TelephonyManager { public static final int NETWORK_TYPE_EDGE = 2; /** Current network is UMTS */ public static final int NETWORK_TYPE_UMTS = 3; + /** Current network is CDMA: Either IS95A or IS95B*/ + /** @hide */ + public static final int NETWORK_TYPE_CDMA = 4; + /** Current network is EVDO revision 0 or revision A*/ + /** @hide */ + public static final int NETWORK_TYPE_EVDO_0 = 5; + /** @hide */ + public static final int NETWORK_TYPE_EVDO_A = 6; + /** Current network is 1xRTT*/ + /** @hide */ + public static final int NETWORK_TYPE_1xRTT = 7; /** - * Returns a constant indicating the radio technology (network type) + * Returns a constant indicating the radio technology (network type) * currently in use on the device. * @return the network type * @@ -342,6 +373,10 @@ public class TelephonyManager { * @see #NETWORK_TYPE_GPRS * @see #NETWORK_TYPE_EDGE * @see #NETWORK_TYPE_UMTS + * @see #NETWORK_TYPE_CDMA + * @see #NETWORK_TYPE_EVDO_0 + * @see #NETWORK_TYPE_EVDO_A + * @see #NETWORK_TYPE_1xRTT */ public int getNetworkType() { String prop = SystemProperties.get(TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE); @@ -354,6 +389,18 @@ public class TelephonyManager { else if ("UMTS".equals(prop)) { return NETWORK_TYPE_UMTS; } + else if ("CDMA".equals(prop)) { + return NETWORK_TYPE_CDMA; + } + else if ("CDMA - EvDo rev. 0".equals(prop)) { + return NETWORK_TYPE_EVDO_0; + } + else if ("CDMA - EvDo rev. A".equals(prop)) { + return NETWORK_TYPE_EVDO_A; + } + else if ("CDMA - 1xRTT".equals(prop)) { + return NETWORK_TYPE_1xRTT; + } else { return NETWORK_TYPE_UNKNOWN; } @@ -374,6 +421,14 @@ public class TelephonyManager { return "EDGE"; case NETWORK_TYPE_UMTS: return "UMTS"; + case NETWORK_TYPE_CDMA: + return "CDMA"; + case NETWORK_TYPE_EVDO_0: + return "CDMA - EvDo rev. 0"; + case NETWORK_TYPE_EVDO_A: + return "CDMA - EvDo rev. A"; + case NETWORK_TYPE_1xRTT: + return "CDMA - 1xRTT"; default: return "UNKNOWN"; } @@ -387,7 +442,7 @@ public class TelephonyManager { /** SIM card state: Unknown. Signifies that the SIM is in transition * between states. For example, when the user inputs the SIM pin - * under PIN_REQUIRED state, a query for sim status returns + * under PIN_REQUIRED state, a query for sim status returns * this state before turning to SIM_STATE_READY. */ public static final int SIM_STATE_UNKNOWN = 0; /** SIM card state: no SIM card is available in the device */ @@ -400,11 +455,11 @@ public class TelephonyManager { public static final int SIM_STATE_NETWORK_LOCKED = 4; /** SIM card state: Ready */ public static final int SIM_STATE_READY = 5; - - /** - * Returns a constant indicating the state of the + + /** + * Returns a constant indicating the state of the * device SIM card. - * + * * @see #SIM_STATE_UNKNOWN * @see #SIM_STATE_ABSENT * @see #SIM_STATE_PIN_REQUIRED @@ -434,7 +489,7 @@ public class TelephonyManager { } } - /** + /** * Returns the MCC+MNC (mobile country code + mobile network code) of the * provider of the SIM. 5 or 6 decimal digits. * <p> @@ -443,36 +498,36 @@ public class TelephonyManager { * @see #getSimState */ public String getSimOperator() { - return SystemProperties.get(TelephonyProperties.PROPERTY_SIM_OPERATOR_NUMERIC); + return SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC); } - /** - * Returns the Service Provider Name (SPN). + /** + * Returns the Service Provider Name (SPN). * <p> * Availability: SIM state must be {@link #SIM_STATE_READY} * * @see #getSimState */ public String getSimOperatorName() { - return SystemProperties.get(TelephonyProperties.PROPERTY_SIM_OPERATOR_ALPHA); + return SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA); } - /** + /** * Returns the ISO country code equivalent for the SIM provider's country code. */ public String getSimCountryIso() { - return SystemProperties.get(TelephonyProperties.PROPERTY_SIM_OPERATOR_ISO_COUNTRY); + return SystemProperties.get(TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY); } /** * Returns the serial number of the SIM, if applicable. * <p> - * Requires Permission: + * Requires Permission: * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} */ public String getSimSerialNumber() { try { - return getSubscriberInfo().getSimSerialNumber(); + return getSubscriberInfo().getIccSerialNumber(); } catch (RemoteException ex) { } return null; @@ -487,7 +542,7 @@ public class TelephonyManager { /** * Returns the unique subscriber ID, for example, the IMSI for a GSM phone. * <p> - * Requires Permission: + * Requires Permission: * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} */ public String getSubscriberId() { @@ -499,10 +554,10 @@ public class TelephonyManager { } /** - * Returns the phone number string for line 1, for example, the MSISDN + * Returns the phone number string for line 1, for example, the MSISDN * for a GSM phone. * <p> - * Requires Permission: + * Requires Permission: * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} */ public String getLine1Number() { @@ -514,9 +569,9 @@ public class TelephonyManager { } /** - * Returns the alphabetic identifier associated with the line 1 number. + * Returns the alphabetic identifier associated with the line 1 number. * <p> - * Requires Permission: + * Requires Permission: * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} * @hide * nobody seems to call this. @@ -532,7 +587,7 @@ public class TelephonyManager { /** * Returns the voice mail number. * <p> - * Requires Permission: + * Requires Permission: * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} */ public String getVoiceMailNumber() { @@ -547,7 +602,7 @@ public class TelephonyManager { * Retrieves the alphabetic identifier associated with the voice * mail number. * <p> - * Requires Permission: + * Requires Permission: * {@link android.Manifest.permission#READ_PHONE_STATE READ_PHONE_STATE} */ public String getVoiceMailAlphaTag() { @@ -567,10 +622,10 @@ public class TelephonyManager { /** Device call state: No activity. */ public static final int CALL_STATE_IDLE = 0; /** Device call state: Ringing. A new call arrived and is - * ringing or waiting. In the latter case, another call is + * ringing or waiting. In the latter case, another call is * already active. */ public static final int CALL_STATE_RINGING = 1; - /** Device call state: Off-hook. At least one call exists + /** Device call state: Off-hook. At least one call exists * that is dialing, active, or on hold, and no calls are ringing * or waiting. */ public static final int CALL_STATE_OFFHOOK = 2; @@ -621,13 +676,13 @@ public class TelephonyManager { public static final int DATA_CONNECTING = 1; /** Data connection state: Connected. IP traffic should be available. */ public static final int DATA_CONNECTED = 2; - /** Data connection state: Suspended. The connection is up, but IP - * traffic is temporarily unavailable. For example, in a 2G network, + /** Data connection state: Suspended. The connection is up, but IP + * traffic is temporarily unavailable. For example, in a 2G network, * data activity may be suspended when a voice call arrives. */ public static final int DATA_SUSPENDED = 3; /** - * Returns a constant indicating the current data connection state + * Returns a constant indicating the current data connection state * (cellular). * * @see #DATA_DISCONNECTED @@ -655,26 +710,26 @@ public class TelephonyManager { // /** - * Registers a listener object to receive notification of changes - * in specified telephony states. + * Registers a listener object to receive notification of changes + * in specified telephony states. * <p> * To register a listener, pass a {@link PhoneStateListener} - * and specify at least one telephony state of interest in - * the events argument. - * + * and specify at least one telephony state of interest in + * the events argument. + * * At registration, and when a specified telephony state - * changes, the telephony manager invokes the appropriate - * callback method on the listener object and passes the + * changes, the telephony manager invokes the appropriate + * callback method on the listener object and passes the * current (udpated) values. * <p> * To unregister a listener, pass the listener object and set the - * events argument to + * events argument to * {@link PhoneStateListener#LISTEN_NONE LISTEN_NONE} (0). - * + * * @param listener The {@link PhoneStateListener} object to register * (or unregister) * @param events The telephony state(s) of interest to the listener, - * as a bitwise-OR combination of {@link PhoneStateListener} + * as a bitwise-OR combination of {@link PhoneStateListener} * LISTEN_ flags. */ public void listen(PhoneStateListener listener, int events) { diff --git a/telephony/java/android/telephony/cdma/CdmaCellLocation.java b/telephony/java/android/telephony/cdma/CdmaCellLocation.java new file mode 100644 index 0000000..189959b --- /dev/null +++ b/telephony/java/android/telephony/cdma/CdmaCellLocation.java @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.telephony.cdma; + +import android.os.Bundle; +import android.telephony.CellLocation; + +/** + * Represents the cell location on a GSM phone. + * @hide + */ +public class CdmaCellLocation extends CellLocation { + private int mBaseStationId = -1; + private int mBaseStationLatitude = -1; + private int mBaseStationLongitude = -1; + + /** + * Empty constructor. Initializes the LAC and CID to -1. + */ + public CdmaCellLocation() { + this.mBaseStationId = -1; + this.mBaseStationLatitude = -1; + this.mBaseStationLongitude = -1; + } + + /** + * Initialize the object from a bundle. + */ + public CdmaCellLocation(Bundle bundleWithValues) { + this.mBaseStationId = bundleWithValues.getInt("baseStationId"); + this.mBaseStationLatitude = bundleWithValues.getInt("baseStationLatitude"); + this.mBaseStationLongitude = bundleWithValues.getInt("baseStationLongitude"); + } + + /** + * @return cdma base station identification number, -1 if unknown + */ + public int getBaseStationId() { + return this.mBaseStationId; + } + + /** + * @return cdma base station latitude, -1 if unknown + */ + public int getBaseStationLatitude() { + return this.mBaseStationLatitude; + } + + /** + * @return cdma base station longitude, -1 if unknown + */ + public int getBaseStationLongitude() { + return this.mBaseStationLongitude; + } + + /** + * Invalidate this object. The cell location data is set to -1. + */ + public void setStateInvalid() { + this.mBaseStationId = -1; + this.mBaseStationLatitude = -1; + this.mBaseStationLongitude = -1; + } + + /** + * Set the cell location data. + */ + public void setCellLocationData(int baseStationId, int baseStationLatitude, + int baseStationLongitude) { + // The following values have to be written in the correct sequence + this.mBaseStationId = baseStationId; + this.mBaseStationLatitude = baseStationLatitude; //values[2]; + this.mBaseStationLongitude = baseStationLongitude; //values[3]; + } + + @Override + public int hashCode() { + return this.mBaseStationId ^ this.mBaseStationLatitude ^ this.mBaseStationLongitude; + } + + @Override + public boolean equals(Object o) { + CdmaCellLocation s; + + try { + s = (CdmaCellLocation)o; + } catch (ClassCastException ex) { + return false; + } + + if (o == null) { + return false; + } + + return (equalsHandlesNulls(this.mBaseStationId, s.mBaseStationId) && + equalsHandlesNulls(this.mBaseStationLatitude, s.mBaseStationLatitude) && + equalsHandlesNulls(this.mBaseStationLongitude, s.mBaseStationLongitude) + ); + } + + @Override + public String toString() { + return "[" + this.mBaseStationId + "," + + this.mBaseStationLatitude + "," + + this.mBaseStationLongitude + "]"; + } + + /** + * Test whether two objects hold the same data values or both are null + * + * @param a first obj + * @param b second obj + * @return true if two objects equal or both are null + */ + private static boolean equalsHandlesNulls(Object a, Object b) { + return (a == null) ? (b == null) : a.equals (b); + } + + /** + * Fill the cell location data into the intent notifier Bundle based on service state + * + * @param bundleToFill intent notifier Bundle + */ + public void fillInNotifierBundle(Bundle bundleToFill) { + bundleToFill.putInt("baseStationId", this.mBaseStationId); + bundleToFill.putInt("baseStationLatitude", this.mBaseStationLatitude); + bundleToFill.putInt("baseStationLongitude", this.mBaseStationLongitude); + } + +} + + diff --git a/telephony/java/android/telephony/cdma/package.html b/telephony/java/android/telephony/cdma/package.html new file mode 100644 index 0000000..ee4af5e --- /dev/null +++ b/telephony/java/android/telephony/cdma/package.html @@ -0,0 +1,5 @@ +<HTML> +<BODY> +Provides APIs for utilizing CDMA-specific telephony features. +</BODY> +</HTML>
\ No newline at end of file diff --git a/telephony/java/android/telephony/gsm/GsmCellLocation.java b/telephony/java/android/telephony/gsm/GsmCellLocation.java index fb9b73a..637a11c 100644 --- a/telephony/java/android/telephony/gsm/GsmCellLocation.java +++ b/telephony/java/android/telephony/gsm/GsmCellLocation.java @@ -17,14 +17,12 @@ package android.telephony.gsm; import android.os.Bundle; -import com.android.internal.telephony.Phone; import android.telephony.CellLocation; /** * Represents the cell location on a GSM phone. */ -public class GsmCellLocation extends CellLocation -{ +public class GsmCellLocation extends CellLocation { private int mLac; private int mCid; @@ -82,7 +80,7 @@ public class GsmCellLocation extends CellLocation @Override public boolean equals(Object o) { GsmCellLocation s; - + try { s = (GsmCellLocation)o; } catch (ClassCastException ex) { @@ -100,7 +98,7 @@ public class GsmCellLocation extends CellLocation public String toString() { return "["+ mLac + "," + mCid + "]"; } - + /** * Test whether two objects hold the same data values or both are null * diff --git a/telephony/java/android/telephony/gsm/SmsManager.java b/telephony/java/android/telephony/gsm/SmsManager.java index c63b530..cdd707e 100644 --- a/telephony/java/android/telephony/gsm/SmsManager.java +++ b/telephony/java/android/telephony/gsm/SmsManager.java @@ -17,28 +17,35 @@ package android.telephony.gsm; import android.app.PendingIntent; -import android.os.RemoteException; -import android.os.IServiceManager; -import android.os.ServiceManager; -import android.os.ServiceManagerNative; -import android.text.TextUtils; - -import com.android.internal.telephony.gsm.EncodeException; -import com.android.internal.telephony.gsm.GsmAlphabet; -import com.android.internal.telephony.gsm.ISms; -import com.android.internal.telephony.gsm.SimConstants; -import com.android.internal.telephony.gsm.SmsRawData; import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; + /** * Manages SMS operations such as sending data, text, and pdu SMS messages. * Get this object by calling the static method SmsManager.getDefault(). + * @deprecated Replaced by android.telephony.SmsManager that supports both GSM and CDMA. */ -public final class SmsManager { +@Deprecated public final class SmsManager { private static SmsManager sInstance; + private android.telephony.SmsManager mSmsMgrProxy; + + /** Get the default instance of the SmsManager + * + * @return the default instance of the SmsManager + * @deprecated Use android.telephony.SmsManager. + */ + @Deprecated + public static final SmsManager getDefault() { + if (sInstance == null) { + sInstance = new SmsManager(); + } + return sInstance; + } + + private SmsManager() { + mSmsMgrProxy = android.telephony.SmsManager.getDefault(); + } /** * Send a text based SMS. @@ -55,28 +62,21 @@ public final class SmsManager { * <code>RESULT_ERROR_RADIO_OFF</code> * <code>RESULT_ERROR_NULL_PDU</code>. * The per-application based SMS control checks sentIntent. If sentIntent - * is NULL the caller will be checked against all unknown applicaitons, + * is NULL the caller will be checked against all unknown applications, * which cause smaller number of SMS to be sent in checking period. * @param deliveryIntent if not NULL this <code>PendingIntent</code> is * broadcast when the message is delivered to the recipient. The * raw pdu of the status report is in the extended data ("pdu"). * * @throws IllegalArgumentException if destinationAddress or text are empty + * @deprecated Use android.telephony.SmsManager. */ - public void sendTextMessage( + @Deprecated + public final void sendTextMessage( String destinationAddress, String scAddress, String text, PendingIntent sentIntent, PendingIntent deliveryIntent) { - if (TextUtils.isEmpty(destinationAddress)) { - throw new IllegalArgumentException("Invalid destinationAddress"); - } - - if (TextUtils.isEmpty(text)) { - throw new IllegalArgumentException("Invalid message body"); - } - - SmsMessage.SubmitPdu pdus = SmsMessage.getSubmitPdu( - scAddress, destinationAddress, text, (deliveryIntent != null)); - sendRawPdu(pdus.encodedScAddress, pdus.encodedMessage, sentIntent, deliveryIntent); + mSmsMgrProxy.sendTextMessage(destinationAddress, scAddress, text, + sentIntent, deliveryIntent); } /** @@ -86,55 +86,24 @@ public final class SmsManager { * @param text the original message. Must not be null. * @return an <code>ArrayList</code> of strings that, in order, * comprise the original message + * @deprecated Use android.telephony.SmsManager. */ - public ArrayList<String> divideMessage(String text) { - int size = text.length(); - int[] params = SmsMessage.calculateLength(text, false); - /* SmsMessage.calculateLength returns an int[4] with: - * int[0] being the number of SMS's required, - * int[1] the number of code units used, - * int[2] is the number of code units remaining until the next message. - * int[3] is the encoding type that should be used for the message. - */ - int messageCount = params[0]; - int encodingType = params[3]; - ArrayList<String> result = new ArrayList<String>(messageCount); - - int start = 0; - int limit; - - if (messageCount > 1) { - limit = (encodingType == SmsMessage.ENCODING_7BIT) ? - SmsMessage.MAX_USER_DATA_SEPTETS_WITH_HEADER : - SmsMessage.MAX_USER_DATA_BYTES_WITH_HEADER; - } else { - limit = (encodingType == SmsMessage.ENCODING_7BIT) ? - SmsMessage.MAX_USER_DATA_SEPTETS : SmsMessage.MAX_USER_DATA_BYTES; - } - - try { - while (start < size) { - int end = GsmAlphabet.findLimitIndex(text, start, limit, encodingType); - result.add(text.substring(start, end)); - start = end; - } - } catch (EncodeException e) { - // ignore it. - } - return result; + @Deprecated + public final ArrayList<String> divideMessage(String text) { + return mSmsMgrProxy.divideMessage(text); } /** * Send a multi-part text based SMS. The callee should have already * divided the message into correctly sized parts by calling * <code>divideMessage</code>. - * + * * @param destinationAddress the address to send the message to * @param scAddress is the service center address or null to use * the current default SMSC * @param parts an <code>ArrayList</code> of strings that, in order, * comprise the original message - * @param sentIntents if not null, an <code>ArrayList</code> of + * @param sentIntents if not null, an <code>ArrayList</code> of * <code>PendingIntent</code>s (one for each message part) that is * broadcast when the corresponding message part has been sent. * The result code will be <code>Activity.RESULT_OK<code> for success, @@ -145,44 +114,21 @@ public final class SmsManager { * The per-application based SMS control checks sentIntent. If sentIntent * is NULL the caller will be checked against all unknown applicaitons, * which cause smaller number of SMS to be sent in checking period. - * @param deliveryIntents if not null, an <code>ArrayList</code> of + * @param deliveryIntents if not null, an <code>ArrayList</code> of * <code>PendingIntent</code>s (one for each message part) that is * broadcast when the corresponding message part has been delivered * to the recipient. The raw pdu of the status report is in the * extended data ("pdu"). + * + * @throws IllegalArgumentException if destinationAddress or data are empty + * @deprecated Use android.telephony.SmsManager. */ - public void sendMultipartTextMessage( + @Deprecated + public final void sendMultipartTextMessage( String destinationAddress, String scAddress, ArrayList<String> parts, ArrayList<PendingIntent> sentIntents, ArrayList<PendingIntent> deliveryIntents) { - if (TextUtils.isEmpty(destinationAddress)) { - throw new IllegalArgumentException("Invalid destinationAddress"); - } - if (parts == null || parts.size() < 1) { - throw new IllegalArgumentException("Invalid message body"); - } - - if (parts.size() > 1) { - try { - ISms simISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); - if (simISms != null) { - simISms.sendMultipartText(destinationAddress, scAddress, parts, - sentIntents, deliveryIntents); - } - } catch (RemoteException ex) { - // ignore it - } - } else { - PendingIntent sentIntent = null; - PendingIntent deliveryIntent = null; - if (sentIntents != null && sentIntents.size() > 0) { - sentIntent = sentIntents.get(0); - } - if (deliveryIntents != null && deliveryIntents.size() > 0) { - deliveryIntent = deliveryIntents.get(0); - } - sendTextMessage(destinationAddress, scAddress, parts.get(0), - sentIntent, deliveryIntent); - } + mSmsMgrProxy.sendMultipartTextMessage(destinationAddress, scAddress, parts, + sentIntents, deliveryIntents); } /** @@ -208,70 +154,14 @@ public final class SmsManager { * raw pdu of the status report is in the extended data ("pdu"). * * @throws IllegalArgumentException if destinationAddress or data are empty + * @deprecated Use android.telephony.SmsManager. */ - public void sendDataMessage( + @Deprecated + public final void sendDataMessage( String destinationAddress, String scAddress, short destinationPort, byte[] data, PendingIntent sentIntent, PendingIntent deliveryIntent) { - if (TextUtils.isEmpty(destinationAddress)) { - throw new IllegalArgumentException("Invalid destinationAddress"); - } - - if (data == null || data.length == 0) { - throw new IllegalArgumentException("Invalid message data"); - } - - SmsMessage.SubmitPdu pdus = SmsMessage.getSubmitPdu(scAddress, destinationAddress, - destinationPort, data, (deliveryIntent != null)); - sendRawPdu(pdus.encodedScAddress, pdus.encodedMessage, sentIntent, deliveryIntent); - } - - /** - * Send a raw SMS PDU. - * - * @param smsc the SMSC to send the message through, or NULL for the - * default SMSC - * @param pdu the raw PDU to send - * @param sentIntent if not NULL this <code>PendingIntent</code> is - * broadcast when the message is sucessfully sent, or failed. - * The result code will be <code>Activity.RESULT_OK<code> for success, - * or one of these errors: - * <code>RESULT_ERROR_GENERIC_FAILURE</code> - * <code>RESULT_ERROR_RADIO_OFF</code> - * <code>RESULT_ERROR_NULL_PDU</code>. - * The per-application based SMS control checks sentIntent. If sentIntent - * is NULL the caller will be checked against all unknown applicaitons, - * which cause smaller number of SMS to be sent in checking period. - * @param deliveryIntent if not NULL this <code>PendingIntent</code> is - * broadcast when the message is delivered to the recipient. The - * raw pdu of the status report is in the extended data ("pdu"). - * - */ - private void sendRawPdu(byte[] smsc, byte[] pdu, PendingIntent sentIntent, - PendingIntent deliveryIntent) { - try { - ISms simISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); - if (simISms != null) { - simISms.sendRawPdu(smsc, pdu, sentIntent, deliveryIntent); - } - } catch (RemoteException ex) { - // ignore it - } - } - - /** - * Get the default instance of the SmsManager - * - * @return the default instance of the SmsManager - */ - public static SmsManager getDefault() { - if (sInstance == null) { - sInstance = new SmsManager(); - } - return sInstance; - } - - private SmsManager() { - // nothing to see here + mSmsMgrProxy.sendDataMessage(destinationAddress, scAddress, destinationPort, + data, sentIntent, deliveryIntent); } /** @@ -282,22 +172,12 @@ public final class SmsManager { * @param status message status (STATUS_ON_SIM_READ, STATUS_ON_SIM_UNREAD, * STATUS_ON_SIM_SENT, STATUS_ON_SIM_UNSENT) * @return true for success - * + * @deprecated Use android.telephony.SmsManager. * {@hide} */ - public boolean copyMessageToSim(byte[] smsc, byte[] pdu, int status) { - boolean success = false; - - try { - ISms simISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); - if (simISms != null) { - success = simISms.copyMessageToSimEf(status, pdu, smsc); - } - } catch (RemoteException ex) { - // ignore it - } - - return success; + @Deprecated + public final boolean copyMessageToSim(byte[] smsc, byte[] pdu, int status) { + return mSmsMgrProxy.copyMessageToIcc(smsc, pdu, status); } /** @@ -305,26 +185,12 @@ public final class SmsManager { * * @param messageIndex is the record index of the message on SIM * @return true for success - * + * @deprecated Use android.telephony.SmsManager. * {@hide} */ - public boolean - deleteMessageFromSim(int messageIndex) { - boolean success = false; - byte[] pdu = new byte[SimConstants.SMS_RECORD_LENGTH-1]; - Arrays.fill(pdu, (byte)0xff); - - try { - ISms simISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); - if (simISms != null) { - success = simISms.updateMessageOnSimEf(messageIndex, - STATUS_ON_SIM_FREE, pdu); - } - } catch (RemoteException ex) { - // ignore it - } - - return success; + @Deprecated + public final boolean deleteMessageFromSim(int messageIndex) { + return mSmsMgrProxy.deleteMessageFromIcc(messageIndex); } /** @@ -336,97 +202,59 @@ public final class SmsManager { * STATUS_ON_SIM_UNSENT, STATUS_ON_SIM_FREE) * @param pdu the raw PDU to store * @return true for success - * + * @deprecated Use android.telephony.SmsManager. * {@hide} */ - public boolean updateMessageOnSim(int messageIndex, int newStatus, - byte[] pdu) { - boolean success = false; - - try { - ISms simISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); - if (simISms != null) { - success = simISms.updateMessageOnSimEf(messageIndex, newStatus, pdu); - } - } catch (RemoteException ex) { - // ignore it - } - - return success; + @Deprecated + public final boolean updateMessageOnSim(int messageIndex, int newStatus, byte[] pdu) { + return mSmsMgrProxy.updateMessageOnIcc(messageIndex, newStatus, pdu); } - /** * Retrieves all messages currently stored on SIM. - * * @return <code>ArrayList</code> of <code>SmsMessage</code> objects - * + * @deprecated Use android.telephony.SmsManager. * {@hide} */ - public ArrayList<SmsMessage> getAllMessagesFromSim() { - List<SmsRawData> records = null; + @Deprecated + public final ArrayList<android.telephony.SmsMessage> getAllMessagesFromSim() { + return mSmsMgrProxy.getAllMessagesFromIcc(); + } - try { - ISms simISms = ISms.Stub.asInterface(ServiceManager.getService("isms")); - if (simISms != null) { - records = simISms.getAllMessagesFromSimEf(); - } - } catch (RemoteException ex) { - // ignore it - } - - return createMessageListFromRawRecords(records); - } + /** Free space (TS 51.011 10.5.3). + * @deprecated Use android.telephony.SmsManager. */ + @Deprecated static public final int STATUS_ON_SIM_FREE = 0; - /** - * Create a list of <code>SmsMessage</code>s from a list of RawSmsData - * records returned by <code>getAllMessagesFromSim()</code> - * - * @param records SMS EF records, returned by - * <code>getAllMessagesFromSim</code> - * @return <code>ArrayList</code> of <code>SmsMessage</code> objects. - */ - private ArrayList<SmsMessage> createMessageListFromRawRecords(List records) { - ArrayList<SmsMessage> messages = new ArrayList<SmsMessage>(); - if (records != null) { - int count = records.size(); - for (int i = 0; i < count; i++) { - SmsRawData data = (SmsRawData)records.get(i); - // List contains all records, including "free" records (null) - if (data != null) { - SmsMessage sms = - SmsMessage.createFromEfRecord(i+1, data.getBytes()); - messages.add(sms); - } - } - } - return messages; - } + /** Received and read (TS 51.011 10.5.3). + * @deprecated Use android.telephony.SmsManager. */ + @Deprecated static public final int STATUS_ON_SIM_READ = 1; - /** Free space (TS 51.011 10.5.3). */ - static public final int STATUS_ON_SIM_FREE = 0; + /** Received and unread (TS 51.011 10.5.3). + * @deprecated Use android.telephony.SmsManager. */ + @Deprecated static public final int STATUS_ON_SIM_UNREAD = 3; - /** Received and read (TS 51.011 10.5.3). */ - static public final int STATUS_ON_SIM_READ = 1; + /** Stored and sent (TS 51.011 10.5.3). + * @deprecated Use android.telephony.SmsManager. */ + @Deprecated static public final int STATUS_ON_SIM_SENT = 5; - /** Received and unread (TS 51.011 10.5.3). */ - static public final int STATUS_ON_SIM_UNREAD = 3; + /** Stored and unsent (TS 51.011 10.5.3). + * @deprecated Use android.telephony.SmsManager. */ + @Deprecated static public final int STATUS_ON_SIM_UNSENT = 7; - /** Stored and sent (TS 51.011 10.5.3). */ - static public final int STATUS_ON_SIM_SENT = 5; + /** Generic failure cause + * @deprecated Use android.telephony.SmsManager. */ + @Deprecated static public final int RESULT_ERROR_GENERIC_FAILURE = 1; - /** Stored and unsent (TS 51.011 10.5.3). */ - static public final int STATUS_ON_SIM_UNSENT = 7; + /** Failed because radio was explicitly turned off + * @deprecated Use android.telephony.SmsManager. */ + @Deprecated static public final int RESULT_ERROR_RADIO_OFF = 2; + /** Failed because no pdu provided + * @deprecated Use android.telephony.SmsManager. */ + @Deprecated static public final int RESULT_ERROR_NULL_PDU = 3; - // SMS send failure result codes + /** Failed because service is currently unavailable + * @deprecated Use android.telephony.SmsManager. */ + @Deprecated static public final int RESULT_ERROR_NO_SERVICE = 4; - /** Generic failure cause */ - static public final int RESULT_ERROR_GENERIC_FAILURE = 1; - /** Failed because radio was explicitly turned off */ - static public final int RESULT_ERROR_RADIO_OFF = 2; - /** Failed because no pdu provided */ - static public final int RESULT_ERROR_NULL_PDU = 3; - /** Failed because service is currently unavailable */ - static public final int RESULT_ERROR_NO_SERVICE = 4; } diff --git a/telephony/java/android/telephony/gsm/SmsMessage.java b/telephony/java/android/telephony/gsm/SmsMessage.java index c2e0165..0928ddf 100644 --- a/telephony/java/android/telephony/gsm/SmsMessage.java +++ b/telephony/java/android/telephony/gsm/SmsMessage.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2006 The Android Open Source Project + * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,327 +16,117 @@ package android.telephony.gsm; -import android.telephony.PhoneNumberUtils; -import android.util.Config; -import android.util.Log; -import android.telephony.PhoneNumberUtils; -import android.text.format.Time; +import android.os.Parcel; +import android.telephony.TelephonyManager; -import com.android.internal.telephony.gsm.EncodeException; -import com.android.internal.telephony.gsm.GsmAlphabet; -import com.android.internal.telephony.gsm.SimUtils; -import com.android.internal.telephony.gsm.SmsHeader; +import com.android.internal.telephony.GsmAlphabet; +import com.android.internal.telephony.EncodeException; +import com.android.internal.telephony.SmsMessageBase; +import com.android.internal.telephony.SmsMessageBase.SubmitPduBase; -import java.io.ByteArrayOutputStream; -import java.io.UnsupportedEncodingException; import java.util.Arrays; -class SmsAddress { - // From TS 23.040 9.1.2.5 and TS 24.008 table 10.5.118 - static final int TON_UNKNOWN = 0; +import static android.telephony.TelephonyManager.PHONE_TYPE_CDMA; - static final int TON_INTERNATIONAL = 1; - static final int TON_NATIONAL = 2; - - static final int TON_NETWORK = 3; - - static final int TON_SUBSCRIBER = 4; - - static final int TON_ALPHANUMERIC = 5; - - static final int TON_APPREVIATED = 6; - - static final int OFFSET_ADDRESS_LENGTH = 0; - - static final int OFFSET_TOA = 1; - - static final int OFFSET_ADDRESS_VALUE = 2; - - int ton; - - String address; - - byte[] origBytes; +/** + * A Short Message Service message. + * @deprecated Replaced by android.telephony.SmsMessage that supports both GSM and CDMA. + */ +@Deprecated +public class SmsMessage { + private static final boolean LOCAL_DEBUG = true; + private static final String LOG_TAG = "SMS"; /** - * New SmsAddress from TS 23.040 9.1.2.5 Address Field - * - * @param offset the offset of the Address-Length byte - * @param length the length in bytes rounded up, e.g. "2 + - * (addressLength + 1) / 2" + * SMS Class enumeration. + * See TS 23.038. + * @deprecated Use android.telephony.SmsMessage. */ - - SmsAddress(byte[] data, int offset, int length) { - origBytes = new byte[length]; - System.arraycopy(data, offset, origBytes, 0, length); - - // addressLength is the count of semi-octets, not bytes - int addressLength = origBytes[OFFSET_ADDRESS_LENGTH] & 0xff; - - int toa = origBytes[OFFSET_TOA] & 0xff; - ton = 0x7 & (toa >> 4); - - // TOA must have its high bit set - if ((toa & 0x80) != 0x80) { - throw new RuntimeException("Invalid TOA - high bit must be set"); - } - - if (isAlphanumeric()) { - // An alphanumeric address - int countSeptets = addressLength * 4 / 7; - - address = GsmAlphabet.gsm7BitPackedToString(origBytes, - OFFSET_ADDRESS_VALUE, countSeptets); - } else { - // TS 23.040 9.1.2.5 says - // that "the MS shall interpret reserved values as 'Unknown' - // but shall store them exactly as received" - - byte lastByte = origBytes[length - 1]; - - if ((addressLength & 1) == 1) { - // Make sure the final unused BCD digit is 0xf - origBytes[length - 1] |= 0xf0; - } - address = PhoneNumberUtils.calledPartyBCDToString(origBytes, - OFFSET_TOA, length - OFFSET_TOA); - - // And restore origBytes - origBytes[length - 1] = lastByte; - } - } - - public String getAddressString() { - return address; + @Deprecated + public enum MessageClass{ + UNKNOWN, CLASS_0, CLASS_1, CLASS_2, CLASS_3; } - /** - * Returns true if this is an alphanumeric addres + /** Unknown encoding scheme (see TS 23.038) + * @deprecated Use android.telephony.SmsMessage. */ - public boolean isAlphanumeric() { - return ton == TON_ALPHANUMERIC; - } - - public boolean isNetworkSpecific() { - return ton == TON_NETWORK; - } + @Deprecated public static final int ENCODING_UNKNOWN = 0; - /** - * Returns true of this is a valid CPHS voice message waiting indicator - * address + /** 7-bit encoding scheme (see TS 23.038) + * @deprecated Use android.telephony.SmsMessage. */ - public boolean isCphsVoiceMessageIndicatorAddress() { - // CPHS-style MWI message - // See CPHS 4.7 B.4.2.1 - // - // Basically: - // - // - Originating address should be 4 bytes long and alphanumeric - // - Decode will result with two chars: - // - Char 1 - // 76543210 - // ^ set/clear indicator (0 = clear) - // ^^^ type of indicator (000 = voice) - // ^^^^ must be equal to 0001 - // - Char 2: - // 76543210 - // ^ line number (0 = line 1) - // ^^^^^^^ set to 0 - // - // Remember, since the alpha address is stored in 7-bit compact form, - // the "line number" is really the top bit of the first address value - // byte - - return (origBytes[OFFSET_ADDRESS_LENGTH] & 0xff) == 4 - && isAlphanumeric() && (origBytes[OFFSET_TOA] & 0x0f) == 0; - } + @Deprecated public static final int ENCODING_7BIT = 1; - /** - * Returns true if this is a valid CPHS voice message waiting indicator - * address indicating a "set" of "indicator 1" of type "voice message - * waiting" + /** 8-bit encoding scheme (see TS 23.038) + * @deprecated Use android.telephony.SmsMessage. */ - public boolean isCphsVoiceMessageSet() { - // 0x11 means "set" "voice message waiting" "indicator 1" - return isCphsVoiceMessageIndicatorAddress() - && (origBytes[OFFSET_ADDRESS_VALUE] & 0xff) == 0x11; + @Deprecated public static final int ENCODING_8BIT = 2; - } - - /** - * Returns true if this is a valid CPHS voice message waiting indicator - * address indicationg a "clear" of "indicator 1" of type "voice message - * waiting" + /** 16-bit encoding scheme (see TS 23.038) + * @deprecated Use android.telephony.SmsMessage. */ - public boolean isCphsVoiceMessageClear() { - // 0x10 means "clear" "voice message waiting" "indicator 1" - return isCphsVoiceMessageIndicatorAddress() - && (origBytes[OFFSET_ADDRESS_VALUE] & 0xff) == 0x10; - - } - - public boolean couldBeEmailGateway() { - // Some carriers seems to send email gateway messages in this form: - // from: an UNKNOWN TON, 3 or 4 digits long, beginning with a 5 - // PID: 0x00, Data coding scheme 0x03 - // So we just attempt to treat any message from an address length <= 4 - // as an email gateway - - return address.length() <= 4; - } - -} - -/** - * A Short Message Service message. - * - */ -public class SmsMessage { - static final String LOG_TAG = "GSM"; + @Deprecated public static final int ENCODING_16BIT = 3; - /** - * SMS Class enumeration. - * See TS 23.038. - * + /** The maximum number of payload bytes per message + * @deprecated Use android.telephony.SmsMessage. */ - public enum MessageClass { - UNKNOWN, CLASS_0, CLASS_1, CLASS_2, CLASS_3; - } - - /** Unknown encoding scheme (see TS 23.038) */ - public static final int ENCODING_UNKNOWN = 0; - /** 7-bit encoding scheme (see TS 23.038) */ - public static final int ENCODING_7BIT = 1; - /** 8-bit encoding scheme (see TS 23.038) */ - public static final int ENCODING_8BIT = 2; - /** 16-bit encoding scheme (see TS 23.038) */ - public static final int ENCODING_16BIT = 3; - - /** The maximum number of payload bytes per message */ - public static final int MAX_USER_DATA_BYTES = 140; + @Deprecated public static final int MAX_USER_DATA_BYTES = 140; /** * The maximum number of payload bytes per message if a user data header * is present. This assumes the header only contains the * CONCATENATED_8_BIT_REFERENCE element. - * + * + * @deprecated Use android.telephony.SmsMessage. * @hide pending API Council approval to extend the public API */ - static final int MAX_USER_DATA_BYTES_WITH_HEADER = 134; + @Deprecated public static final int MAX_USER_DATA_BYTES_WITH_HEADER = 134; - /** The maximum number of payload septets per message */ - public static final int MAX_USER_DATA_SEPTETS = 160; + /** The maximum number of payload septets per message + * @deprecated Use android.telephony.SmsMessage. + */ + @Deprecated public static final int MAX_USER_DATA_SEPTETS = 160; /** * The maximum number of payload septets per message if a user data header * is present. This assumes the header only contains the * CONCATENATED_8_BIT_REFERENCE element. + * @deprecated Use android.telephony.SmsMessage. */ - public static final int MAX_USER_DATA_SEPTETS_WITH_HEADER = 153; - - /** The address of the SMSC. May be null */ - String scAddress; - - /** The address of the sender */ - SmsAddress originatingAddress; - - /** The message body as a string. May be null if the message isn't text */ - String messageBody; - - String pseudoSubject; - - /** Non-null this is an email gateway message */ - String emailFrom; - - /** Non-null if this is an email gateway message */ - String emailBody; - - boolean isEmail; - - long scTimeMillis; + @Deprecated public static final int MAX_USER_DATA_SEPTETS_WITH_HEADER = 153; - /** The raw PDU of the message */ - byte[] mPdu; - - /** The raw bytes for the user data section of the message */ - byte[] userData; - - SmsHeader userDataHeader; - - /** - * TP-Message-Type-Indicator - * 9.2.3 - */ - int mti; - - /** TP-Protocol-Identifier (TP-PID) */ - int protocolIdentifier; - - // TP-Data-Coding-Scheme - // see TS 23.038 - int dataCodingScheme; - - // TP-Reply-Path - // e.g. 23.040 9.2.2.1 - boolean replyPathPresent = false; - - // "Message Marked for Automatic Deletion Group" - // 23.038 Section 4 - boolean automaticDeletion; - - // "Message Waiting Indication Group" - // 23.038 Section 4 - private boolean isMwi; - - private boolean mwiSense; - - private boolean mwiDontStore; - - MessageClass messageClass; - - /** - * Indicates status for messages stored on the SIM. - */ - int statusOnSim = -1; - - /** - * Record index of message in the EF. + /** Contains actual SmsMessage. Only public for debugging and for framework layer. + * @deprecated Use android.telephony.SmsMessage. + * {@hide} */ - int indexOnSim = -1; - - /** TP-Message-Reference - Message Reference of sent message. @hide */ - public int messageRef; - - /** True if Status Report is for SMS-SUBMIT; false for SMS-COMMAND. */ - boolean forSubmit; + @Deprecated public SmsMessageBase mWrappedSmsMessage; - /** The address of the receiver. */ - SmsAddress recipientAddress; - - /** Time when SMS-SUBMIT was delivered from SC to MSE. */ - long dischargeTimeMillis; - - /** - * TP-Status - status of a previously submitted SMS. - * This field applies to SMS-STATUS-REPORT messages. 0 indicates success; - * see TS 23.040, 9.2.3.15 for description of other possible values. - */ - int status; + /** @deprecated Use android.telephony.SmsMessage. */ + @Deprecated + public static class SubmitPdu { + /** @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public byte[] encodedScAddress; // Null if not applicable. + /** @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public byte[] encodedMessage; - /** - * TP-Status - status of a previously submitted SMS. - * This field is true iff the message is a SMS-STATUS-REPORT message. - */ - boolean isStatusReportMessage = false; + //Constructor + /** @deprecated Use android.telephony.SmsMessage. */ + @Deprecated + public SubmitPdu() { + } - /** - * This class represents the encoded form of an outgoing SMS. - */ - public static class SubmitPdu { - public byte[] encodedScAddress; // Null if not applicable. - public byte[] encodedMessage; + /** @deprecated Use android.telephony.SmsMessage. + * {@hide} + */ + @Deprecated + protected SubmitPdu(SubmitPduBase spb) { + this.encodedMessage = spb.encodedMessage; + this.encodedScAddress = spb.encodedScAddress; + } + /** @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public String toString() { return "SubmitPdu: encodedScAddress = " + Arrays.toString(encodedScAddress) @@ -345,18 +135,33 @@ public class SmsMessage { } } + // Constructor + /** @deprecated Use android.telephony.SmsMessage. */ + @Deprecated + public SmsMessage() { + this(getSmsFacility()); + } + + private SmsMessage(SmsMessageBase smb) { + mWrappedSmsMessage = smb; + } + /** * Create an SmsMessage from a raw PDU. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public static SmsMessage createFromPdu(byte[] pdu) { - try { - SmsMessage msg = new SmsMessage(); - msg.parsePdu(pdu); - return msg; - } catch (RuntimeException ex) { - Log.e(LOG_TAG, "SMS PDU parsing failed: ", ex); - return null; + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.createFromPdu(pdu); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.createFromPdu(pdu); } + + return new SmsMessage(wrappedMessage); } /** @@ -364,38 +169,70 @@ public class SmsMessage { * +CMT unsolicited response (PDU mode, of course) * +CMT: [<alpha>],<length><CR><LF><pdu> * - * Only public for debugging - * + * Only public for debugging and for RIL + * @deprecated Use android.telephony.SmsMessage. * {@hide} */ - /* package */ public static SmsMessage newFromCMT(String[] lines) { - try { - SmsMessage msg = new SmsMessage(); - msg.parsePdu(SimUtils.hexStringToBytes(lines[1])); - return msg; - } catch (RuntimeException ex) { - Log.e(LOG_TAG, "SMS PDU parsing failed: ", ex); - return null; + @Deprecated + public static SmsMessage newFromCMT(String[] lines){ + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.newFromCMT(lines); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.newFromCMT(lines); } + + return new SmsMessage(wrappedMessage); } - /* pacakge */ static SmsMessage newFromCMTI(String line) { - // the thinking here is not to read the message immediately - // FTA test case - Log.e(LOG_TAG, "newFromCMTI: not yet supported"); - return null; + /** @deprecated Use android.telephony.SmsMessage. + * @hide */ + @Deprecated + protected static SmsMessage newFromCMTI(String line) { + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.newFromCMTI(line); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.newFromCMTI(line); + } + + return new SmsMessage(wrappedMessage); } - /** @hide */ - /* package */ public static SmsMessage newFromCDS(String line) { - try { - SmsMessage msg = new SmsMessage(); - msg.parsePdu(SimUtils.hexStringToBytes(line)); - return msg; - } catch (RuntimeException ex) { - Log.e(LOG_TAG, "CDS SMS PDU parsing failed: ", ex); - return null; + /** @deprecated Use android.telephony.SmsMessage. + * @hide */ + @Deprecated + public static SmsMessage newFromCDS(String line) { + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.newFromCDS(line); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.newFromCDS(line); + } + + return new SmsMessage(wrappedMessage); + } + + /** @deprecated Use android.telephony.SmsMessage. + * @hide */ + @Deprecated + public static SmsMessage newFromParcel(Parcel p) { + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); + + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.newFromParcel(p); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.newFromParcel(p); } + + return new SmsMessage(wrappedMessage); } /** @@ -405,51 +242,40 @@ public class SmsMessage { * returned by SmsManager.getAllMessagesFromSim + 1. * @param data Record data. * @return An SmsMessage representing the record. - * + * + * @deprecated Use android.telephony.SmsMessage. * @hide */ + @Deprecated public static SmsMessage createFromEfRecord(int index, byte[] data) { - try { - SmsMessage msg = new SmsMessage(); - - msg.indexOnSim = index; - - // First byte is status: RECEIVED_READ, RECEIVED_UNREAD, STORED_SENT, - // or STORED_UNSENT - // See TS 51.011 10.5.3 - if ((data[0] & 1) == 0) { - Log.w(LOG_TAG, - "SMS parsing failed: Trying to parse a free record"); - return null; - } else { - msg.statusOnSim = data[0] & 0x07; - } + SmsMessageBase wrappedMessage; + int activePhone = TelephonyManager.getDefault().getPhoneType(); - int size = data.length - 1; - - // Note: Data may include trailing FF's. That's OK; message - // should still parse correctly. - byte[] pdu = new byte[size]; - System.arraycopy(data, 1, pdu, 0, size); - msg.parsePdu(pdu); - return msg; - } catch (RuntimeException ex) { - Log.e(LOG_TAG, "SMS PDU parsing failed: ", ex); - return null; + if (PHONE_TYPE_CDMA == activePhone) { + wrappedMessage = com.android.internal.telephony.cdma.SmsMessage.createFromEfRecord( + index, data); + } else { + wrappedMessage = com.android.internal.telephony.gsm.SmsMessage.createFromEfRecord( + index, data); } + + return new SmsMessage(wrappedMessage); } /** * Get the TP-Layer-Length for the given SMS-SUBMIT PDU Basically, the * length in bytes (not hex chars) less the SMSC header + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public static int getTPLayerLengthForPDU(String pdu) { - int len = pdu.length() / 2; - int smscLen = 0; + int activePhone = TelephonyManager.getDefault().getPhoneType(); - smscLen = Integer.parseInt(pdu.substring(0, 2), 16); - - return len - smscLen - 1; + if (PHONE_TYPE_CDMA == activePhone) { + return com.android.internal.telephony.cdma.SmsMessage.getTPLayerLengthForPDU(pdu); + } else { + return com.android.internal.telephony.gsm.SmsMessage.getTPLayerLengthForPDU(pdu); + } } /** @@ -466,7 +292,9 @@ public class SmsMessage { * the number of code units used, and int[2] is the number of code * units remaining until the next message. int[3] is the encoding * type that should be used for the message. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public static int[] calculateLength(CharSequence messageBody, boolean use7bitOnly) { int ret[] = new int[4]; @@ -517,10 +345,10 @@ public class SmsMessage { * units remaining until the next message. int[3] is the encoding * type that should be used for the message. */ + @Deprecated public static int[] calculateLength(String messageBody, boolean use7bitOnly) { return calculateLength((CharSequence)messageBody, use7bitOnly); } - /** * Get an SMS-SUBMIT PDU for a destination address and a message @@ -529,92 +357,27 @@ public class SmsMessage { * @return a <code>SubmitPdu</code> containing the encoded SC * address, if applicable, and the encoded message. * Returns null on encode error. + * @deprecated Use android.telephony.SmsMessage. * @hide */ + @Deprecated public static SubmitPdu getSubmitPdu(String scAddress, String destinationAddress, String message, boolean statusReportRequested, byte[] header) { + SubmitPduBase spb; + int activePhone = TelephonyManager.getDefault().getPhoneType(); - // Perform null parameter checks. - if (message == null || destinationAddress == null) { - return null; - } - - SubmitPdu ret = new SubmitPdu(); - // MTI = SMS-SUBMIT, UDHI = header != null - byte mtiByte = (byte)(0x01 | (header != null ? 0x40 : 0x00)); - ByteArrayOutputStream bo = getSubmitPduHead( - scAddress, destinationAddress, mtiByte, - statusReportRequested, ret); - - try { - // First, try encoding it with the GSM alphabet - - // User Data (and length) - byte[] userData = GsmAlphabet.stringToGsm7BitPackedWithHeader(message, header); - - if ((0xff & userData[0]) > MAX_USER_DATA_SEPTETS) { - // Message too long - return null; - } - - // TP-Data-Coding-Scheme - // Default encoding, uncompressed - // To test writing messages to the SIM card, change this value 0x00 to 0x12, which - // means "bits 1 and 0 contain message class, and the class is 2". Note that this - // takes effect for the sender. In other words, messages sent by the phone with this - // change will end up on the receiver's SIM card. You can then send messages to - // yourself (on a phone with this change) and they'll end up on the SIM card. - bo.write(0x00); - - // (no TP-Validity-Period) - - bo.write(userData, 0, userData.length); - } catch (EncodeException ex) { - byte[] userData, textPart; - // Encoding to the 7-bit alphabet failed. Let's see if we can - // send it as a UCS-2 encoded message - - try { - textPart = message.getBytes("utf-16be"); - } catch (UnsupportedEncodingException uex) { - Log.e(LOG_TAG, - "Implausible UnsupportedEncodingException ", - uex); - return null; - } - - if (header != null) { - userData = new byte[header.length + textPart.length]; - - System.arraycopy(header, 0, userData, 0, header.length); - System.arraycopy(textPart, 0, userData, header.length, textPart.length); - } else { - userData = textPart; - } - - if (userData.length > MAX_USER_DATA_BYTES) { - // Message too long - return null; - } - - // TP-Data-Coding-Scheme - // Class 3, UCS-2 encoding, uncompressed - bo.write(0x0b); - - // (no TP-Validity-Period) - - // TP-UDL - bo.write(userData.length); - - bo.write(userData, 0, userData.length); + if (PHONE_TYPE_CDMA == activePhone) { + spb = com.android.internal.telephony.cdma.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, message, statusReportRequested, header); + } else { + spb = com.android.internal.telephony.gsm.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, message, statusReportRequested, header); } - ret.encodedMessage = bo.toByteArray(); - return ret; + return new SubmitPdu(spb); } - /** * Get an SMS-SUBMIT PDU for a destination address and a message * @@ -622,12 +385,23 @@ public class SmsMessage { * @return a <code>SubmitPdu</code> containing the encoded SC * address, if applicable, and the encoded message. * Returns null on encode error. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public static SubmitPdu getSubmitPdu(String scAddress, - String destinationAddress, String message, - boolean statusReportRequested) { + String destinationAddress, String message, boolean statusReportRequested) { + SubmitPduBase spb; + int activePhone = TelephonyManager.getDefault().getPhoneType(); - return getSubmitPdu(scAddress, destinationAddress, message, statusReportRequested, null); + if (PHONE_TYPE_CDMA == activePhone) { + spb = com.android.internal.telephony.cdma.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, message, statusReportRequested); + } else { + spb = com.android.internal.telephony.gsm.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, message, statusReportRequested); + } + + return new SubmitPdu(spb); } /** @@ -641,478 +415,105 @@ public class SmsMessage { * @return a <code>SubmitPdu</code> containing the encoded SC * address, if applicable, and the encoded message. * Returns null on encode error. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public static SubmitPdu getSubmitPdu(String scAddress, String destinationAddress, short destinationPort, byte[] data, boolean statusReportRequested) { - if (data.length > (MAX_USER_DATA_BYTES - 7 /* UDH size */)) { - Log.e(LOG_TAG, "SMS data message may only contain " - + (MAX_USER_DATA_BYTES - 7) + " bytes"); - return null; - } - - SubmitPdu ret = new SubmitPdu(); - ByteArrayOutputStream bo = getSubmitPduHead( - scAddress, destinationAddress, (byte) 0x41, // MTI = SMS-SUBMIT, - // TP-UDHI = true - statusReportRequested, ret); - - // TP-Data-Coding-Scheme - // No class, 8 bit data - bo.write(0x04); - - // (no TP-Validity-Period) - - // User data size - bo.write(data.length + 7); - - // User data header size - bo.write(0x06); // header is 6 octets - - // User data header, indicating the destination port - bo.write(SmsHeader.APPLICATION_PORT_ADDRESSING_16_BIT); // port - // addressing - // header - bo.write(0x04); // each port is 2 octets - bo.write((destinationPort >> 8) & 0xFF); // MSB of destination port - bo.write(destinationPort & 0xFF); // LSB of destination port - bo.write(0x00); // MSB of originating port - bo.write(0x00); // LSB of originating port - - // User data - bo.write(data, 0, data.length); - - ret.encodedMessage = bo.toByteArray(); - return ret; - } + SubmitPduBase spb; + int activePhone = TelephonyManager.getDefault().getPhoneType(); - /** - * Create the beginning of a SUBMIT PDU. This is the part of the - * SUBMIT PDU that is common to the two versions of {@link #getSubmitPdu}, - * one of which takes a byte array and the other of which takes a - * <code>String</code>. - * - * @param scAddress Service Centre address. null == use default - * @param destinationAddress the address of the destination for the message - * @param mtiByte - * @param ret <code>SubmitPdu</code> containing the encoded SC - * address, if applicable, and the encoded message - */ - private static ByteArrayOutputStream getSubmitPduHead( - String scAddress, String destinationAddress, byte mtiByte, - boolean statusReportRequested, SubmitPdu ret) { - ByteArrayOutputStream bo = new ByteArrayOutputStream( - MAX_USER_DATA_BYTES + 40); - - // SMSC address with length octet, or 0 - if (scAddress == null) { - ret.encodedScAddress = null; + if (PHONE_TYPE_CDMA == activePhone) { + spb = com.android.internal.telephony.cdma.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, destinationPort, data, statusReportRequested); } else { - ret.encodedScAddress = PhoneNumberUtils.networkPortionToCalledPartyBCDWithLength( - scAddress); - } - - // TP-Message-Type-Indicator (and friends) - if (statusReportRequested) { - // Set TP-Status-Report-Request bit. - mtiByte |= 0x20; - if (Config.LOGD) Log.d(LOG_TAG, "SMS status report requested"); - } - bo.write(mtiByte); - - // space for TP-Message-Reference - bo.write(0); - - byte[] daBytes; - - daBytes = PhoneNumberUtils.networkPortionToCalledPartyBCD(destinationAddress); - - // destination address length in BCD digits, ignoring TON byte and pad - // TODO Should be better. - bo.write((daBytes.length - 1) * 2 - - ((daBytes[daBytes.length - 1] & 0xf0) == 0xf0 ? 1 : 0)); - - // destination address - bo.write(daBytes, 0, daBytes.length); - - // TP-Protocol-Identifier - bo.write(0); - return bo; - } - - static class PduParser { - byte pdu[]; - - int cur; - - SmsHeader userDataHeader; - - byte[] userData; - - int mUserDataSeptetPadding; - - int mUserDataSize; - - PduParser(String s) { - this(SimUtils.hexStringToBytes(s)); - } - - PduParser(byte[] pdu) { - this.pdu = pdu; - cur = 0; - mUserDataSeptetPadding = 0; - } - - /** - * Parse and return the SC address prepended to SMS messages coming via - * the TS 27.005 / AT interface. Returns null on invalid address - */ - String getSCAddress() { - int len; - String ret; - - // length of SC Address - len = getByte(); - - if (len == 0) { - // no SC address - ret = null; - } else { - // SC address - try { - ret = PhoneNumberUtils - .calledPartyBCDToString(pdu, cur, len); - } catch (RuntimeException tr) { - Log.d(LOG_TAG, "invalid SC address: ", tr); - ret = null; - } - } - - cur += len; - - return ret; - } - - /** - * returns non-sign-extended byte value - */ - int getByte() { - return pdu[cur++] & 0xff; - } - - /** - * Any address except the SC address (eg, originating address) See TS - * 23.040 9.1.2.5 - */ - SmsAddress getAddress() { - SmsAddress ret; - - // "The Address-Length field is an integer representation of - // the number field, i.e. excludes any semi octet containing only - // fill bits." - // The TOA field is not included as part of this - int addressLength = pdu[cur] & 0xff; - int lengthBytes = 2 + (addressLength + 1) / 2; - - ret = new SmsAddress(pdu, cur, lengthBytes); - - cur += lengthBytes; - - return ret; - } - - /** - * Parses an SC timestamp and returns a currentTimeMillis()-style - * timestamp - */ - - long getSCTimestampMillis() { - // TP-Service-Centre-Time-Stamp - int year = SimUtils.bcdByteToInt(pdu[cur++]); - int month = SimUtils.bcdByteToInt(pdu[cur++]); - int day = SimUtils.bcdByteToInt(pdu[cur++]); - int hour = SimUtils.bcdByteToInt(pdu[cur++]); - int minute = SimUtils.bcdByteToInt(pdu[cur++]); - int second = SimUtils.bcdByteToInt(pdu[cur++]); - - // For the timezone, the most significant bit of the - // least signficant nibble is the sign byte - // (meaning the max range of this field is 79 quarter-hours, - // which is more than enough) - - byte tzByte = pdu[cur++]; - - // Mask out sign bit. - int timezoneOffset = SimUtils - .bcdByteToInt((byte) (tzByte & (~0x08))); - - timezoneOffset = ((tzByte & 0x08) == 0) ? timezoneOffset - : -timezoneOffset; - - Time time = new Time(Time.TIMEZONE_UTC); - - // It's 2006. Should I really support years < 2000? - time.year = year >= 90 ? year + 1900 : year + 2000; - time.month = month - 1; - time.monthDay = day; - time.hour = hour; - time.minute = minute; - time.second = second; - - // Timezone offset is in quarter hours. - return time.toMillis(true) - (timezoneOffset * 15 * 60 * 1000); - } - - /** - * Pulls the user data out of the PDU, and separates the payload from - * the header if there is one. - * - * @param hasUserDataHeader true if there is a user data header - * @param dataInSeptets true if the data payload is in septets instead - * of octets - * @return the number of septets or octets in the user data payload - */ - int constructUserData(boolean hasUserDataHeader, boolean dataInSeptets) - { - int offset = cur; - int userDataLength = pdu[offset++] & 0xff; - int headerSeptets = 0; - - if (hasUserDataHeader) { - int userDataHeaderLength = pdu[offset++] & 0xff; - - byte[] udh = new byte[userDataHeaderLength]; - System.arraycopy(pdu, offset, udh, 0, userDataHeaderLength); - userDataHeader = SmsHeader.parse(udh); - offset += userDataHeaderLength; - - int headerBits = (userDataHeaderLength + 1) * 8; - headerSeptets = headerBits / 7; - headerSeptets += (headerBits % 7) > 0 ? 1 : 0; - mUserDataSeptetPadding = (headerSeptets * 7) - headerBits; - } - - /* - * Here we just create the user data length to be the remainder of - * the pdu minus the user data hearder. This is because the count - * could mean the number of uncompressed sepets if the userdata is - * encoded in 7-bit. - */ - userData = new byte[pdu.length - offset]; - System.arraycopy(pdu, offset, userData, 0, userData.length); - cur = offset; - - if (dataInSeptets) { - // Return the number of septets - int count = userDataLength - headerSeptets; - // If count < 0, return 0 (means UDL was probably incorrect) - return count < 0 ? 0 : count; - } else { - // Return the number of octets - return userData.length; - } - } - - /** - * Returns the user data payload, not including the headers - * - * @return the user data payload, not including the headers - */ - byte[] getUserData() { - return userData; - } - - /** - * Returns the number of padding bits at the begining of the user data - * array before the start of the septets. - * - * @return the number of padding bits at the begining of the user data - * array before the start of the septets - */ - int getUserDataSeptetPadding() { - return mUserDataSeptetPadding; + spb = com.android.internal.telephony.gsm.SmsMessage.getSubmitPdu(scAddress, + destinationAddress, destinationPort, data, statusReportRequested); } - /** - * Returns an object representing the user data headers - * - * @return an object representing the user data headers - * - * {@hide} - */ - SmsHeader getUserDataHeader() { - return userDataHeader; - } - -/* - XXX Not sure what this one is supposed to be doing, and no one is using - it. - String getUserDataGSM8bit() { - // System.out.println("remainder of pud:" + - // HexDump.dumpHexString(pdu, cur, pdu.length - cur)); - int count = pdu[cur++] & 0xff; - int size = pdu[cur++]; - - // skip over header for now - cur += size; - - if (pdu[cur - 1] == 0x01) { - int tid = pdu[cur++] & 0xff; - int type = pdu[cur++] & 0xff; - - size = pdu[cur++] & 0xff; - - int i = cur; - - while (pdu[i++] != '\0') { - } - - int length = i - cur; - String mimeType = new String(pdu, cur, length); - - cur += length; - - if (false) { - System.out.println("tid = 0x" + HexDump.toHexString(tid)); - System.out.println("type = 0x" + HexDump.toHexString(type)); - System.out.println("header size = " + size); - System.out.println("mimeType = " + mimeType); - System.out.println("remainder of header:" + - HexDump.dumpHexString(pdu, cur, (size - mimeType.length()))); - } - - cur += size - mimeType.length(); - - // System.out.println("data count = " + count + " cur = " + cur - // + " :" + HexDump.dumpHexString(pdu, cur, pdu.length - cur)); - - MMSMessage msg = MMSMessage.parseEncoding(mContext, pdu, cur, - pdu.length - cur); - } else { - System.out.println(new String(pdu, cur, pdu.length - cur - 1)); - } - - return SimUtils.bytesToHexString(pdu); - } -*/ - - /** - * Interprets the user data payload as pack GSM 7bit characters, and - * decodes them into a String. - * - * @param septetCount the number of septets in the user data payload - * @return a String with the decoded characters - */ - String getUserDataGSM7Bit(int septetCount) { - String ret; - - ret = GsmAlphabet.gsm7BitPackedToString(pdu, cur, septetCount, - mUserDataSeptetPadding); - - cur += (septetCount * 7) / 8; - - return ret; - } - - /** - * Interprets the user data payload as UCS2 characters, and - * decodes them into a String. - * - * @param byteCount the number of bytes in the user data payload - * @return a String with the decoded characters - */ - String getUserDataUCS2(int byteCount) { - String ret; - - try { - ret = new String(pdu, cur, byteCount, "utf-16"); - } catch (UnsupportedEncodingException ex) { - ret = ""; - Log.e(LOG_TAG, "implausible UnsupportedEncodingException", ex); - } - - cur += byteCount; - return ret; - } - - boolean moreDataPresent() { - return (pdu.length > cur); - } + return new SubmitPdu(spb); } /** * Returns the address of the SMS service center that relayed this message * or null if there is none. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public String getServiceCenterAddress() { - return scAddress; + return mWrappedSmsMessage.getServiceCenterAddress(); } /** * Returns the originating address (sender) of this SMS message in String * form or null if unavailable + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public String getOriginatingAddress() { - if (originatingAddress == null) { - return null; - } - - return originatingAddress.getAddressString(); + return mWrappedSmsMessage.getOriginatingAddress(); } /** * Returns the originating address, or email from address if this message * was from an email gateway. Returns null if originating address * unavailable. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public String getDisplayOriginatingAddress() { - if (isEmail) { - return emailFrom; - } else { - return getOriginatingAddress(); - } + return mWrappedSmsMessage.getDisplayOriginatingAddress(); } /** * Returns the message body as a String, if it exists and is text based. * @return message body is there is one, otherwise null + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public String getMessageBody() { - return messageBody; + return mWrappedSmsMessage.getMessageBody(); } /** * Returns the class of this message. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public MessageClass getMessageClass() { - return messageClass; + int index = mWrappedSmsMessage.getMessageClass().ordinal(); + + return MessageClass.values()[index]; } /** * Returns the message body, or email message body if this message was from * an email gateway. Returns null if message body unavailable. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public String getDisplayMessageBody() { - if (isEmail) { - return emailBody; - } else { - return getMessageBody(); - } + return mWrappedSmsMessage.getDisplayMessageBody(); } /** * Unofficial convention of a subject line enclosed in parens empty string * if not present + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public String getPseudoSubject() { - return pseudoSubject == null ? "" : pseudoSubject; + return mWrappedSmsMessage.getPseudoSubject(); } /** * Returns the service centre timestamp in currentTimeMillis() format + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public long getTimestampMillis() { - return scTimeMillis; + return mWrappedSmsMessage.getTimestampMillis(); } /** @@ -1120,129 +521,114 @@ public class SmsMessage { * * @return true if this message came through an email gateway and email * sender / subject / parsed body are available + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public boolean isEmail() { - return isEmail; + return mWrappedSmsMessage.isEmail(); } - /** + /** * @return if isEmail() is true, body of the email sent through the gateway. * null otherwise + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public String getEmailBody() { - return emailBody; + return mWrappedSmsMessage.getEmailBody(); } /** * @return if isEmail() is true, email from address of email sent through * the gateway. null otherwise + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public String getEmailFrom() { - return emailFrom; + return mWrappedSmsMessage.getEmailFrom(); } /** * Get protocol identifier. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public int getProtocolIdentifier() { - return protocolIdentifier; + return mWrappedSmsMessage.getProtocolIdentifier(); } /** - * See TS 23.040 9.2.3.9 returns true if this is a "replace short message" - * SMS + * See TS 23.040 9.2.3.9 returns true if this is a "replace short message" SMS + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public boolean isReplace() { - return (protocolIdentifier & 0xc0) == 0x40 - && (protocolIdentifier & 0x3f) > 0 - && (protocolIdentifier & 0x3f) < 8; + return mWrappedSmsMessage.isReplace(); } /** * Returns true for CPHS MWI toggle message. * - * @return true if this is a CPHS MWI toggle message See CPHS 4.2 section - * B.4.2 + * @return true if this is a CPHS MWI toggle message See CPHS 4.2 section B.4.2 + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public boolean isCphsMwiMessage() { - return originatingAddress.isCphsVoiceMessageClear() - || originatingAddress.isCphsVoiceMessageSet(); + return mWrappedSmsMessage.isCphsMwiMessage(); } /** * returns true if this message is a CPHS voicemail / message waiting * indicator (MWI) clear message + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public boolean isMWIClearMessage() { - if (isMwi && (mwiSense == false)) { - return true; - } - - return originatingAddress != null - && originatingAddress.isCphsVoiceMessageClear(); + return mWrappedSmsMessage.isMWIClearMessage(); } /** * returns true if this message is a CPHS voicemail / message waiting * indicator (MWI) set message + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public boolean isMWISetMessage() { - if (isMwi && (mwiSense == true)) { - return true; - } - - return originatingAddress != null - && originatingAddress.isCphsVoiceMessageSet(); + return mWrappedSmsMessage.isMWISetMessage(); } /** * returns true if this message is a "Message Waiting Indication Group: * Discard Message" notification and should not be stored. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public boolean isMwiDontStore() { - if (isMwi && mwiDontStore) { - return true; - } - - if (isCphsMwiMessage()) { - // See CPHS 4.2 Section B.4.2.1 - // If the user data is a single space char, do not store - // the message. Otherwise, store and display as usual - if (" ".equals(getMessageBody())) { - ; - } - return true; - } - - return false; + return mWrappedSmsMessage.isMwiDontStore(); } /** - * returns the user data section minus the user data header if one was - * present. + * returns the user data section minus the user data header if one was present. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public byte[] getUserData() { - return userData; + return mWrappedSmsMessage.getUserData(); } - /** - * Returns an object representing the user data header - * - * @return an object representing the user data header - * - * {@hide} - */ - public SmsHeader getUserDataHeader() { - return userDataHeader; - } + /* Not part of the SDK interface and only needed by specific classes: + protected SmsHeader getUserDataHeader() + */ /** * Returns the raw PDU for the message. * * @return the raw PDU for the message. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public byte[] getPdu() { - return mPdu; + return mWrappedSmsMessage.getPdu(); } /** @@ -1254,369 +640,108 @@ public class SmsMessage { * SmsManager.STATUS_ON_SIM_UNREAD * SmsManager.STATUS_ON_SIM_SEND * SmsManager.STATUS_ON_SIM_UNSENT + * @deprecated Use android.telephony.SmsMessage and getStatusOnIcc instead. */ + @Deprecated public int getStatusOnSim() { - return statusOnSim; + return mWrappedSmsMessage.getStatusOnIcc(); + } + + /** + * Returns the status of the message on the ICC (read, unread, sent, unsent). + * + * @return the status of the message on the ICC. These are: + * SmsManager.STATUS_ON_ICC_FREE + * SmsManager.STATUS_ON_ICC_READ + * SmsManager.STATUS_ON_ICC_UNREAD + * SmsManager.STATUS_ON_ICC_SEND + * SmsManager.STATUS_ON_ICC_UNSENT + * @deprecated Use android.telephony.SmsMessage. + * @hide + */ + @Deprecated + public int getStatusOnIcc() { + + return mWrappedSmsMessage.getStatusOnIcc(); } /** * Returns the record index of the message on the SIM (1-based index). * @return the record index of the message on the SIM, or -1 if this * SmsMessage was not created from a SIM SMS EF record. + * @deprecated Use android.telephony.SmsMessage and getIndexOnIcc instead. */ + @Deprecated public int getIndexOnSim() { - return indexOnSim; + return mWrappedSmsMessage.getIndexOnIcc(); } /** + * Returns the record index of the message on the ICC (1-based index). + * @return the record index of the message on the ICC, or -1 if this + * SmsMessage was not created from a ICC SMS EF record. + * @deprecated Use android.telephony.SmsMessage. + * @hide + */ + @Deprecated + public int getIndexOnIcc() { + + return mWrappedSmsMessage.getIndexOnIcc(); + } + + /** + * GSM: * For an SMS-STATUS-REPORT message, this returns the status field from - * the status report. This field indicates the status of a previousely + * the status report. This field indicates the status of a previously * submitted SMS, if requested. See TS 23.040, 9.2.3.15 TP-Status for a * description of values. + * CDMA: + * For not interfering with status codes from GSM, the value is + * shifted to the bits 31-16. + * The value is composed of an error class (bits 25-24) and a status code (bits 23-16). + * Possible codes are described in C.S0015-B, v2.0, 4.5.21. * * @return 0 indicates the previously sent message was received. - * See TS 23.040, 9.9.2.3.15 for a description of other possible - * values. + * See TS 23.040, 9.9.2.3.15 and C.S0015-B, v2.0, 4.5.21 + * for a description of other possible values. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public int getStatus() { - return status; + return mWrappedSmsMessage.getStatus(); } /** * Return true iff the message is a SMS-STATUS-REPORT message. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public boolean isStatusReportMessage() { - return isStatusReportMessage; + return mWrappedSmsMessage.isStatusReportMessage(); } /** * Returns true iff the <code>TP-Reply-Path</code> bit is set in * this message. + * @deprecated Use android.telephony.SmsMessage. */ + @Deprecated public boolean isReplyPathPresent() { - return replyPathPresent; - } - - /** - * TS 27.005 3.1, <pdu> definition "In the case of SMS: 3GPP TS 24.011 [6] - * SC address followed by 3GPP TS 23.040 [3] TPDU in hexadecimal format: - * ME/TA converts each octet of TP data unit into two IRA character long - * hexad number (e.g. octet with integer value 42 is presented to TE as two - * characters 2A (IRA 50 and 65))" ...in the case of cell broadcast, - * something else... - */ - private void parsePdu(byte[] pdu) { - mPdu = pdu; - // Log.d(LOG_TAG, "raw sms mesage:"); - // Log.d(LOG_TAG, s); - - PduParser p = new PduParser(pdu); - - scAddress = p.getSCAddress(); - - if (scAddress != null) { - if (Config.LOGD) Log.d(LOG_TAG, "SMS SC address: " + scAddress); - } - - // TODO(mkf) support reply path, user data header indicator - - // TP-Message-Type-Indicator - // 9.2.3 - int firstByte = p.getByte(); - - mti = firstByte & 0x3; - switch (mti) { - // TP-Message-Type-Indicator - // 9.2.3 - case 0: - parseSmsDeliver(p, firstByte); - break; - case 2: - parseSmsStatusReport(p, firstByte); - break; - default: - // TODO(mkf) the rest of these - throw new RuntimeException("Unsupported message type"); - } - } - - /** - * Parses a SMS-STATUS-REPORT message. - * - * @param p A PduParser, cued past the first byte. - * @param firstByte The first byte of the PDU, which contains MTI, etc. - */ - private void parseSmsStatusReport(PduParser p, int firstByte) { - isStatusReportMessage = true; - - // TP-Status-Report-Qualifier bit == 0 for SUBMIT - forSubmit = (firstByte & 0x20) == 0x00; - // TP-Message-Reference - messageRef = p.getByte(); - // TP-Recipient-Address - recipientAddress = p.getAddress(); - // TP-Service-Centre-Time-Stamp - scTimeMillis = p.getSCTimestampMillis(); - // TP-Discharge-Time - dischargeTimeMillis = p.getSCTimestampMillis(); - // TP-Status - status = p.getByte(); - - // The following are optional fields that may or may not be present. - if (p.moreDataPresent()) { - // TP-Parameter-Indicator - int extraParams = p.getByte(); - int moreExtraParams = extraParams; - while ((moreExtraParams & 0x80) != 0) { - // We only know how to parse a few extra parameters, all - // indicated in the first TP-PI octet, so skip over any - // additional TP-PI octets. - moreExtraParams = p.getByte(); - } - // TP-Protocol-Identifier - if ((extraParams & 0x01) != 0) { - protocolIdentifier = p.getByte(); - } - // TP-Data-Coding-Scheme - if ((extraParams & 0x02) != 0) { - dataCodingScheme = p.getByte(); - } - // TP-User-Data-Length (implies existence of TP-User-Data) - if ((extraParams & 0x04) != 0) { - boolean hasUserDataHeader = (firstByte & 0x40) == 0x40; - parseUserData(p, hasUserDataHeader); - } - } - } - - private void parseSmsDeliver(PduParser p, int firstByte) { - replyPathPresent = (firstByte & 0x80) == 0x80; - - originatingAddress = p.getAddress(); - - if (originatingAddress != null) { - if (Config.LOGV) Log.v(LOG_TAG, "SMS originating address: " - + originatingAddress.address); - } - - // TP-Protocol-Identifier (TP-PID) - // TS 23.040 9.2.3.9 - protocolIdentifier = p.getByte(); - - // TP-Data-Coding-Scheme - // see TS 23.038 - dataCodingScheme = p.getByte(); - - if (Config.LOGV) { - Log.v(LOG_TAG, "SMS TP-PID:" + protocolIdentifier - + " data coding scheme: " + dataCodingScheme); - } - - scTimeMillis = p.getSCTimestampMillis(); - - if (Config.LOGD) Log.d(LOG_TAG, "SMS SC timestamp: " + scTimeMillis); - - boolean hasUserDataHeader = (firstByte & 0x40) == 0x40; - - parseUserData(p, hasUserDataHeader); + return mWrappedSmsMessage.isReplyPathPresent(); } - /** - * Parses the User Data of an SMS. - * - * @param p The current PduParser. - * @param hasUserDataHeader Indicates whether a header is present in the - * User Data. + /** This method returns the reference to a specific + * SmsMessage object, which is used for accessing its static methods. + * @return Specific SmsMessage. + * @deprecated Use android.telephony.SmsMessage. */ - private void parseUserData(PduParser p, boolean hasUserDataHeader) { - boolean hasMessageClass = false; - boolean userDataCompressed = false; - - int encodingType = ENCODING_UNKNOWN; - - // Look up the data encoding scheme - if ((dataCodingScheme & 0x80) == 0) { - // Bits 7..4 == 0xxx - automaticDeletion = (0 != (dataCodingScheme & 0x40)); - userDataCompressed = (0 != (dataCodingScheme & 0x20)); - hasMessageClass = (0 != (dataCodingScheme & 0x10)); - - if (userDataCompressed) { - Log.w(LOG_TAG, "4 - Unsupported SMS data coding scheme " - + "(compression) " + (dataCodingScheme & 0xff)); - } else { - switch ((dataCodingScheme >> 2) & 0x3) { - case 0: // GSM 7 bit default alphabet - encodingType = ENCODING_7BIT; - break; - - case 2: // UCS 2 (16bit) - encodingType = ENCODING_16BIT; - break; - - case 1: // 8 bit data - case 3: // reserved - Log.w(LOG_TAG, "1 - Unsupported SMS data coding scheme " - + (dataCodingScheme & 0xff)); - encodingType = ENCODING_8BIT; - break; - } - } - } else if ((dataCodingScheme & 0xf0) == 0xf0) { - automaticDeletion = false; - hasMessageClass = true; - userDataCompressed = false; - - if (0 == (dataCodingScheme & 0x04)) { - // GSM 7 bit default alphabet - encodingType = ENCODING_7BIT; - } else { - // 8 bit data - encodingType = ENCODING_8BIT; - } - } else if ((dataCodingScheme & 0xF0) == 0xC0 - || (dataCodingScheme & 0xF0) == 0xD0 - || (dataCodingScheme & 0xF0) == 0xE0) { - // 3GPP TS 23.038 V7.0.0 (2006-03) section 4 - - // 0xC0 == 7 bit, don't store - // 0xD0 == 7 bit, store - // 0xE0 == UCS-2, store - - if ((dataCodingScheme & 0xF0) == 0xE0) { - encodingType = ENCODING_16BIT; - } else { - encodingType = ENCODING_7BIT; - } - - userDataCompressed = false; - boolean active = ((dataCodingScheme & 0x08) == 0x08); - - // bit 0x04 reserved - - if ((dataCodingScheme & 0x03) == 0x00) { - isMwi = true; - mwiSense = active; - mwiDontStore = ((dataCodingScheme & 0xF0) == 0xC0); - } else { - isMwi = false; - - Log.w(LOG_TAG, "MWI for fax, email, or other " - + (dataCodingScheme & 0xff)); - } + private static final SmsMessageBase getSmsFacility(){ + int activePhone = TelephonyManager.getDefault().getPhoneType(); + if (PHONE_TYPE_CDMA == activePhone) { + return new com.android.internal.telephony.cdma.SmsMessage(); } else { - Log.w(LOG_TAG, "3 - Unsupported SMS data coding scheme " - + (dataCodingScheme & 0xff)); - } - - // set both the user data and the user data header. - int count = p.constructUserData(hasUserDataHeader, - encodingType == ENCODING_7BIT); - this.userData = p.getUserData(); - this.userDataHeader = p.getUserDataHeader(); - - switch (encodingType) { - case ENCODING_UNKNOWN: - case ENCODING_8BIT: - messageBody = null; - break; - - case ENCODING_7BIT: - messageBody = p.getUserDataGSM7Bit(count); - break; - - case ENCODING_16BIT: - messageBody = p.getUserDataUCS2(count); - break; - } - - if (Config.LOGV) Log.v(LOG_TAG, "SMS message body (raw): '" + messageBody + "'"); - - if (messageBody != null) { - parseMessageBody(); - } - - if (!hasMessageClass) { - messageClass = MessageClass.UNKNOWN; - } else { - switch (dataCodingScheme & 0x3) { - case 0: - messageClass = MessageClass.CLASS_0; - break; - case 1: - messageClass = MessageClass.CLASS_1; - break; - case 2: - messageClass = MessageClass.CLASS_2; - break; - case 3: - messageClass = MessageClass.CLASS_3; - break; - } - } - } - - private void parseMessageBody() { - if (originatingAddress.couldBeEmailGateway()) { - extractEmailAddressFromMessageBody(); - } - } - - /** - * Try to parse this message as an email gateway message -> Neither - * of the standard ways are currently supported: There are two ways - * specified in TS 23.040 Section 3.8 (not supported via this mechanism) - - * SMS message "may have its TP-PID set for internet electronic mail - MT - * SMS format: [<from-address><space>]<message> - "Depending on the - * nature of the gateway, the destination/origination address is either - * derived from the content of the SMS TP-OA or TP-DA field, or the - * TP-OA/TP-DA field contains a generic gateway address and the to/from - * address is added at the beginning as shown above." - multiple addreses - * separated by commas, no spaces - subject field delimited by '()' or '##' - * and '#' Section 9.2.3.24.11 - */ - private void extractEmailAddressFromMessageBody() { - - /* - * a little guesswork here. I haven't found doc for this. - * the format could be either - * - * 1. [x@y][ ]/[subject][ ]/[body] - * -or- - * 2. [x@y][ ]/[body] - */ - int slash = 0, slash2 = 0, atSymbol = 0; - - try { - slash = messageBody.indexOf(" /"); - if (slash == -1) { - return; - } - - atSymbol = messageBody.indexOf('@'); - if (atSymbol == -1 || atSymbol > slash) { - return; - } - - emailFrom = messageBody.substring(0, slash); - - slash2 = messageBody.indexOf(" /", slash + 2); - - if (slash2 == -1) { - pseudoSubject = null; - emailBody = messageBody.substring(slash + 2); - } else { - pseudoSubject = messageBody.substring(slash + 2, slash2); - emailBody = messageBody.substring(slash2 + 2); - } - - isEmail = true; - } catch (Exception ex) { - Log.w(LOG_TAG, - "extractEmailAddressFromMessageBody: exception slash=" - + slash + ", atSymbol=" + atSymbol + ", slash2=" - + slash2, ex); + return new com.android.internal.telephony.gsm.SmsMessage(); } } - } + diff --git a/telephony/java/com/android/internal/telephony/ATResponseParser.java b/telephony/java/com/android/internal/telephony/ATResponseParser.java index 93ec455..fdb0526 100644 --- a/telephony/java/com/android/internal/telephony/ATResponseParser.java +++ b/telephony/java/com/android/internal/telephony/ATResponseParser.java @@ -34,7 +34,7 @@ public class ATResponseParser { this.line = line; } - + public boolean nextBoolean() { @@ -147,7 +147,7 @@ public class ATResponseParser } } - + /** Throws ATParseEx if whitespace extends to the end of string */ private char skipWhiteSpace (char c) diff --git a/telephony/java/com/android/internal/telephony/gsm/AdnRecord.aidl b/telephony/java/com/android/internal/telephony/AdnRecord.aidl index 68d9a7c..b4a1a29 100644 --- a/telephony/java/com/android/internal/telephony/gsm/AdnRecord.aidl +++ b/telephony/java/com/android/internal/telephony/AdnRecord.aidl @@ -14,6 +14,7 @@ ** limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; parcelable AdnRecord; + diff --git a/telephony/java/com/android/internal/telephony/AdnRecord.java b/telephony/java/com/android/internal/telephony/AdnRecord.java new file mode 100644 index 0000000..5f40579 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/AdnRecord.java @@ -0,0 +1,283 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.os.Parcel; +import android.os.Parcelable; +import android.telephony.PhoneNumberUtils; +import android.util.Log; + +import com.android.internal.telephony.GsmAlphabet; + + +/** + * + * Used to load or store ADNs (Abbreviated Dialing Numbers). + * + * {@hide} + * + */ +public class AdnRecord implements Parcelable { + static final String LOG_TAG = "GSM"; + + //***** Instance Variables + + String alphaTag = ""; + String number = ""; + int extRecord = 0xff; + int efid; // or 0 if none + int recordNumber; // or 0 if none + + + //***** Constants + + // In an ADN record, everything but the alpha identifier + // is in a footer that's 14 bytes + static final int FOOTER_SIZE_BYTES = 14; + + // Maximum size of the un-extended number field + static final int MAX_NUMBER_SIZE_BYTES = 11; + + static final int EXT_RECORD_LENGTH_BYTES = 13; + static final int EXT_RECORD_TYPE_ADDITIONAL_DATA = 2; + static final int EXT_RECORD_TYPE_MASK = 3; + static final int MAX_EXT_CALLED_PARTY_LENGTH = 0xa; + + // ADN offset + static final int ADN_BCD_NUMBER_LENGTH = 0; + static final int ADN_TON_AND_NPI = 1; + static final int ADN_DAILING_NUMBER_START = 2; + static final int ADN_DAILING_NUMBER_END = 11; + static final int ADN_CAPABILITY_ID = 12; + static final int ADN_EXTENSION_ID = 13; + + //***** Static Methods + + public static final Parcelable.Creator<AdnRecord> CREATOR + = new Parcelable.Creator<AdnRecord>() { + public AdnRecord createFromParcel(Parcel source) { + int efid; + int recordNumber; + String alphaTag; + String number; + + efid = source.readInt(); + recordNumber = source.readInt(); + alphaTag = source.readString(); + number = source.readString(); + + return new AdnRecord(efid, recordNumber, alphaTag, number); + } + + public AdnRecord[] newArray(int size) { + return new AdnRecord[size]; + } + }; + + + //***** Constructor + public + AdnRecord (byte[] record) { + this(0, 0, record); + } + + public + AdnRecord (int efid, int recordNumber, byte[] record) { + this.efid = efid; + this.recordNumber = recordNumber; + parseRecord(record); + } + + public + AdnRecord (String alphaTag, String number) { + this(0, 0, alphaTag, number); + } + + public + AdnRecord (int efid, int recordNumber, String alphaTag, String number) { + this.efid = efid; + this.recordNumber = recordNumber; + this.alphaTag = alphaTag; + this.number = number; + } + + //***** Instance Methods + + public String getAlphaTag() { + return alphaTag; + } + + public String getNumber() { + return number; + } + + public String toString() { + return "ADN Record '" + alphaTag + "' '" + number + "'"; + } + + public boolean isEmpty() { + return alphaTag.equals("") && number.equals(""); + } + + public boolean hasExtendedRecord() { + return extRecord != 0 && extRecord != 0xff; + } + + public boolean isEqual(AdnRecord adn) { + return ( alphaTag.equals(adn.getAlphaTag()) && + number.equals(adn.getNumber()) ); + } + //***** Parcelable Implementation + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(efid); + dest.writeInt(recordNumber); + dest.writeString(alphaTag); + dest.writeString(number); + } + + /** + * Build adn hex byte array based on record size + * The format of byte array is defined in 51.011 10.5.1 + * + * @param recordSize is the size X of EF record + * @return hex byte[recordSize] to be written to EF record + * return nulll for wrong format of dialing nubmer or tag + */ + public byte[] buildAdnString(int recordSize) { + byte[] bcdNumber; + byte[] byteTag; + byte[] adnString = null; + int footerOffset = recordSize - FOOTER_SIZE_BYTES; + + if (number == null || number.equals("") || + alphaTag == null || alphaTag.equals("")) { + + Log.w(LOG_TAG, "[buildAdnString] Empty alpha tag or number"); + adnString = new byte[recordSize]; + for (int i = 0; i < recordSize; i++) { + adnString[i] = (byte) 0xFF; + } + } else if (number.length() + > (ADN_DAILING_NUMBER_END - ADN_DAILING_NUMBER_START + 1) * 2) { + Log.w(LOG_TAG, + "[buildAdnString] Max length of dailing number is 20"); + } else if (alphaTag.length() > footerOffset) { + Log.w(LOG_TAG, + "[buildAdnString] Max length of tag is " + footerOffset); + } else { + + adnString = new byte[recordSize]; + for (int i = 0; i < recordSize; i++) { + adnString[i] = (byte) 0xFF; + } + + bcdNumber = PhoneNumberUtils.numberToCalledPartyBCD(number); + + System.arraycopy(bcdNumber, 0, adnString, + footerOffset + ADN_TON_AND_NPI, bcdNumber.length); + + adnString[footerOffset + ADN_BCD_NUMBER_LENGTH] + = (byte) (bcdNumber.length); + adnString[footerOffset + ADN_CAPABILITY_ID] + = (byte) 0xFF; // Capacility Id + adnString[footerOffset + ADN_EXTENSION_ID] + = (byte) 0xFF; // Extension Record Id + + byteTag = GsmAlphabet.stringToGsm8BitPacked(alphaTag); + System.arraycopy(byteTag, 0, adnString, 0, byteTag.length); + + } + + return adnString; + } + + /** + * See TS 51.011 10.5.10 + */ + public void + appendExtRecord (byte[] extRecord) { + try { + if (extRecord.length != EXT_RECORD_LENGTH_BYTES) { + return; + } + + if ((extRecord[0] & EXT_RECORD_TYPE_MASK) + != EXT_RECORD_TYPE_ADDITIONAL_DATA) { + return; + } + + if ((0xff & extRecord[1]) > MAX_EXT_CALLED_PARTY_LENGTH) { + // invalid or empty record + return; + } + + number += PhoneNumberUtils.calledPartyBCDFragmentToString( + extRecord, 2, 0xff & extRecord[1]); + + // We don't support ext record chaining. + + } catch (RuntimeException ex) { + Log.w(LOG_TAG, "Error parsing AdnRecord ext record", ex); + } + } + + //***** Private Methods + + /** + * alphaTag and number are set to null on invalid format + */ + private void + parseRecord(byte[] record) { + try { + alphaTag = IccUtils.adnStringFieldToString( + record, 0, record.length - FOOTER_SIZE_BYTES); + + int footerOffset = record.length - FOOTER_SIZE_BYTES; + + int numberLength = 0xff & record[footerOffset]; + + if (numberLength > MAX_NUMBER_SIZE_BYTES) { + // Invalid number length + number = ""; + return; + } + + // Please note 51.011 10.5.1: + // + // "If the Dialling Number/SSC String does not contain + // a dialling number, e.g. a control string deactivating + // a service, the TON/NPI byte shall be set to 'FF' by + // the ME (see note 2)." + + number = PhoneNumberUtils.calledPartyBCDToString( + record, footerOffset + 1, numberLength); + + + extRecord = 0xff & record[record.length - 1]; + + } catch (RuntimeException ex) { + Log.w(LOG_TAG, "Error parsing AdnRecord", ex); + number = ""; + alphaTag = ""; + } + } +} diff --git a/telephony/java/com/android/internal/telephony/gsm/AdnRecordCache.java b/telephony/java/com/android/internal/telephony/AdnRecordCache.java index 9da18e3..c270ae5 100644 --- a/telephony/java/com/android/internal/telephony/gsm/AdnRecordCache.java +++ b/telephony/java/com/android/internal/telephony/AdnRecordCache.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; import android.util.SparseArray; import android.util.Log; @@ -23,18 +23,18 @@ import android.os.Handler; import android.os.AsyncResult; import java.util.ArrayList; import java.util.Iterator; +import com.android.internal.telephony.IccConstants; /** * {@hide} */ -public final class AdnRecordCache extends Handler implements SimConstants -{ +public final class AdnRecordCache extends Handler implements IccConstants { //***** Instance Variables - GSMPhone phone; + PhoneBase phone; // Indexed by EF ID - SparseArray<ArrayList<AdnRecord>> adnLikeFiles + SparseArray<ArrayList<AdnRecord>> adnLikeFiles = new SparseArray<ArrayList<AdnRecord>>(); // People waiting for ADN-like files to be loaded @@ -52,9 +52,8 @@ public final class AdnRecordCache extends Handler implements SimConstants //***** Constructor - /*package*/ - AdnRecordCache(GSMPhone phone) - { + + public AdnRecordCache(PhoneBase phone) { this.phone = phone; } @@ -63,14 +62,12 @@ public final class AdnRecordCache extends Handler implements SimConstants /** * Called from SIMRecords.onRadioNotAvailable and SIMRecords.handleSimRefresh. */ - /*package*/ void - reset() - { + public void reset() { adnLikeFiles.clear(); clearWaiters(); clearUserWriters(); - + } private void clearWaiters() { @@ -95,29 +92,27 @@ public final class AdnRecordCache extends Handler implements SimConstants * @return List of AdnRecords for efid if we've already loaded them this * radio session, or null if we haven't */ - /*package*/ ArrayList<AdnRecord> - getRecordsIfLoaded(int efid) - { + public ArrayList<AdnRecord> + getRecordsIfLoaded(int efid) { return adnLikeFiles.get(efid); } /** - * Returns extension ef associated with ADN-like EF or -1 if + * Returns extension ef associated with ADN-like EF or -1 if * we don't know. * * See 3GPP TS 51.011 for this mapping */ private int - extensionEfForEf(int efid) - { + extensionEfForEf(int efid) { switch (efid) { case EF_MBDN: return EF_EXT6; case EF_ADN: return EF_EXT1; case EF_SDN: return EF_EXT3; case EF_FDN: return EF_EXT2; - case EF_MSISDN: return EF_EXT1; + case EF_MSISDN: return EF_EXT1; default: return -1; - } + } } private void sendErrorResponse(Message response, String errString) { @@ -138,7 +133,7 @@ public final class AdnRecordCache extends Handler implements SimConstants * @param response message to be posted when done * response.exception hold the exception in error */ - void updateAdnByIndex(int efid, AdnRecord adn, int recordIndex, String pin2, + public void updateAdnByIndex(int efid, AdnRecord adn, int recordIndex, String pin2, Message response) { int extensionEF = extensionEfForEf(efid); @@ -174,7 +169,7 @@ public final class AdnRecordCache extends Handler implements SimConstants * @param response message to be posted when done * response.exception hold the exception in error */ - void updateAdnBySearch(int efid, AdnRecord oldAdn, AdnRecord newAdn, + public void updateAdnBySearch(int efid, AdnRecord oldAdn, AdnRecord newAdn, String pin2, Message response) { int extensionEF; @@ -227,9 +222,8 @@ public final class AdnRecordCache extends Handler implements SimConstants * Responds with exception (in response) if efid is not a known ADN-like * record */ - /*package*/ void - requestLoadAllAdnLike (int efid, Message response) - { + public void + requestLoadAllAdnLike (int efid, Message response) { ArrayList<Message> waiters; ArrayList<AdnRecord> result; @@ -256,25 +250,25 @@ public final class AdnRecordCache extends Handler implements SimConstants waiters.add(response); return; } - + // Start loading efid - + waiters = new ArrayList<Message>(); waiters.add(response); adnLikeWaiters.put(efid, waiters); int extensionEF = extensionEfForEf(efid); - + if (extensionEF < 0) { // respond with error if not known ADN-like record if (response != null) { - AsyncResult.forMessage(response).exception + AsyncResult.forMessage(response).exception = new RuntimeException("EF is not known ADN-like EF:" + efid); response.sendToTarget(); } - + return; } @@ -285,8 +279,7 @@ public final class AdnRecordCache extends Handler implements SimConstants //***** Private methods private void - notifyWaiters(ArrayList<Message> waiters, AsyncResult ar) - { + notifyWaiters(ArrayList<Message> waiters, AsyncResult ar) { if (waiters == null) { return; diff --git a/telephony/java/com/android/internal/telephony/AdnRecordLoader.java b/telephony/java/com/android/internal/telephony/AdnRecordLoader.java new file mode 100644 index 0000000..cfb5aaa --- /dev/null +++ b/telephony/java/com/android/internal/telephony/AdnRecordLoader.java @@ -0,0 +1,285 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import java.util.ArrayList; + +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.util.Log; + + +public class AdnRecordLoader extends Handler { + static String LOG_TAG; + + //***** Instance Variables + + PhoneBase phone; + int ef; + int extensionEF; + int pendingExtLoads; + Message userResponse; + String pin2; + + // For "load one" + int recordNumber; + + // for "load all" + ArrayList<AdnRecord> adns; // only valid after EVENT_ADN_LOAD_ALL_DONE + + // Either an AdnRecord or a reference to adns depending + // if this is a load one or load all operation + Object result; + + //***** Event Constants + + static final int EVENT_ADN_LOAD_DONE = 1; + static final int EVENT_EXT_RECORD_LOAD_DONE = 2; + static final int EVENT_ADN_LOAD_ALL_DONE = 3; + static final int EVENT_EF_LINEAR_RECORD_SIZE_DONE = 4; + static final int EVENT_UPDATE_RECORD_DONE = 5; + + //***** Constructor + + public AdnRecordLoader(PhoneBase phone) { + // The telephony unit-test cases may create AdnRecords + // in secondary threads + super(phone.getHandler().getLooper()); + + this.phone = phone; + LOG_TAG = phone.getPhoneName(); + } + + /** + * Resulting AdnRecord is placed in response.obj.result + * or response.obj.exception is set + */ + public void + loadFromEF(int ef, int extensionEF, int recordNumber, + Message response) { + this.ef = ef; + this.extensionEF = extensionEF; + this.recordNumber = recordNumber; + this.userResponse = response; + + phone.mIccFileHandler.loadEFLinearFixed( + ef, recordNumber, + obtainMessage(EVENT_ADN_LOAD_DONE)); + + } + + + /** + * Resulting ArrayList<adnRecord> is placed in response.obj.result + * or response.obj.exception is set + */ + public void + loadAllFromEF(int ef, int extensionEF, + Message response) { + this.ef = ef; + this.extensionEF = extensionEF; + this.userResponse = response; + + phone.mIccFileHandler.loadEFLinearFixedAll( + ef, + obtainMessage(EVENT_ADN_LOAD_ALL_DONE)); + + } + + /** + * Write adn to a EF SIM record + * It will get the record size of EF record and compose hex adn array + * then write the hex array to EF record + * + * @param adn is set with alphaTag and phoneNubmer + * @param ef EF fileid + * @param extensionEF extension EF fileid + * @param recordNumber 1-based record index + * @param pin2 for CHV2 operations, must be null if pin2 is not needed + * @param response will be sent to its handler when completed + */ + public void + updateEF(AdnRecord adn, int ef, int extensionEF, int recordNumber, + String pin2, Message response) { + this.ef = ef; + this.extensionEF = extensionEF; + this.recordNumber = recordNumber; + this.userResponse = response; + this.pin2 = pin2; + + phone.mIccFileHandler.getEFLinearRecordSize( ef, + obtainMessage(EVENT_EF_LINEAR_RECORD_SIZE_DONE, adn)); + } + + //***** Overridden from Handler + + public void + handleMessage(Message msg) { + AsyncResult ar; + byte data[]; + AdnRecord adn; + + try { + switch (msg.what) { + case EVENT_EF_LINEAR_RECORD_SIZE_DONE: + ar = (AsyncResult)(msg.obj); + adn = (AdnRecord)(ar.userObj); + + if (ar.exception != null) { + throw new RuntimeException("get EF record size failed", + ar.exception); + } + + int[] recordSize = (int[])ar.result; + // recordSize is int[3] array + // int[0] is the record length + // int[1] is the total length of the EF file + // int[2] is the number of records in the EF file + // So int[0] * int[2] = int[1] + if (recordSize.length != 3 || recordNumber > recordSize[2]) { + throw new RuntimeException("get wrong EF record size format", + ar.exception); + } + + data = adn.buildAdnString(recordSize[0]); + + if(data == null) { + throw new RuntimeException("worong ADN format", + ar.exception); + } + + phone.mIccFileHandler.updateEFLinearFixed(ef, recordNumber, + data, pin2, obtainMessage(EVENT_UPDATE_RECORD_DONE)); + + pendingExtLoads = 1; + + break; + case EVENT_UPDATE_RECORD_DONE: + ar = (AsyncResult)(msg.obj); + if (ar.exception != null) { + throw new RuntimeException("update EF adn record failed", + ar.exception); + } + pendingExtLoads = 0; + result = null; + break; + case EVENT_ADN_LOAD_DONE: + ar = (AsyncResult)(msg.obj); + data = (byte[])(ar.result); + + if (ar.exception != null) { + throw new RuntimeException("load failed", ar.exception); + } + + if (false) { + Log.d(LOG_TAG,"ADN EF: 0x" + + Integer.toHexString(ef) + + ":" + recordNumber + + "\n" + IccUtils.bytesToHexString(data)); + } + + adn = new AdnRecord(ef, recordNumber, data); + result = adn; + + if (adn.hasExtendedRecord()) { + // If we have a valid value in the ext record field, + // we're not done yet: we need to read the corresponding + // ext record and append it + + pendingExtLoads = 1; + + phone.mIccFileHandler.loadEFLinearFixed( + extensionEF, adn.extRecord, + obtainMessage(EVENT_EXT_RECORD_LOAD_DONE, adn)); + } + break; + + case EVENT_EXT_RECORD_LOAD_DONE: + ar = (AsyncResult)(msg.obj); + data = (byte[])(ar.result); + adn = (AdnRecord)(ar.userObj); + + if (ar.exception != null) { + throw new RuntimeException("load failed", ar.exception); + } + + Log.d(LOG_TAG,"ADN extention EF: 0x" + + Integer.toHexString(extensionEF) + + ":" + adn.extRecord + + "\n" + IccUtils.bytesToHexString(data)); + + adn.appendExtRecord(data); + + pendingExtLoads--; + // result should have been set in + // EVENT_ADN_LOAD_DONE or EVENT_ADN_LOAD_ALL_DONE + break; + + case EVENT_ADN_LOAD_ALL_DONE: + ar = (AsyncResult)(msg.obj); + ArrayList<byte[]> datas = (ArrayList<byte[]>)(ar.result); + + if (ar.exception != null) { + throw new RuntimeException("load failed", ar.exception); + } + + adns = new ArrayList<AdnRecord>(datas.size()); + result = adns; + pendingExtLoads = 0; + + for(int i = 0, s = datas.size() ; i < s ; i++) { + adn = new AdnRecord(ef, 1 + i, datas.get(i)); + adns.add(adn); + + if (adn.hasExtendedRecord()) { + // If we have a valid value in the ext record field, + // we're not done yet: we need to read the corresponding + // ext record and append it + + pendingExtLoads++; + + phone.mIccFileHandler.loadEFLinearFixed( + extensionEF, adn.extRecord, + obtainMessage(EVENT_EXT_RECORD_LOAD_DONE, adn)); + } + } + break; + } + } catch (RuntimeException exc) { + if (userResponse != null) { + AsyncResult.forMessage(userResponse) + .exception = exc; + userResponse.sendToTarget(); + // Loading is all or nothing--either every load succeeds + // or we fail the whole thing. + userResponse = null; + } + return; + } + + if (userResponse != null && pendingExtLoads == 0) { + AsyncResult.forMessage(userResponse).result + = result; + + userResponse.sendToTarget(); + userResponse = null; + } + } + + +} diff --git a/telephony/java/com/android/internal/telephony/BaseCommands.java b/telephony/java/com/android/internal/telephony/BaseCommands.java new file mode 100644 index 0000000..11e7461 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/BaseCommands.java @@ -0,0 +1,580 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + + +import android.content.Context; +import android.os.RegistrantList; +import android.os.Registrant; +import android.os.Handler; +import android.os.AsyncResult; +import android.provider.Checkin; +import android.util.Config; +import android.util.Log; + +/** + * {@hide} + */ +public abstract class BaseCommands implements CommandsInterface { + static final String LOG_TAG = "RILB"; + + //***** Instance Variables + protected Context mContext; + protected RadioState mState = RadioState.RADIO_UNAVAILABLE; + protected Object mStateMonitor = new Object(); + + protected RegistrantList mRadioStateChangedRegistrants = new RegistrantList(); + protected RegistrantList mOnRegistrants = new RegistrantList(); + protected RegistrantList mAvailRegistrants = new RegistrantList(); + protected RegistrantList mOffOrNotAvailRegistrants = new RegistrantList(); + protected RegistrantList mNotAvailRegistrants = new RegistrantList(); + protected RegistrantList mSIMReadyRegistrants = new RegistrantList(); + protected RegistrantList mSIMLockedRegistrants = new RegistrantList(); + protected RegistrantList mRUIMReadyRegistrants = new RegistrantList(); + protected RegistrantList mRUIMLockedRegistrants = new RegistrantList(); + protected RegistrantList mNVReadyRegistrants = new RegistrantList(); + protected RegistrantList mCallStateRegistrants = new RegistrantList(); + protected RegistrantList mNetworkStateRegistrants = new RegistrantList(); + protected RegistrantList mDataConnectionRegistrants = new RegistrantList(); + protected RegistrantList mRadioTechnologyChangedRegistrants = new RegistrantList(); + protected RegistrantList mIccStatusChangedRegistrants = new RegistrantList(); + protected RegistrantList mVoicePrivacyOnRegistrants = new RegistrantList(); + protected RegistrantList mVoicePrivacyOffRegistrants = new RegistrantList(); + protected Registrant mSMSRegistrant; + protected Registrant mNITZTimeRegistrant; + protected Registrant mSignalStrengthRegistrant; + protected Registrant mUSSDRegistrant; + protected Registrant mSmsOnSimRegistrant; + /** Registrant for handling SMS Status Reports */ + protected Registrant mSmsStatusRegistrant; + /** Registrant for handling Supplementary Service Notifications */ + protected Registrant mSsnRegistrant; + protected Registrant mStkSessionEndRegistrant; + protected Registrant mStkProCmdRegistrant; + protected Registrant mStkEventRegistrant; + protected Registrant mStkCallSetUpRegistrant; + /** Registrant for handling SIM/RUIM SMS storage full messages */ + protected Registrant mIccSmsFullRegistrant; + /** Registrant for handling Icc Refresh notifications */ + protected Registrant mIccRefreshRegistrant; + /** Registrant for handling RING notifications */ + protected Registrant mRingRegistrant; + /** Registrant for handling RESTRICTED STATE changed notification */ + protected Registrant mRestrictedStateRegistrant; + + //Network Mode received from PhoneFactory + protected int mNetworkMode; + //CDMA subscription received from PhoneFactory + protected int mCdmaSubscription; + //Type of Phone, GSM or CDMA. Set by CDMAPhone or GSMPhone. + protected int mPhoneType; + + + public BaseCommands(Context context) { + mContext = context; // May be null (if so we won't log statistics) + } + + //***** CommandsInterface implementation + + public RadioState getRadioState() { + return mState; + } + + + public void registerForRadioStateChanged(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mRadioStateChangedRegistrants.add(r); + r.notifyRegistrant(); + } + } + + public void unregisterForRadioStateChanged(Handler h) { + synchronized (mStateMonitor) { + mRadioStateChangedRegistrants.remove(h); + } + } + + public void registerForOn(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mOnRegistrants.add(r); + + if (mState.isOn()) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + } + public void unregisterForOn(Handler h) { + synchronized (mStateMonitor) { + mOnRegistrants.remove(h); + } + } + + + public void registerForAvailable(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mAvailRegistrants.add(r); + + if (mState.isAvailable()) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + } + + public void unregisterForAvailable(Handler h) { + synchronized(mStateMonitor) { + mAvailRegistrants.remove(h); + } + } + + public void registerForNotAvailable(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mNotAvailRegistrants.add(r); + + if (!mState.isAvailable()) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + } + + public void unregisterForNotAvailable(Handler h) { + synchronized (mStateMonitor) { + mNotAvailRegistrants.remove(h); + } + } + + public void registerForOffOrNotAvailable(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mOffOrNotAvailRegistrants.add(r); + + if (mState == RadioState.RADIO_OFF || !mState.isAvailable()) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + } + public void unregisterForOffOrNotAvailable(Handler h) { + synchronized(mStateMonitor) { + mOffOrNotAvailRegistrants.remove(h); + } + } + + + /** Any transition into SIM_READY */ + public void registerForSIMReady(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mSIMReadyRegistrants.add(r); + + if (mState.isSIMReady()) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + } + + public void unregisterForSIMReady(Handler h) { + synchronized (mStateMonitor) { + mSIMReadyRegistrants.remove(h); + } + } + + /** Any transition into RUIM_READY */ + public void registerForRUIMReady(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mRUIMReadyRegistrants.add(r); + + if (mState.isRUIMReady()) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + } + + public void unregisterForRUIMReady(Handler h) { + synchronized(mStateMonitor) { + mRUIMReadyRegistrants.remove(h); + } + } + + /** Any transition into NV_READY */ + public void registerForNVReady(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mNVReadyRegistrants.add(r); + + if (mState.isNVReady()) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + } + + public void unregisterForNVReady(Handler h) { + synchronized (mStateMonitor) { + mNVReadyRegistrants.remove(h); + } + } + + public void registerForSIMLockedOrAbsent(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mSIMLockedRegistrants.add(r); + + if (mState == RadioState.SIM_LOCKED_OR_ABSENT) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + } + + public void unregisterForSIMLockedOrAbsent(Handler h) { + synchronized (mStateMonitor) { + mSIMLockedRegistrants.remove(h); + } + } + + public void registerForRUIMLockedOrAbsent(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + synchronized (mStateMonitor) { + mRUIMLockedRegistrants.add(r); + + if (mState == RadioState.RUIM_LOCKED_OR_ABSENT) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + } + + public void unregisterForRUIMLockedOrAbsent(Handler h) { + synchronized (mStateMonitor) { + mRUIMLockedRegistrants.remove(h); + } + } + + public void registerForCallStateChanged(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + mCallStateRegistrants.add(r); + } + + public void unregisterForCallStateChanged(Handler h) { + mCallStateRegistrants.remove(h); + } + + public void registerForNetworkStateChanged(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + mNetworkStateRegistrants.add(r); + } + + public void unregisterForNetworkStateChanged(Handler h) { + mNetworkStateRegistrants.remove(h); + } + + public void registerForDataStateChanged(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + mDataConnectionRegistrants.add(r); + } + + public void unregisterForDataStateChanged(Handler h) { + mDataConnectionRegistrants.remove(h); + } + + public void registerForRadioTechnologyChanged(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + mRadioTechnologyChangedRegistrants.add(r); + } + + public void unregisterForRadioTechnologyChanged(Handler h) { + mRadioTechnologyChangedRegistrants.remove(h); + } + + public void registerForIccStatusChanged(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + mIccStatusChangedRegistrants.add(r); + } + + public void unregisterForIccStatusChanged(Handler h) { + mIccStatusChangedRegistrants.remove(h); + } + + public void setOnNewSMS(Handler h, int what, Object obj) { + mSMSRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnNewSMS(Handler h) { + mSMSRegistrant.clear(); + } + + public void setOnSmsOnSim(Handler h, int what, Object obj) { + mSmsOnSimRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnSmsOnSim(Handler h) { + mSmsOnSimRegistrant.clear(); + } + + public void setOnSmsStatus(Handler h, int what, Object obj) { + mSmsStatusRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnSmsStatus(Handler h) { + mSmsStatusRegistrant.clear(); + } + + public void setOnSignalStrengthUpdate(Handler h, int what, Object obj) { + mSignalStrengthRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnSignalStrengthUpdate(Handler h) { + mSignalStrengthRegistrant.clear(); + } + + public void setOnNITZTime(Handler h, int what, Object obj) { + mNITZTimeRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnNITZTime(Handler h) { + mNITZTimeRegistrant.clear(); + } + + public void setOnUSSD(Handler h, int what, Object obj) { + mUSSDRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnUSSD(Handler h) { + mUSSDRegistrant.clear(); + } + + public void setOnSuppServiceNotification(Handler h, int what, Object obj) { + mSsnRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnSuppServiceNotification(Handler h) { + mSsnRegistrant.clear(); + } + + public void setOnStkSessionEnd(Handler h, int what, Object obj) { + mStkSessionEndRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnStkSessionEnd(Handler h) { + mStkSessionEndRegistrant.clear(); + } + + public void setOnStkProactiveCmd(Handler h, int what, Object obj) { + mStkProCmdRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnStkProactiveCmd(Handler h) { + mStkProCmdRegistrant.clear(); + } + + public void setOnStkEvent(Handler h, int what, Object obj) { + mStkEventRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnStkEvent(Handler h) { + mStkEventRegistrant.clear(); + } + + public void setOnStkCallSetUp(Handler h, int what, Object obj) { + mStkCallSetUpRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnStkCallSetUp(Handler h) { + mStkCallSetUpRegistrant.clear(); + } + + public void setOnIccSmsFull(Handler h, int what, Object obj) { + mIccSmsFullRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnIccSmsFull(Handler h) { + mIccSmsFullRegistrant.clear(); + } + + public void setOnIccRefresh(Handler h, int what, Object obj) { + mIccRefreshRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnIccRefresh(Handler h) { + mIccRefreshRegistrant.clear(); + } + + public void setOnCallRing(Handler h, int what, Object obj) { + mRingRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnCallRing(Handler h) { + mRingRegistrant.clear(); + } + + public void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + mVoicePrivacyOnRegistrants.add(r); + } + + public void unregisterForInCallVoicePrivacyOn(Handler h){ + mVoicePrivacyOnRegistrants.remove(h); + } + + public void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + mVoicePrivacyOffRegistrants.add(r); + } + + public void unregisterForInCallVoicePrivacyOff(Handler h){ + mVoicePrivacyOffRegistrants.remove(h); + } + + public void setOnRestrictedStateChanged(Handler h, int what, Object obj) { + mRestrictedStateRegistrant = new Registrant (h, what, obj); + } + + public void unSetOnRestrictedStateChanged(Handler h) { + mRestrictedStateRegistrant.clear(); + } + + //***** Protected Methods + /** + * Store new RadioState and send notification based on the changes + * + * This function is called only by RIL.java when receiving unsolicited + * RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED + * + * RadioState has 5 values : RADIO_OFF, RADIO_UNAVAILABLE, SIM_NOT_READY, + * SIM_LOCKED_OR_ABSENT, and SIM_READY. + * + * @param newState new RadioState decoded from RIL_UNSOL_RADIO_STATE_CHANGED + */ + protected void setRadioState(RadioState newState) { + RadioState oldState; + + synchronized (mStateMonitor) { + if (Config.LOGV) { + Log.v(LOG_TAG, "setRadioState old: " + mState + + " new " + newState); + } + + oldState = mState; + mState = newState; + + if (oldState == mState) { + // no state transition + return; + } + + if (mContext != null && + newState == RadioState.RADIO_UNAVAILABLE && + oldState != RadioState.RADIO_OFF) { + Checkin.updateStats(mContext.getContentResolver(), + Checkin.Stats.Tag.PHONE_RADIO_RESETS, 1, 0.0); + } + + mRadioStateChangedRegistrants.notifyRegistrants(); + + if (mState.isAvailable() && !oldState.isAvailable()) { + Log.d(LOG_TAG,"Notifying: radio available"); + mAvailRegistrants.notifyRegistrants(); + onRadioAvailable(); + } + + if (!mState.isAvailable() && oldState.isAvailable()) { + Log.d(LOG_TAG,"Notifying: radio not available"); + mNotAvailRegistrants.notifyRegistrants(); + } + + if (mState.isSIMReady() && !oldState.isSIMReady()) { + Log.d(LOG_TAG,"Notifying: SIM ready"); + mSIMReadyRegistrants.notifyRegistrants(); + } + + if (mState == RadioState.SIM_LOCKED_OR_ABSENT) { + Log.d(LOG_TAG,"Notifying: SIM locked or absent"); + mSIMLockedRegistrants.notifyRegistrants(); + } + + if (mState.isRUIMReady() && !oldState.isRUIMReady()) { + Log.d(LOG_TAG,"Notifying: RUIM ready"); + mRUIMReadyRegistrants.notifyRegistrants(); + } + + if (mState == RadioState.RUIM_LOCKED_OR_ABSENT) { + Log.d(LOG_TAG,"Notifying: RUIM locked or absent"); + mRUIMLockedRegistrants.notifyRegistrants(); + } + if (mState.isNVReady() && !oldState.isNVReady()) { + Log.d(LOG_TAG,"Notifying: NV ready"); + mNVReadyRegistrants.notifyRegistrants(); + } + + if (mState.isOn() && !oldState.isOn()) { + Log.d(LOG_TAG,"Notifying: Radio On"); + mOnRegistrants.notifyRegistrants(); + } + + if ((!mState.isOn() || !mState.isAvailable()) + && !((!oldState.isOn() || !oldState.isAvailable())) + ) { + Log.d(LOG_TAG,"Notifying: radio off or not available"); + mOffOrNotAvailRegistrants.notifyRegistrants(); + } + + /* Radio Technology Change events + * NOTE: isGsm and isCdma have no common states in RADIO_OFF or RADIO_UNAVAILABLE; the + * current phone is determined by mPhoneType + * NOTE: at startup no phone have been created and the RIL determines the mPhoneType + * looking based on the networkMode set by the PhoneFactory in the constructor + */ + + if (mState.isGsm() && oldState.isCdma()) { + Log.d(LOG_TAG,"Notifying: radio technology change CDMA to GSM"); + mRadioTechnologyChangedRegistrants.notifyRegistrants(); + } + + if (mState.isGsm() && !oldState.isOn() && (mPhoneType == RILConstants.CDMA_PHONE)) { + Log.d(LOG_TAG,"Notifying: radio technology change CDMA OFF to GSM"); + mRadioTechnologyChangedRegistrants.notifyRegistrants(); + } + + if (mState.isCdma() && oldState.isGsm()) { + Log.d(LOG_TAG,"Notifying: radio technology change GSM to CDMA"); + mRadioTechnologyChangedRegistrants.notifyRegistrants(); + } + + if (mState.isCdma() && !oldState.isOn() && (mPhoneType == RILConstants.GSM_PHONE)) { + Log.d(LOG_TAG,"Notifying: radio technology change GSM OFF to CDMA"); + mRadioTechnologyChangedRegistrants.notifyRegistrants(); + } + } + } + + protected void onRadioAvailable() { + } +} diff --git a/telephony/java/com/android/internal/telephony/Call.java b/telephony/java/com/android/internal/telephony/Call.java index 82aeb25..70471b6 100644 --- a/telephony/java/com/android/internal/telephony/Call.java +++ b/telephony/java/com/android/internal/telephony/Call.java @@ -17,6 +17,7 @@ package com.android.internal.telephony; import java.util.List; + /** * {@hide} */ @@ -39,6 +40,13 @@ public abstract class Call { } } + + /* Instance Variables */ + + public State state = State.IDLE; + + + /* Instance Methods */ /** Do not modify the List result!!! This list is not yours to keep @@ -46,36 +54,46 @@ public abstract class Call { */ public abstract List<Connection> getConnections(); - public abstract State getState(); public abstract Phone getPhone(); + public abstract boolean isMultiparty(); + public abstract void hangup() throws CallStateException; + /** * hasConnection - * + * * @param c a Connection object * @return true if the call contains the connection object passed in */ public boolean hasConnection(Connection c) { return c.getCall() == this; } - + /** * hasConnections * @return true if the call contains one or more connections */ public boolean hasConnections() { List connections = getConnections(); - + if (connections == null) { return false; } - + return connections.size() > 0; } - + + /** + * getState + * @return state of class call + */ + public State getState() { + return state; + } + /** * isIdle - * + * * FIXME rename * @return true if the call contains only disconnected connections (if any) */ @@ -93,27 +111,27 @@ public abstract class Call { long time = Long.MAX_VALUE; Connection c; Connection earliest = null; - + l = getConnections(); - + if (l.size() == 0) { return null; } - + for (int i = 0, s = l.size() ; i < s ; i++) { c = (Connection) l.get(i); long t; - + t = c.getCreateTime(); - + if (t < time) { earliest = c; } } - + return earliest; } - + public long getEarliestCreateTime() { List l; @@ -160,9 +178,6 @@ public abstract class Call { return time; } - public abstract boolean isMultiparty(); - - public abstract void hangup() throws CallStateException; public boolean isDialingOrAlerting() { diff --git a/telephony/java/com/android/internal/telephony/gsm/CallForwardInfo.java b/telephony/java/com/android/internal/telephony/CallForwardInfo.java index bf31b13..8b853b0 100644 --- a/telephony/java/com/android/internal/telephony/gsm/CallForwardInfo.java +++ b/telephony/java/com/android/internal/telephony/CallForwardInfo.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; import android.telephony.PhoneNumberUtils; @@ -23,8 +23,7 @@ import android.telephony.PhoneNumberUtils; * * {@hide} */ -public class CallForwardInfo -{ +public class CallForwardInfo { public int status; /*1 = active, 0 = not active */ public int reason; /* from TS 27.007 7.11 "reason" */ public int serviceClass; /* Sum of CommandsInterface.SERVICE_CLASS */ @@ -32,8 +31,7 @@ public class CallForwardInfo public String number; /* "number" from TS 27.007 7.11 */ public int timeSeconds; /* for CF no reply only */ - public String toString() - { + public String toString() { return super.toString() + (status == 0 ? " not active " : " active ") + " reason: " + reason + " serviceClass: " + serviceClass diff --git a/telephony/java/com/android/internal/telephony/CallTracker.java b/telephony/java/com/android/internal/telephony/CallTracker.java new file mode 100644 index 0000000..eb339f8 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/CallTracker.java @@ -0,0 +1,123 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.util.Log; + +import com.android.internal.telephony.CommandException; + + +/** + * {@hide} + */ +public abstract class CallTracker extends Handler { + + private static final boolean DBG_POLL = false; + + //***** Constants + + static final int POLL_DELAY_MSEC = 250; + + protected int pendingOperations; + protected boolean needsPoll; + protected Message lastRelevantPoll; + + public CommandsInterface cm; + + + //***** Events + + protected static final int EVENT_POLL_CALLS_RESULT = 1; + protected static final int EVENT_CALL_STATE_CHANGE = 2; + protected static final int EVENT_REPOLL_AFTER_DELAY = 3; + protected static final int EVENT_OPERATION_COMPLETE = 4; + protected static final int EVENT_GET_LAST_CALL_FAIL_CAUSE = 5; + + protected static final int EVENT_SWITCH_RESULT = 8; + protected static final int EVENT_RADIO_AVAILABLE = 9; + protected static final int EVENT_RADIO_NOT_AVAILABLE = 10; + protected static final int EVENT_CONFERENCE_RESULT = 11; + protected static final int EVENT_SEPARATE_RESULT = 12; + protected static final int EVENT_ECT_RESULT = 13; + + + protected void pollCallsWhenSafe() { + needsPoll = true; + + if (checkNoOperationsPending()) { + lastRelevantPoll = obtainMessage(EVENT_POLL_CALLS_RESULT); + cm.getCurrentCalls(lastRelevantPoll); + } + } + + protected void + pollCallsAfterDelay() { + Message msg = obtainMessage(); + + msg.what = EVENT_REPOLL_AFTER_DELAY; + sendMessageDelayed(msg, POLL_DELAY_MSEC); + } + + protected boolean + isCommandExceptionRadioNotAvailable(Throwable e) { + return e != null && e instanceof CommandException + && ((CommandException)e).getCommandError() + == CommandException.Error.RADIO_NOT_AVAILABLE; + } + + protected abstract void handlePollCalls(AsyncResult ar); + + protected void handleRadioAvailable() { + pollCallsWhenSafe(); + } + + /** + * Obtain a complete message that indicates that this operation + * does not require polling of getCurrentCalls(). However, if other + * operations that do need getCurrentCalls() are pending or are + * scheduled while this operation is pending, the invocation + * of getCurrentCalls() will be postponed until this + * operation is also complete. + */ + protected Message + obtainNoPollCompleteMessage(int what) { + pendingOperations++; + lastRelevantPoll = null; + return obtainMessage(what); + } + + /** + * @return true if we're idle or there's a call to getCurrentCalls() pending + * but nothing else + */ + private boolean + checkNoOperationsPending() { + if (DBG_POLL) log("checkNoOperationsPending: pendingOperations=" + + pendingOperations); + return pendingOperations == 0; + } + + + //***** Overridden from Handler + public abstract void handleMessage (Message msg); + + protected abstract void log(String msg); + +} diff --git a/telephony/java/com/android/internal/telephony/CallerInfoAsyncQuery.java b/telephony/java/com/android/internal/telephony/CallerInfoAsyncQuery.java index 145e5d8..04da9f7 100644 --- a/telephony/java/com/android/internal/telephony/CallerInfoAsyncQuery.java +++ b/telephony/java/com/android/internal/telephony/CallerInfoAsyncQuery.java @@ -37,7 +37,7 @@ import android.util.Log; public class CallerInfoAsyncQuery { private static final boolean DBG = false; - private static final String LOG_TAG = "CallerInfoAsyncQuery"; + private static final String LOG_TAG = "PHONE"; private static final int EVENT_NEW_QUERY = 1; private static final int EVENT_ADD_LISTENER = 2; diff --git a/telephony/java/com/android/internal/telephony/gsm/CommandException.java b/telephony/java/com/android/internal/telephony/CommandException.java index 5cf48f3..a5d11cf 100644 --- a/telephony/java/com/android/internal/telephony/gsm/CommandException.java +++ b/telephony/java/com/android/internal/telephony/CommandException.java @@ -14,15 +14,16 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; + +import com.android.internal.telephony.RILConstants; import android.util.Log; /** * {@hide} */ -public class CommandException extends RuntimeException -{ +public class CommandException extends RuntimeException { private Error e; public enum Error { @@ -38,30 +39,28 @@ public class CommandException extends RuntimeException SMS_FAIL_RETRY, } - public CommandException(Error e) - { + public CommandException(Error e) { super(e.toString()); this.e = e; } public static CommandException - fromRilErrno(int ril_errno) - { + fromRilErrno(int ril_errno) { switch(ril_errno) { case RILConstants.SUCCESS: return null; - case RILConstants.RIL_ERRNO_INVALID_RESPONSE: + case RILConstants.RIL_ERRNO_INVALID_RESPONSE: return new CommandException(Error.INVALID_RESPONSE); - case RILConstants.RADIO_NOT_AVAILABLE: + case RILConstants.RADIO_NOT_AVAILABLE: return new CommandException(Error.RADIO_NOT_AVAILABLE); - case RILConstants.GENERIC_FAILURE: + case RILConstants.GENERIC_FAILURE: return new CommandException(Error.GENERIC_FAILURE); - case RILConstants.PASSWORD_INCORRECT: + case RILConstants.PASSWORD_INCORRECT: return new CommandException(Error.PASSWORD_INCORRECT); - case RILConstants.SIM_PIN2: + case RILConstants.SIM_PIN2: return new CommandException(Error.SIM_PIN2); - case RILConstants.SIM_PUK2: + case RILConstants.SIM_PUK2: return new CommandException(Error.SIM_PUK2); - case RILConstants.REQUEST_NOT_SUPPORTED: + case RILConstants.REQUEST_NOT_SUPPORTED: return new CommandException(Error.REQUEST_NOT_SUPPORTED); case RILConstants.OP_NOT_ALLOWED_DURING_VOICE_CALL: return new CommandException(Error.OP_NOT_ALLOWED_DURING_VOICE_CALL); @@ -75,8 +74,7 @@ public class CommandException extends RuntimeException } } - public Error getCommandError() - { + public Error getCommandError() { return e; } diff --git a/telephony/java/com/android/internal/telephony/gsm/CommandsInterface.java b/telephony/java/com/android/internal/telephony/CommandsInterface.java index 7915798..aec7238 100644 --- a/telephony/java/com/android/internal/telephony/gsm/CommandsInterface.java +++ b/telephony/java/com/android/internal/telephony/CommandsInterface.java @@ -14,50 +14,79 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; -import com.android.internal.telephony.*; +package com.android.internal.telephony; + import android.os.Message; import android.os.Handler; + /** * {@hide} */ -public interface CommandsInterface -{ +public interface CommandsInterface { enum RadioState { RADIO_OFF, /* Radio explictly powered off (eg CFUN=0) */ RADIO_UNAVAILABLE, /* Radio unavailable (eg, resetting or not booted) */ SIM_NOT_READY, /* Radio is on, but the SIM interface is not ready */ - SIM_LOCKED_OR_ABSENT, /* SIM PIN locked, PUK required, network + SIM_LOCKED_OR_ABSENT, /* SIM PIN locked, PUK required, network personalization, or SIM absent */ - SIM_READY; /* Radio is on and SIM interface is available */ - - boolean isOn() /* and available...*/ - { + SIM_READY, /* Radio is on and SIM interface is available */ + RUIM_NOT_READY, /* Radio is on, but the RUIM interface is not ready */ + RUIM_READY, /* Radio is on and the RUIM interface is available */ + RUIM_LOCKED_OR_ABSENT, /* RUIM PIN locked, PUK required, network + personalization locked, or RUIM absent */ + NV_NOT_READY, /* Radio is on, but the NV interface is not available */ + NV_READY; /* Radio is on and the NV interface is available */ + + public boolean isOn() /* and available...*/ { return this == SIM_NOT_READY || this == SIM_LOCKED_OR_ABSENT - || this == SIM_READY; + || this == SIM_READY + || this == RUIM_NOT_READY + || this == RUIM_READY + || this == RUIM_LOCKED_OR_ABSENT + || this == NV_NOT_READY + || this == NV_READY; } - boolean isAvailable() - { + public boolean isAvailable() { return this != RADIO_UNAVAILABLE; } - boolean isSIMReady() - { - // if you add new states after SIM_READY, include them too + public boolean isSIMReady() { return this == SIM_READY; } + + public boolean isRUIMReady() { + return this == RUIM_READY; + } + + public boolean isNVReady() { + return this == NV_READY; + } + + public boolean isGsm() { + return this == SIM_NOT_READY + || this == SIM_LOCKED_OR_ABSENT + || this == SIM_READY; + } + + public boolean isCdma() { + return this == RUIM_NOT_READY + || this == RUIM_READY + || this == RUIM_LOCKED_OR_ABSENT + || this == NV_NOT_READY + || this == NV_READY; + } } - enum SimStatus { - SIM_ABSENT, - SIM_NOT_READY, - SIM_READY, - SIM_PIN, - SIM_PUK, - SIM_NETWORK_PERSONALIZATION + enum IccStatus { + ICC_ABSENT, + ICC_NOT_READY, + ICC_READY, + ICC_PIN, + ICC_PUK, + ICC_NETWORK_PERSONALIZATION } //***** Constants @@ -93,7 +122,7 @@ public interface CommandsInterface static final String CB_FACILITY_BA_MT = "AC"; static final String CB_FACILITY_BA_SIM = "SC"; static final String CB_FACILITY_BA_FD = "FD"; - + // Used for various supp services apis // See 27.007 +CCFC or +CLCK @@ -102,7 +131,7 @@ public interface CommandsInterface static final int SERVICE_CLASS_DATA = (1 << 1); //synoym for 16+32+64+128 static final int SERVICE_CLASS_FAX = (1 << 2); static final int SERVICE_CLASS_SMS = (1 << 3); - static final int SERVICE_CLASS_DATA_SYNC = (1 << 4); + static final int SERVICE_CLASS_DATA_SYNC = (1 << 4); static final int SERVICE_CLASS_DATA_ASYNC = (1 << 5); static final int SERVICE_CLASS_PACKET = (1 << 6); static final int SERVICE_CLASS_PAD = (1 << 7); @@ -122,8 +151,8 @@ public interface CommandsInterface RadioState getRadioState(); - /** - * Fires on any RadioState transition + /** + * Fires on any RadioState transition * Always fires immediately as well * * do not attempt to calculate transitions by storing getRadioState() values @@ -131,58 +160,85 @@ public interface CommandsInterface * registration methods */ void registerForRadioStateChanged(Handler h, int what, Object obj); + void unregisterForRadioStateChanged(Handler h); - /** - * Fires on any transition into RadioState.isOn() + /** + * Fires on any transition into RadioState.isOn() * Fires immediately if currently in that state * In general, actions should be idempotent. State may change * before event is received. */ void registerForOn(Handler h, int what, Object obj); + void unregisterForOn(Handler h); - /** - * Fires on any transition out of RadioState.isAvailable() + /** + * Fires on any transition out of RadioState.isAvailable() * Fires immediately if currently in that state * In general, actions should be idempotent. State may change * before event is received. */ void registerForAvailable(Handler h, int what, Object obj); - //void unregisterForAvailable(Handler h); - /** + void unregisterForAvailable(Handler h); + + /** * Fires on any transition into !RadioState.isAvailable() * Fires immediately if currently in that state * In general, actions should be idempotent. State may change * before event is received. */ void registerForNotAvailable(Handler h, int what, Object obj); - //void unregisterForNotAvailable(Handler h); - /** + void unregisterForNotAvailable(Handler h); + + /** * Fires on any transition into RADIO_OFF or !RadioState.isAvailable() * Fires immediately if currently in that state * In general, actions should be idempotent. State may change * before event is received. */ void registerForOffOrNotAvailable(Handler h, int what, Object obj); - //void unregisterForNotAvailable(Handler h); + void unregisterForOffOrNotAvailable(Handler h); - /** + /** * Fires on any transition into SIM_READY * Fires immediately if if currently in that state * In general, actions should be idempotent. State may change * before event is received. */ void registerForSIMReady(Handler h, int what, Object obj); - //void unregisterForSIMReady(Handler h); + void unregisterForSIMReady(Handler h); + /** Any transition into SIM_LOCKED_OR_ABSENT */ void registerForSIMLockedOrAbsent(Handler h, int what, Object obj); - //void unregisterForSIMLockedOrAbsent(Handler h); + void unregisterForSIMLockedOrAbsent(Handler h); void registerForCallStateChanged(Handler h, int what, Object obj); - //void unregisterForCallStateChanged(Handler h); + void unregisterForCallStateChanged(Handler h); void registerForNetworkStateChanged(Handler h, int what, Object obj); - //void unregisterForNetworkStateChanged(Handler h); - void registerForPDPStateChanged(Handler h, int what, Object obj); - //void unregisterForPDPStateChanged(Handler h); + void unregisterForNetworkStateChanged(Handler h); + void registerForDataStateChanged(Handler h, int what, Object obj); + void unregisterForDataStateChanged(Handler h); + + void registerForRadioTechnologyChanged(Handler h, int what, Object obj); + void unregisterForRadioTechnologyChanged(Handler h); + void registerForNVReady(Handler h, int what, Object obj); + void unregisterForNVReady(Handler h); + void registerForRUIMLockedOrAbsent(Handler h, int what, Object obj); + void unregisterForRUIMLockedOrAbsent(Handler h); + + /** InCall voice privacy notifications */ + void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj); + void unregisterForInCallVoicePrivacyOn(Handler h); + void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj); + void unregisterForInCallVoicePrivacyOff(Handler h); + + /** + * Fires on any transition into RUIM_READY + * Fires immediately if if currently in that state + * In general, actions should be idempotent. State may change + * before event is received. + */ + void registerForRUIMReady(Handler h, int what, Object obj); + void unregisterForRUIMReady(Handler h); /** * unlike the register* methods, there's only one new SMS handler @@ -192,21 +248,24 @@ public interface CommandsInterface * AsyncResult.result is a String containing the SMS PDU */ void setOnNewSMS(Handler h, int what, Object obj); + void unSetOnNewSMS(Handler h); /** - * Register for NEW_SMS_ON_SIM unsolicited message + * Register for NEW_SMS_ON_SIM unsolicited message * * AsyncResult.result is an int array containing the index of new SMS */ void setOnSmsOnSim(Handler h, int what, Object obj); + void unSetOnSmsOnSim(Handler h); /** - * Register for NEW_SMS_STATUS_REPORT unsolicited message + * Register for NEW_SMS_STATUS_REPORT unsolicited message * * AsyncResult.result is a String containing the status report PDU */ void setOnSmsStatus(Handler h, int what, Object obj); - + void unSetOnSmsStatus(Handler h); + /** * unlike the register* methods, there's only one NITZ time handler * @@ -220,13 +279,14 @@ public interface CommandsInterface * seconds on system startup */ void setOnNITZTime(Handler h, int what, Object obj); + void unSetOnNITZTime(Handler h); /** * unlike the register* methods, there's only one USSD notify handler * * Represents the arrival of a USSD "notify" message, which may * or may not have been triggered by a previous USSD send - * + * * AsyncResult.result is a String[] * ((String[])(AsyncResult.result))[0] contains status code * "0" USSD-Notify -- text in ((const char **)data)[1] @@ -241,26 +301,29 @@ public interface CommandsInterface */ void setOnUSSD(Handler h, int what, Object obj); + void unSetOnUSSD(Handler h); /** * unlike the register* methods, there's only one signal strength handler - * AsyncResult.result is an int[2] - * response.obj.result[0] is received signal strength (0-31, 99) - * response.obj.result[1] is bit error rate (0-7, 99) + * AsyncResult.result is an int[2] + * response.obj.result[0] is received signal strength (0-31, 99) + * response.obj.result[1] is bit error rate (0-7, 99) * as defined in TS 27.007 8.5 */ void setOnSignalStrengthUpdate(Handler h, int what, Object obj); + void unSetOnSignalStrengthUpdate(Handler h); /** - * Sets the handler for SIM SMS storage full unsolicited message. + * Sets the handler for SIM/RUIM SMS storage full unsolicited message. * Unlike the register* methods, there's only one notification handler * * @param h Handler for notification message. * @param what User-defined message code. * @param obj User object. */ - void setOnSimSmsFull(Handler h, int what, Object obj); + void setOnIccSmsFull(Handler h, int what, Object obj); + void unSetOnIccSmsFull(Handler h); /** * Sets the handler for SIM Refresh notifications. @@ -270,8 +333,9 @@ public interface CommandsInterface * @param what User-defined message code. * @param obj User object. */ - void setOnSimRefresh(Handler h, int what, Object obj); - + void setOnIccRefresh(Handler h, int what, Object obj); + void unSetOnIccRefresh(Handler h); + /** * Sets the handler for RING notifications. * Unlike the register* methods, there's only one notification handler @@ -281,7 +345,8 @@ public interface CommandsInterface * @param obj User object. */ void setOnCallRing(Handler h, int what, Object obj); - + void unSetOnCallRing(Handler h); + /** * Sets the handler for RESTRICTED_STATE changed notification, * eg, for Domain Specific Access Control @@ -292,7 +357,8 @@ public interface CommandsInterface */ void setOnRestrictedStateChanged(Handler h, int what, Object obj); - + void unSetOnRestrictedStateChanged(Handler h); + /** * Sets the handler for Supplementary Service Notifications. * Unlike the register* methods, there's only one notification handler @@ -302,6 +368,7 @@ public interface CommandsInterface * @param obj User object. */ void setOnSuppServiceNotification(Handler h, int what, Object obj); + void unSetOnSuppServiceNotification(Handler h); /** * Sets the handler for Session End Notifications for STK. @@ -312,6 +379,7 @@ public interface CommandsInterface * @param obj User object. */ void setOnStkSessionEnd(Handler h, int what, Object obj); + void unSetOnStkSessionEnd(Handler h); /** * Sets the handler for Proactive Commands for STK. @@ -322,6 +390,7 @@ public interface CommandsInterface * @param obj User object. */ void setOnStkProactiveCmd(Handler h, int what, Object obj); + void unSetOnStkProactiveCmd(Handler h); /** * Sets the handler for Event Notifications for STK. @@ -332,6 +401,7 @@ public interface CommandsInterface * @param obj User object. */ void setOnStkEvent(Handler h, int what, Object obj); + void unSetOnStkEvent(Handler h); /** * Sets the handler for Call Set Up Notifications for STK. @@ -342,6 +412,7 @@ public interface CommandsInterface * @param obj User object. */ void setOnStkCallSetUp(Handler h, int what, Object obj); + void unSetOnStkCallSetUp(Handler h); /** * Enables/disbables supplementary service related notifications from @@ -351,19 +422,21 @@ public interface CommandsInterface * @param result Message to be posted when command completes. */ void setSuppServiceNotifications(boolean enable, Message result); + //void unSetSuppServiceNotifications(Handler h); + /** - * Returns current SIM status. + * Returns current ICC status. + * + * AsyncResult.result is IccStatus * - * AsyncResult.result is SimStatus - * */ - void getSimStatus(Message result); + void getIccStatus(Message result); /** - * Supply the SIM PIN to the SIM card - * + * Supply the ICC PIN to the ICC card + * * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure @@ -373,11 +446,11 @@ public interface CommandsInterface * ar.exception and ar.result are null on success */ - void supplySimPin(String pin, Message result); + void supplyIccPin(String pin, Message result); /** - * Supply the SIM PUK to the SIM card - * + * Supply the ICC PUK to the ICC card + * * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure @@ -387,13 +460,13 @@ public interface CommandsInterface * ar.exception and ar.result are null on success */ - void supplySimPuk(String puk, String newPin, Message result); + void supplyIccPuk(String puk, String newPin, Message result); /** - * Supply the SIM PIN2 to the SIM card - * Only called following operation where SIM_PIN2 was + * Supply the ICC PIN2 to the ICC card + * Only called following operation where ICC_PIN2 was * returned as a a failure from a previous operation - * + * * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure @@ -403,13 +476,13 @@ public interface CommandsInterface * ar.exception and ar.result are null on success */ - void supplySimPin2(String pin2, Message result); + void supplyIccPin2(String pin2, Message result); /** * Supply the SIM PUK2 to the SIM card * Only called following operation where SIM_PUK2 was * returned as a a failure from a previous operation - * + * * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure @@ -419,16 +492,16 @@ public interface CommandsInterface * ar.exception and ar.result are null on success */ - void supplySimPuk2(String puk2, String newPin2, Message result); + void supplyIccPuk2(String puk2, String newPin2, Message result); - void changeSimPin(String oldPin, String newPin, Message result); - void changeSimPin2(String oldPin2, String newPin2, Message result); + void changeIccPin(String oldPin, String newPin, Message result); + void changeIccPin2(String oldPin2, String newPin2, Message result); void changeBarringPassword(String facility, String oldPwd, String newPwd, Message result); void supplyNetworkDepersonalization(String netpin, Message result); - /** + /** * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure @@ -438,16 +511,26 @@ public interface CommandsInterface */ void getCurrentCalls (Message result); - /** + /** * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure * ar.userObject contains the orignal value of result.obj * ar.result contains a List of PDPContextState + * @deprecated */ void getPDPContextList(Message result); - /** + /** + * returned message + * retMsg.obj = AsyncResult ar + * ar.exception carries exception on failure + * ar.userObject contains the orignal value of result.obj + * ar.result contains a List of PDPContextState + */ + void getDataCallList(Message result); + + /** * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure @@ -460,7 +543,7 @@ public interface CommandsInterface */ void dial (String address, int clirMode, Message result); - /** + /** * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure @@ -469,7 +552,7 @@ public interface CommandsInterface */ void getIMSI(Message result); - /** + /** * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure @@ -478,7 +561,7 @@ public interface CommandsInterface */ void getIMEI(Message result); - /** + /** * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure @@ -487,7 +570,7 @@ public interface CommandsInterface */ void getIMEISV(Message result); - /** + /** * Hang up one individual connection. * returned message * retMsg.obj = AsyncResult ar @@ -512,7 +595,7 @@ public interface CommandsInterface /** * 3GPP 22.030 6.5.5 - * "Releases all active calls (if any exist) and accepts + * "Releases all active calls (if any exist) and accepts * the other (held or waiting) call." * * ar.exception carries exception on failure @@ -523,7 +606,7 @@ public interface CommandsInterface /** * 3GPP 22.030 6.5.5 - * "Places all active calls (if any exist) on hold and accepts + * "Places all active calls (if any exist) on hold and accepts * the other (held or waiting) call." * * ar.exception carries exception on failure @@ -539,12 +622,27 @@ public interface CommandsInterface * ar.exception carries exception on failure * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure - */ + */ void conference (Message result); /** + * Set preferred Voice Privacy (VP). + * + * @param enable true is enhanced and false is normal VP + * @param result is a callback message + */ + void setPreferredVoicePrivacy(boolean enable, Message result); + + /** + * Get currently set preferred Voice Privacy (VP) mode. + * + * @param result is a callback message + */ + void getPreferredVoicePrivacy(Message result); + + /** * 3GPP 22.030 6.5.5 - * "Places all active calls on hold except call X with which + * "Places all active calls on hold except call X with which * communication shall be supported." */ void separateConnection (int gsmIndex, Message result); @@ -554,15 +652,15 @@ public interface CommandsInterface * ar.exception carries exception on failure * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure - */ + */ void acceptCall (Message result); - /** + /** * also known as UDUB * ar.exception carries exception on failure * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure - */ + */ void rejectCall (Message result); /** @@ -586,14 +684,21 @@ public interface CommandsInterface void getLastCallFailCause (Message result); - /** + /** * Reason for last PDP context deactivate or failure to activate * cause code returned as int[0] in Message.obj.response * returns an integer cause code defined in TS 24.008 * section 6.1.3.1.3 or close approximation + * @deprecated */ void getLastPdpFailCause (Message result); + /** + * The preferred new alternative to getLastPdpFailCause + * that is also CDMA-compatible. + */ + void getLastDataCallFailCause (Message result); + void setMute (boolean enableMute, Message response); void getMute (Message response); @@ -601,8 +706,8 @@ public interface CommandsInterface /** * response.obj is an AsyncResult * response.obj.result is an int[2] - * response.obj.result[0] is received signal strength (0-31, 99) - * response.obj.result[1] is bit error rate (0-7, 99) + * response.obj.result[0] is received signal strength (0-31, 99) + * response.obj.result[1] is bit error rate (0-7, 99) * as defined in TS 27.007 8.5 */ void getSignalStrength (Message response); @@ -612,21 +717,21 @@ public interface CommandsInterface * response.obj.result is an int[3] * response.obj.result[0] is registration state 0-5 from TS 27.007 7.2 * response.obj.result[1] is LAC if registered or -1 if not - * response.obj.result[2] is CID if registered or -1 if not + * response.obj.result[2] is CID if registered or -1 if not * valid LAC and CIDs are 0x0000 - 0xffff - * + * * Please note that registration state 4 ("unknown") is treated * as "out of service" above */ void getRegistrationState (Message response); - + /** * response.obj.result is an int[3] * response.obj.result[0] is registration state 0-5 from TS 27.007 7.2 * response.obj.result[1] is LAC if registered or -1 if not - * response.obj.result[2] is CID if registered or -1 if not + * response.obj.result[2] is CID if registered or -1 if not * valid LAC and CIDs are 0x0000 - 0xffff - * + * * Please note that registration state 4 ("unknown") is treated * as "out of service" above */ @@ -637,14 +742,14 @@ public interface CommandsInterface * response.obj.result[0] is long alpha or null if unregistered * response.obj.result[1] is short alpha or null if unregistered * response.obj.result[2] is numeric or null if unregistered - */ + */ void getOperator(Message response); /** * ar.exception carries exception on failure * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure - */ + */ void sendDtmf(char c, Message result); @@ -667,26 +772,40 @@ public interface CommandsInterface * smscPDU is smsc address in PDU form GSM BCD format prefixed * by a length byte (as expected by TS 27.005) or NULL for default SMSC * pdu is SMS in PDU format as an ASCII hex string - * less the SMSC address + * less the SMSC address */ void sendSMS (String smscPDU, String pdu, Message response); /** + * @param pdu is CDMA-SMS in internal pseudo-PDU format + * @param response sent when operation completes + */ + void sendCdmaSms(byte[] pdu, Message response); + + /** * Deletes the specified SMS record from SIM memory (EF_SMS). - * + * * @param index index of the SMS record to delete * @param response sent when operation completes */ void deleteSmsOnSim(int index, Message response); /** + * Deletes the specified SMS record from RUIM memory (EF_SMS in DF_CDMA). + * + * @param index index of the SMS record to delete + * @param response sent when operation completes + */ + void deleteSmsOnRuim(int index, Message response); + + /** * Writes an SMS message to SIM memory (EF_SMS). - * + * * @param status status of message on SIM. One of: - * SmsManger.STATUS_ON_SIM_READ - * SmsManger.STATUS_ON_SIM_UNREAD - * SmsManger.STATUS_ON_SIM_SENT - * SmsManger.STATUS_ON_SIM_UNSENT + * SmsManger.STATUS_ON_ICC_READ + * SmsManger.STATUS_ON_ICC_UNREAD + * SmsManger.STATUS_ON_ICC_SENT + * SmsManger.STATUS_ON_ICC_UNSENT * @param pdu message PDU, as hex string * @param response sent when operation completes. * response.obj will be an AsyncResult, and will indicate @@ -694,89 +813,105 @@ public interface CommandsInterface */ void writeSmsToSim(int status, String smsc, String pdu, Message response); + void writeSmsToRuim(int status, String pdu, Message response); + + /** + * @deprecated + * @param apn + * @param user + * @param password + * @param response + */ void setupDefaultPDP(String apn, String user, String password, Message response); + /** + * @deprecated + * @param cid + * @param response + */ void deactivateDefaultPDP(int cid, Message response); void setRadioPower(boolean on, Message response); void acknowledgeLastIncomingSMS(boolean success, Message response); - /** - * parameters equivilient to 27.007 AT+CRSM command + void acknowledgeLastIncomingCdmaSms(boolean success, Message response); + + /** + * parameters equivilient to 27.007 AT+CRSM command * response.obj will be an AsyncResult - * response.obj.userObj will be a SimIoResult on success + * response.obj.userObj will be a IccIoResult on success */ - void simIO (int command, int fileid, String path, int p1, int p2, int p3, + void iccIO (int command, int fileid, String path, int p1, int p2, int p3, String data, String pin2, Message response); /** * (AsyncResult)response.obj).result is an int[] with element [0] set to - * 1 for "CLIP is provisioned", and 0 for "CLIP is not provisioned". + * 1 for "CLIP is provisioned", and 0 for "CLIP is not provisioned". * * @param response is callback message */ - + void queryCLIP(Message response); /** * response.obj will be a an int[2] * * response.obj[0] will be TS 27.007 +CLIR parameter 'n' - * 0 presentation indicator is used according to the subscription of the CLIR service - * 1 CLIR invocation - * 2 CLIR suppression + * 0 presentation indicator is used according to the subscription of the CLIR service + * 1 CLIR invocation + * 2 CLIR suppression * * response.obj[1] will be TS 27.007 +CLIR parameter 'm' - * 0 CLIR not provisioned - * 1 CLIR provisioned in permanent mode - * 2 unknown (e.g. no network, etc.) - * 3 CLIR temporary mode presentation restricted - * 4 CLIR temporary mode presentation allowed + * 0 CLIR not provisioned + * 1 CLIR provisioned in permanent mode + * 2 unknown (e.g. no network, etc.) + * 3 CLIR temporary mode presentation restricted + * 4 CLIR temporary mode presentation allowed */ void getCLIR(Message response); - + /** * clirMode is one of the CLIR_* constants above * * response.obj is null */ - + void setCLIR(int clirMode, Message response); /** * (AsyncResult)response.obj).result is an int[] with element [0] set to - * 0 for disabled, 1 for enabled. + * 0 for disabled, 1 for enabled. * * @param serviceClass is a sum of SERVICE_CLASS_* * @param response is callback message */ - + void queryCallWaiting(int serviceClass, Message response); - + /** * @param enable is true to enable, false to disable * @param serviceClass is a sum of SERVICE_CLASS_* * @param response is callback message */ - + void setCallWaiting(boolean enable, int serviceClass, Message response); /** * @param action is one of CF_ACTION_* * @param cfReason is one of CF_REASON_* - * @param serviceClass is a sum of SERVICE_CLASSS_* + * @param serviceClass is a sum of SERVICE_CLASSS_* */ - void setCallForward(int action, int cfReason, int serviceClass, - String number, int timeSeconds, Message response); + void setCallForward(int action, int cfReason, int serviceClass, + String number, int timeSeconds, Message response); /** * cfReason is one of CF_REASON_* * * ((AsyncResult)response.obj).result will be an array of * CallForwardInfo's - * + * * An array of length 0 means "disabled for all codes" */ void queryCallForwardStatus(int cfReason, int serviceClass, @@ -815,7 +950,7 @@ public interface CommandsInterface * @param serviceClass is a sum of SERVICE_CLASS_* * @param response is callback message */ - + void queryFacilityLock (String facility, String password, int serviceClass, Message response); @@ -828,7 +963,7 @@ public interface CommandsInterface */ void setFacilityLock (String facility, boolean lockState, String password, int serviceClass, Message response); - + void sendUSSD (String ussdString, Message response); @@ -850,7 +985,7 @@ public interface CommandsInterface /** * 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 @@ -923,4 +1058,136 @@ public interface CommandsInterface * @param response Callback message */ public void handleCallSetupRequestFromSim(boolean accept, Message response); + + //***** new Methods for CDMA support + + /** + * Request the device ESN / MEID / IMEI / IMEISV. + * "response" is const char ** + * [0] is IMEI if GSM subscription is available + * [1] is IMEISV if GSM subscription is available + * [2] is ESN if CDMA subscription is available + * [3] is MEID if CDMA subscription is available + */ + public void getDeviceIdentity(Message response); + + /** + * Request the device IMSI_M / MDN / AH_SID / H_SID / H_NID. + * "response" is const char ** + * [0] is IMSI_M if CDMA subscription is available + * [1] is MDN if CDMA subscription is available + * [2] is AH_SID (Analog Home SID) if CDMA subscription + * [3] is H_SID (Home SID) if CDMA subscription is available + * [4] is H_NID (Home SID) if CDMA subscription is available + */ + public void getCDMASubscription(Message response); + + /** + * Send Flash Code. + * "response" is is NULL + * [0] is a FLASH string + */ + public void sendCDMAFeatureCode(String FeatureCode, Message response); + + /** Set the Phone type created */ + void setPhoneType(int phoneType); + /** + * Query the CDMA roaming preference setting + * + * @param response is callback message to report one of CDMA_RM_* + */ + void queryCdmaRoamingPreference(Message response); + + /** + * Requests to set the CDMA roaming preference + * @param cdmaRoamingType one of CDMA_RM_* + * @param response is callback message + */ + void setCdmaRoamingPreference(int cdmaRoamingType, Message response); + + /** + * Requests to set the CDMA subscription mode + * @param cdmaSubscriptionType one of CDMA_SUBSCRIPTION_* + * @param response is callback message + */ + void setCdmaSubscription(int cdmaSubscriptionType, Message response); + + /** + * Set the TTY mode for the CDMA phone + * + * @param enable is true to enable, false to disable + * @param response is callback message + */ + void setTTYModeEnabled(boolean enable, Message response); + + /** + * Query the TTY mode for the CDMA phone + * (AsyncResult)response.obj).result is an int[] with element [0] set to + * 0 for disabled, 1 for enabled. + * + * @param response is callback message + */ + void queryTTYModeEnabled(Message response); + + /** + * Setup a packet data connection On successful completion, the result + * message will return the following: [0] indicating PDP CID, which is + * generated by RIL. This Connection ID is used in both GSM/UMTS and CDMA + * modes [1] indicating the network interface name for GSM/UMTS or CDMA [2] + * indicating the IP address for this interface for GSM/UMTS and NULL in the + * case of CDMA + * + * @param radioTechnology + * indicates whether to setup connection on radio technology CDMA + * (0) or GSM/UMTS (1) + * @param profile + * Profile Number or NULL to indicate default profile + * @param apn + * the APN to connect to if radio technology is GSM/UMTS. + * Otherwise null for CDMA. + * @param user + * the username for APN, or NULL + * @param password + * the password for APN, or NULL + * @param result + * Callback message + */ + public void setupDataCall(String radioTechnology, String profile, String apn, + String user, String password, Message result); + + /** + * Deactivate packet data connection + * + * @param cid + * The connection ID + * @param result + * Callback message is empty on completion + */ + public void deactivateDataCall(int cid, Message result); + + /** + * Activate or deactivate cell broadcast SMS. + * + * @param activate + * 0 = activate, 1 = deactivate + * @param result + * Callback message is empty on completion + */ + public void activateCdmaBroadcastSms(int activate, Message result); + + /** + * Configure cdma cell broadcast SMS. + * + * @param result + * Callback message is empty on completion + */ + public void setCdmaBroadcastConfig(int[] configValuesArray, Message result); + + /** + * Query the current configuration of cdma cell broadcast SMS. + * + * @param result + * Callback message contains the configuration from the modem on completion + */ + public void getCdmaBroadcastConfig(Message result); } diff --git a/telephony/java/com/android/internal/telephony/Connection.java b/telephony/java/com/android/internal/telephony/Connection.java index ead49bf..86ceb89 100644 --- a/telephony/java/com/android/internal/telephony/Connection.java +++ b/telephony/java/com/android/internal/telephony/Connection.java @@ -19,8 +19,8 @@ package com.android.internal.telephony; /** * {@hide} */ -public abstract class Connection -{ +public abstract class Connection { + // Number presentation type for caller id display public static int PRESENTATION_ALLOWED = 1; // normal public static int PRESENTATION_RESTRICTED = 2; // block by user @@ -42,7 +42,7 @@ public abstract class Connection INCOMING_REJECTED, /* an incoming call that was rejected */ POWER_OFF, /* radio is turned off explicitly */ OUT_OF_SERVICE, /* out of service */ - SIM_ERROR, /* No SIM, SIM locked, or other SIM error */ + ICC_ERROR, /* No ICC, ICC locked, or other ICC error */ CALL_BARRED, /* call was blocked by call barrring */ FDN_BLOCKED, /* call was blocked by fixed dial number */ CS_RESTRICTED, /* call was blocked by restricted all voice access */ @@ -54,7 +54,7 @@ public abstract class Connection /* Instance Methods */ - /** + /** * Gets address (e.g., phone number) associated with connection * TODO: distinguish reasons for unavailablity * @@ -92,7 +92,7 @@ public abstract class Connection public abstract long getDisconnectTime(); /** - * returns the number of milliseconds the call has been connected, + * returns the number of milliseconds the call has been connected, * or 0 if the call has never connected. * If the call is still connected, then returns the elapsed * time since connect @@ -113,8 +113,8 @@ public abstract class Connection public abstract DisconnectCause getDisconnectCause(); /** - * Returns true of this connection originated elsewhere - * ("MT" or mobile terminated; another party called this terminal) + * Returns true of this connection originated elsewhere + * ("MT" or mobile terminated; another party called this terminal) * or false if this call originated here (MO or mobile originated) */ public abstract boolean isIncoming(); @@ -122,32 +122,30 @@ public abstract class Connection /** * If this Connection is connected, then it is associated with * a Call. - * + * * Returns getCall().getState() or Call.State.IDLE if not * connected */ - public Call.State getState() - { + public Call.State getState() { Call c; c = getCall(); - if (c == null) { + if (c == null) { return Call.State.IDLE; } else { return c.getState(); } } - + /** * isAlive() - * + * * @return true if the connection isn't disconnected * (could be active, holding, ringing, dialing, etc) */ public boolean - isAlive() - { + isAlive() { return getState().isAlive(); } @@ -155,29 +153,26 @@ public abstract class Connection * Returns true if Connection is connected and is INCOMING or WAITING */ public boolean - isRinging() - { + isRinging() { return getState().isRinging(); } /** - * + * * @return the userdata set in setUserData() */ - public Object getUserData() - { + public Object getUserData() { return userData; } /** - * + * * @param userdata user can store an any userdata in the Connection object. */ - public void setUserData(Object userdata) - { + public void setUserData(Object userdata) { this.userData = userdata; } - + /** * Hangup individual Connection */ @@ -191,16 +186,16 @@ public abstract class Connection public abstract void separate() throws CallStateException; public enum PostDialState { - NOT_STARTED, /* The post dial string playback hasn't - been started, or this call is not yet + NOT_STARTED, /* The post dial string playback hasn't + been started, or this call is not yet connected, or this is an incoming call */ STARTED, /* The post dial string playback has begun */ - WAIT, /* The post dial string playback is waiting for a + WAIT, /* The post dial string playback is waiting for a call to proceedAfterWaitChar() */ - WILD, /* The post dial string playback is waiting for a + WILD, /* The post dial string playback is waiting for a call to proceedAfterWildChar() */ COMPLETE, /* The post dial string playback is complete */ - CANCELLED /* The post dial string playback was cancelled + CANCELLED /* The post dial string playback was cancelled with cancelPostDial() */ } @@ -215,7 +210,7 @@ public abstract class Connection /** * See Phone.setOnPostDialWaitCharacter() */ - + public abstract void proceedAfterWaitChar(); /** @@ -232,5 +227,5 @@ public abstract class Connection * @return one of PRESENTATION_* */ public abstract int getNumberPresentation(); - + } diff --git a/telephony/java/com/android/internal/telephony/DataConnection.java b/telephony/java/com/android/internal/telephony/DataConnection.java new file mode 100644 index 0000000..6e9d1ab --- /dev/null +++ b/telephony/java/com/android/internal/telephony/DataConnection.java @@ -0,0 +1,299 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.util.Log; + +/** + * {@hide} + */ +public abstract class DataConnection extends Handler { + + // the inherited class + + public enum State { + ACTIVE, /* has active data connection */ + ACTIVATING, /* during connecting process */ + INACTIVE; /* has empty data connection */ + + public String toString() { + switch (this) { + case ACTIVE: + return "active"; + case ACTIVATING: + return "setting up"; + default: + return "inactive"; + } + } + + public boolean isActive() { + return this == ACTIVE; + } + + public boolean isInactive() { + return this == INACTIVE; + } + } + + public enum FailCause { + NONE, + BAD_APN, + BAD_PAP_SECRET, + BARRED, + USER_AUTHENTICATION, + SERVICE_OPTION_NOT_SUPPORTED, + SERVICE_OPTION_NOT_SUBSCRIBED, + SIM_LOCKED, + RADIO_OFF, + NO_SIGNAL, + NO_DATA_PLAN, + RADIO_NOT_AVAILABLE, + SUSPENED_TEMPORARY, + RADIO_ERROR_RETRY, + UNKNOWN; + + public boolean isPermanentFail() { + return (this == RADIO_OFF); + } + + public String toString() { + switch (this) { + case NONE: + return "no error"; + case BAD_APN: + return "bad apn"; + case BAD_PAP_SECRET: + return "bad pap secret"; + case BARRED: + return "barred"; + case USER_AUTHENTICATION: + return "error user autentication"; + case SERVICE_OPTION_NOT_SUPPORTED: + return "data not supported"; + case SERVICE_OPTION_NOT_SUBSCRIBED: + return "datt not subcribed"; + case SIM_LOCKED: + return "sim locked"; + case RADIO_OFF: + return "radio is off"; + case NO_SIGNAL: + return "no signal"; + case NO_DATA_PLAN: + return "no data plan"; + case RADIO_NOT_AVAILABLE: + return "radio not available"; + case SUSPENED_TEMPORARY: + return "suspend temporary"; + case RADIO_ERROR_RETRY: + return "transient radio error"; + default: + return "unknown data error"; + } + } + } + + // ***** Event codes + protected static final int EVENT_SETUP_DATA_CONNECTION_DONE = 1; + protected static final int EVENT_GET_LAST_FAIL_DONE = 2; + protected static final int EVENT_LINK_STATE_CHANGED = 3; + protected static final int EVENT_DEACTIVATE_DONE = 4; + protected static final int EVENT_FORCE_RETRY = 5; + + //***** Tag IDs for EventLog + protected static final int EVENT_LOG_BAD_DNS_ADDRESS = 50100; + + + //***** Member Variables + protected PhoneBase phone; + protected Message onConnectCompleted; + protected Message onDisconnect; + protected int cid; + protected String interfaceName; + protected String ipAddress; + protected String gatewayAddress; + protected String[] dnsServers; + protected State state; + protected long createTime; + protected long lastFailTime; + protected FailCause lastFailCause; + protected static final String NULL_IP = "0.0.0.0"; + Object userData; + + // receivedDisconnectReq is set when disconnect during activation + protected boolean receivedDisconnectReq; + + /* Instance Methods */ + protected abstract void onSetupConnectionCompleted(AsyncResult ar); + + protected abstract void onDeactivated(AsyncResult ar); + + protected abstract void disconnect(Message msg); + + protected abstract void notifyFail(FailCause cause, Message onCompleted); + + protected abstract void notifyDisconnect(Message msg); + + protected abstract void onLinkStateChanged(DataLink.LinkState linkState); + + protected abstract FailCause getFailCauseFromRequest(int rilCause); + + public abstract String toString(); + + protected abstract void log(String s); + + + //***** Constructor + protected DataConnection(PhoneBase phone) { + super(); + this.phone = phone; + onConnectCompleted = null; + onDisconnect = null; + this.cid = -1; + receivedDisconnectReq = false; + this.dnsServers = new String[2]; + + clearSettings(); + } + + protected void setHttpProxy(String httpProxy, String httpPort) { + if (httpProxy == null || httpProxy.length() == 0) { + phone.setSystemProperty("net.gprs.http-proxy", null); + return; + } + + if (httpPort == null || httpPort.length() == 0) { + httpPort = "8080"; // Default to port 8080 + } + + phone.setSystemProperty("net.gprs.http-proxy", + "http://" + httpProxy + ":" + httpPort + "/"); + } + + public String getInterface() { + return interfaceName; + } + + public String getIpAddress() { + return ipAddress; + } + + public String getGatewayAddress() { + return gatewayAddress; + } + + public String[] getDnsServers() { + return dnsServers; + } + + public void clearSettings() { + log("DataConnection.clearSettings()"); + + this.state = State.INACTIVE; + this.createTime = -1; + this.lastFailTime = -1; + this.lastFailCause = FailCause.NONE; + + receivedDisconnectReq = false; + onConnectCompleted = null; + interfaceName = null; + ipAddress = null; + gatewayAddress = null; + dnsServers[0] = null; + dnsServers[1] = null; + } + + protected void onGetLastFailCompleted(AsyncResult ar) { + if (receivedDisconnectReq) { + // Don't bother reporting the error if there's already a + // pending disconnect request, since DataConnectionTracker + // has already updated its state. + notifyDisconnect(onDisconnect); + } else { + FailCause cause = FailCause.UNKNOWN; + + if (ar.exception == null) { + int rilFailCause = ((int[]) (ar.result))[0]; + cause = getFailCauseFromRequest(rilFailCause); + } + notifyFail(cause, onConnectCompleted); + } + } + + protected void onForceRetry() { + if (receivedDisconnectReq) { + notifyDisconnect(onDisconnect); + } else { + notifyFail(FailCause.RADIO_ERROR_RETRY, onConnectCompleted); + } + } + + @Override + public void handleMessage(Message msg) { + AsyncResult ar; + + log("DataConnection.handleMessage()"); + + switch (msg.what) { + + case EVENT_SETUP_DATA_CONNECTION_DONE: + onSetupConnectionCompleted((AsyncResult) msg.obj); + break; + + case EVENT_FORCE_RETRY: + onForceRetry(); + break; + + case EVENT_GET_LAST_FAIL_DONE: + onGetLastFailCompleted((AsyncResult) msg.obj); + break; + + case EVENT_LINK_STATE_CHANGED: + ar = (AsyncResult) msg.obj; + DataLink.LinkState ls = (DataLink.LinkState) ar.result; + onLinkStateChanged(ls); + break; + + case EVENT_DEACTIVATE_DONE: + onDeactivated((AsyncResult) msg.obj); + break; + } + } + + public State getState() { + log("DataConnection.getState()"); + return state; + } + + public long getConnectionTime() { + log("DataConnection.getConnectionTime()"); + return createTime; + } + + public long getLastFailTime() { + log("DataConnection.getLastFailTime()"); + return lastFailTime; + } + + public FailCause getLastFailCause() { + log("DataConnection.getLastFailCause()"); + return lastFailCause; + } +} diff --git a/telephony/java/com/android/internal/telephony/DataConnectionTracker.java b/telephony/java/com/android/internal/telephony/DataConnectionTracker.java new file mode 100644 index 0000000..5b826b2 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/DataConnectionTracker.java @@ -0,0 +1,313 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.app.PendingIntent; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.INetStatService; +import android.os.Message; +import android.os.RemoteException; +import android.provider.Settings; +import android.provider.Settings.SettingNotFoundException; +import android.util.Log; + +/** + * {@hide} + * + */ +public abstract class DataConnectionTracker extends Handler { + private static final boolean DBG = true; + + /** + * IDLE: ready to start data connection setup, default state + * INITING: state of issued setupDefaultPDP() but not finish yet + * CONNECTING: state of issued startPppd() but not finish yet + * SCANNING: data connection fails with one apn but other apns are available + * ready to start data connection on other apns (before INITING) + * CONNECTED: IP connection is setup + * DISCONNECTING: Connection.disconnect() has been called, but PDP + * context is not yet deactivated + * FAILED: data connection fail for all apns settings + * + * getDataConnectionState() maps State to DataState + * FAILED or IDLE : DISCONNECTED + * INITING or CONNECTING or SCANNING: CONNECTING + * CONNECTED : CONNECTED or DISCONNECTING + */ + public enum State { + IDLE, + INITING, + CONNECTING, + SCANNING, + CONNECTED, + DISCONNECTING, + FAILED + } + + public enum Activity { + NONE, + DATAIN, + DATAOUT, + DATAINANDOUT + } + + //***** Event Codes + protected static final int EVENT_DATA_SETUP_COMPLETE = 1; + protected static final int EVENT_RADIO_AVAILABLE = 3; + protected static final int EVENT_RECORDS_LOADED = 4; + protected static final int EVENT_TRY_SETUP_DATA = 5; + protected static final int EVENT_DATA_STATE_CHANGED = 6; + protected static final int EVENT_POLL_PDP = 7; + protected static final int EVENT_GET_PDP_LIST_COMPLETE = 11; + protected static final int EVENT_RADIO_OFF_OR_NOT_AVAILABLE = 12; + protected static final int EVENT_VOICE_CALL_STARTED = 14; + protected static final int EVENT_VOICE_CALL_ENDED = 15; + protected static final int EVENT_GPRS_DETACHED = 19; + protected static final int EVENT_LINK_STATE_CHANGED = 20; + protected static final int EVENT_ROAMING_ON = 21; + protected static final int EVENT_ROAMING_OFF = 22; + protected static final int EVENT_ENABLE_NEW_APN = 23; + protected static final int EVENT_RESTORE_DEFAULT_APN = 24; + protected static final int EVENT_DISCONNECT_DONE = 25; + protected static final int EVENT_GPRS_ATTACHED = 26; + protected static final int EVENT_START_NETSTAT_POLL = 27; + protected static final int EVENT_START_RECOVERY = 28; + protected static final int EVENT_APN_CHANGED = 29; + protected static final int EVENT_CDMA_DATA_DETACHED = 30; + protected static final int EVENT_NV_READY = 31; + protected static final int EVENT_PS_RESTRICT_ENABLED = 32; + protected static final int EVENT_PS_RESTRICT_DISABLED = 33; + + //***** Constants + protected static final int RECONNECT_DELAY_INITIAL_MILLIS = 5 * 1000; + + /** Cap out with 1 hour retry interval. */ + protected static final int RECONNECT_DELAY_MAX_MILLIS = 60 * 60 * 1000; + + /** Slow poll when attempting connection recovery. */ + protected static final int POLL_NETSTAT_SLOW_MILLIS = 5000; + /** Default ping deadline, in seconds. */ + protected final int DEFAULT_PING_DEADLINE = 5; + /** Default max failure count before attempting to network re-registration. */ + protected final int DEFAULT_MAX_PDP_RESET_FAIL = 3; + + /** + * After detecting a potential connection problem, this is the max number + * of subsequent polls before attempting a radio reset. At this point, + * poll interval is 5 seconds (POLL_NETSTAT_SLOW_MILLIS), so set this to + * poll for about 2 more minutes. + */ + protected static final int NO_RECV_POLL_LIMIT = 24; + + // 1 sec. default polling interval when screen is on. + protected static final int POLL_NETSTAT_MILLIS = 1000; + // 10 min. default polling interval when screen is off. + protected static final int POLL_NETSTAT_SCREEN_OFF_MILLIS = 1000*60*10; + // 2 min for round trip time + protected static final int POLL_LONGEST_RTT = 120 * 1000; + // 10 for packets without ack + protected static final int NUMBER_SENT_PACKETS_OF_HANG = 10; + // how long to wait before switching back to default APN + protected static final int RESTORE_DEFAULT_APN_DELAY = 1 * 60 * 1000; + // system property that can override the above value + protected static final String APN_RESTORE_DELAY_PROP_NAME = "android.telephony.apn-restore"; + // represents an invalid IP address + protected static final String NULL_IP = "0.0.0.0"; + + + // member variables + protected PhoneBase phone; + protected Activity activity = Activity.NONE; + protected State state = State.IDLE; + protected Handler mDataConnectionTracker = null; + + + protected INetStatService netstat; + protected long txPkts, rxPkts, sentSinceLastRecv; + protected int netStatPollPeriod; + protected int mNoRecvPollCount = 0; + protected boolean netStatPollEnabled = false; + + // wifi connection status will be updated by sticky intent + protected boolean mIsWifiConnected = false; + + /** Intent sent when the reconnect alarm fires. */ + protected PendingIntent mReconnectIntent = null; + + /** CID of active data connection */ + protected int cidActive; + + /** + * Default constructor + */ + protected DataConnectionTracker(PhoneBase phone) { + super(); + this.phone = phone; + } + + public Activity getActivity() { + return activity; + } + + public State getState() { + return state; + } + + public String getStateInString() { + switch (state) { + case IDLE: return "IDLE"; + case INITING: return "INIT"; + case CONNECTING: return "CING"; + case SCANNING: return "SCAN"; + case CONNECTED: return "CNTD"; + case DISCONNECTING: return "DING"; + case FAILED: return "FAIL"; + default: return "ERRO"; + } + } + + /** + * The data connection is expected to be setup while device + * 1. has Icc card + * 2. registered for data service + * 3. user doesn't explicitly disable data service + * 4. wifi is not on + * + * @return false while no data connection if all above requirements are met. + */ + public abstract boolean isDataConnectionAsDesired(); + + //The data roaming setting is now located in the shared preferences. + // See if the requested preference value is the same as that stored in + // the shared values. If it is not, then update it. + public void setDataOnRoamingEnabled(boolean enabled) { + if (getDataOnRoamingEnabled() != enabled) { + Settings.Secure.putInt(phone.getContext().getContentResolver(), + Settings.Secure.DATA_ROAMING, enabled ? 1 : 0); + } + Message roamingMsg = phone.getServiceState().getRoaming() ? + obtainMessage(EVENT_ROAMING_ON) : obtainMessage(EVENT_ROAMING_OFF); + sendMessage(roamingMsg); + } + + //Retrieve the data roaming setting from the shared preferences. + public boolean getDataOnRoamingEnabled() { + try { + return Settings.Secure.getInt(phone.getContext().getContentResolver(), + Settings.Secure.DATA_ROAMING) > 0; + } catch (SettingNotFoundException snfe) { + return false; + } + } + + // abstract handler methods + protected abstract void onTrySetupData(); + protected abstract void onRoamingOff(); + protected abstract void onRoamingOn(); + protected abstract void onRadioAvailable(); + protected abstract void onRadioOffOrNotAvailable(); + protected abstract void onDataSetupComplete(AsyncResult ar); + protected abstract void onDisconnectDone(AsyncResult ar); + protected abstract void onVoiceCallStarted(); + protected abstract void onVoiceCallEnded(); + + //***** Overridden from Handler + public void handleMessage (Message msg) { + switch (msg.what) { + + case EVENT_TRY_SETUP_DATA: + onTrySetupData(); + break; + + case EVENT_ROAMING_OFF: + onRoamingOff(); + break; + + case EVENT_ROAMING_ON: + onRoamingOn(); + break; + + case EVENT_RADIO_AVAILABLE: + onRadioAvailable(); + break; + + case EVENT_RADIO_OFF_OR_NOT_AVAILABLE: + onRadioOffOrNotAvailable(); + break; + + case EVENT_DATA_SETUP_COMPLETE: + cidActive = msg.arg1; + onDataSetupComplete((AsyncResult) msg.obj); + break; + + case EVENT_DISCONNECT_DONE: + onDisconnectDone((AsyncResult) msg.obj); + break; + + case EVENT_VOICE_CALL_STARTED: + onVoiceCallStarted(); + break; + + case EVENT_VOICE_CALL_ENDED: + onVoiceCallEnded(); + break; + + default: + Log.e("DATA", "Unidentified event = " + msg.what); + break; + } + } + + /** + * Simply tear down data connections due to radio off + * and don't setup again. + */ + public abstract void cleanConnectionBeforeRadioOff(); + + /** + * Report the current state of data connectivity (enabled or disabled) + * @return {@code false} if data connectivity has been explicitly disabled, + * {@code true} otherwise. + */ + public abstract boolean getDataEnabled(); + + /** + * Report on whether data connectivity is enabled + * @return {@code false} if data connectivity has been explicitly disabled, + * {@code true} otherwise. + */ + public abstract boolean getAnyDataEnabled(); + + /** + * Prevent mobile data connections from being established, + * or once again allow mobile data connections. If the state + * toggles, then either tear down or set up data, as + * appropriate to match the new state. + * @param enable indicates whether to enable ({@code true}) or disable ({@code false}) data + * @return {@code true} if the operation succeeded + */ + public abstract boolean setDataEnabled(boolean enable); + + protected abstract void startNetStatPoll(); + + protected abstract void stopNetStatPoll(); + + protected abstract void restartRadio(); + + protected abstract void log(String s); +} diff --git a/telephony/java/com/android/internal/telephony/gsm/DataLink.java b/telephony/java/com/android/internal/telephony/DataLink.java index b822ab4..8132d91 100644 --- a/telephony/java/com/android/internal/telephony/gsm/DataLink.java +++ b/telephony/java/com/android/internal/telephony/DataLink.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; import android.os.Handler; import android.os.Registrant; @@ -24,14 +24,13 @@ import android.os.Registrant; * * {@hide} */ -abstract class DataLink extends Handler implements DataLinkInterface { +public abstract class DataLink extends Handler implements DataLinkInterface { /** Registrant for link status change notifications. */ - Registrant mLinkChangeRegistrant; - + protected Registrant mLinkChangeRegistrant; protected DataConnectionTracker dataConnection; - DataLink(DataConnectionTracker dc) { + protected DataLink(DataConnectionTracker dc) { dataConnection = dc; } diff --git a/telephony/java/com/android/internal/telephony/gsm/DataLinkInterface.java b/telephony/java/com/android/internal/telephony/DataLinkInterface.java index bca63f2..e8148a8 100644 --- a/telephony/java/com/android/internal/telephony/gsm/DataLinkInterface.java +++ b/telephony/java/com/android/internal/telephony/DataLinkInterface.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; import android.database.Cursor; import android.os.Handler; @@ -24,7 +24,7 @@ import android.os.Handler; * * {@hide} */ -interface DataLinkInterface { +public interface DataLinkInterface { /** * Link state enumeration. * @@ -35,21 +35,21 @@ interface DataLinkInterface { LINK_DOWN, LINK_EXITED } - + /** Normal exit */ final static int EXIT_OK = 0; /** Open failed */ final static int EXIT_OPEN_FAILED = 7; - + /** * Sets the handler for link state change events. - * + * * @param h Handler * @param what User-defined message code * @param obj User object */ void setOnLinkChange(Handler h, int what, Object obj); - + /** * Sets up the data link. */ @@ -59,14 +59,14 @@ interface DataLinkInterface { * Tears down the data link. */ void disconnect(); - + /** - * Returns the exit code for a data link failure. + * Returns the exit code for a data link failure. * * @return exit code */ int getLastLinkExitCode(); - + /** * Sets password information that may be required by the data link * (eg, PAP secrets). diff --git a/telephony/java/com/android/internal/telephony/DefaultPhoneNotifier.java b/telephony/java/com/android/internal/telephony/DefaultPhoneNotifier.java index 81ef623..79b4afe 100644 --- a/telephony/java/com/android/internal/telephony/DefaultPhoneNotifier.java +++ b/telephony/java/com/android/internal/telephony/DefaultPhoneNotifier.java @@ -33,7 +33,7 @@ public class DefaultPhoneNotifier implements PhoneNotifier { private static final boolean DBG = true; private ITelephonyRegistry mRegistry; - /*package*/ + /*package*/ DefaultPhoneNotifier() { mRegistry = ITelephonyRegistry.Stub.asInterface(ServiceManager.getService( "telephony.registry")); @@ -94,7 +94,7 @@ public class DefaultPhoneNotifier implements PhoneNotifier { public void notifyDataConnection(Phone sender, String reason) { try { - mRegistry.notifyDataConnection(convertDataState(sender.getDataConnectionState()), + mRegistry.notifyDataConnection(convertDataState(sender.getDataConnectionState()), sender.isDataConnectivityPossible(), reason, sender.getActiveApn(), sender.getInterfaceName(null)); } catch (RemoteException ex) { @@ -119,7 +119,7 @@ public class DefaultPhoneNotifier implements PhoneNotifier { // system process is dead } } - + private void log(String s) { Log.d(LOG_TAG, "[PhoneNotifier] " + s); } diff --git a/telephony/java/com/android/internal/telephony/gsm/DriverCall.java b/telephony/java/com/android/internal/telephony/DriverCall.java index aab885a..6c4e71f 100644 --- a/telephony/java/com/android/internal/telephony/gsm/DriverCall.java +++ b/telephony/java/com/android/internal/telephony/DriverCall.java @@ -14,9 +14,8 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; -import com.android.internal.telephony.*; - +package com.android.internal.telephony; +//import com.android.internal.telephony.*; import android.util.Log; import java.lang.Comparable; import android.telephony.PhoneNumberUtils; @@ -24,10 +23,9 @@ import android.telephony.PhoneNumberUtils; /** * {@hide} */ -public class DriverCall implements Comparable -{ - static final String LOG_TAG = "GSM"; - +public class DriverCall implements Comparable { + static final String LOG_TAG = "RILB"; + public enum State { ACTIVE, HOLDING, @@ -48,11 +46,10 @@ public class DriverCall implements Comparable public boolean isVoice; public int als; public int numberPresentation; - + /** returns null on error */ static DriverCall - fromCLCCLine(String line) - { + fromCLCCLine(String line) { DriverCall ret = new DriverCall(); //+CLCC: 1,0,2,0,0,\"+18005551212\",145 @@ -66,10 +63,10 @@ public class DriverCall implements Comparable ret.isVoice = (0 == p.nextInt()); ret.isMpty = p.nextBoolean(); - + // use ALLOWED as default presentation while parsing CLCC ret.numberPresentation = Connection.PRESENTATION_ALLOWED; - + if (p.hasMore()) { // Some lame implementations return strings // like "NOT AVAILABLE" in the CLCC line @@ -98,13 +95,11 @@ public class DriverCall implements Comparable } public - DriverCall() - { + DriverCall() { } public String - toString() - { + toString() { return "id=" + index + "," + (isMT ? "mt" : "mo") + "," + state + "," @@ -114,8 +109,7 @@ public class DriverCall implements Comparable } public static State - stateFromCLCC(int state) throws ATParseEx - { + stateFromCLCC(int state) throws ATParseEx { switch(state) { case 0: return State.ACTIVE; case 1: return State.HOLDING; @@ -127,7 +121,7 @@ public class DriverCall implements Comparable throw new ATParseEx("illegal call state " + state); } } - + public static int presentationFromCLIP(int cli) throws ATParseEx { @@ -141,12 +135,11 @@ public class DriverCall implements Comparable } } - //***** Comparable Implementation + //***** Comparable Implementation /** For sorting by index */ public int - compareTo (Object o) - { + compareTo (Object o) { DriverCall dc; dc = (DriverCall)o; diff --git a/telephony/java/com/android/internal/telephony/gsm/EncodeException.java b/telephony/java/com/android/internal/telephony/EncodeException.java index d546cef..0436ba0 100644 --- a/telephony/java/com/android/internal/telephony/gsm/EncodeException.java +++ b/telephony/java/com/android/internal/telephony/EncodeException.java @@ -14,25 +14,21 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; /** * {@hide} */ -public class EncodeException extends Exception -{ - public EncodeException() - { +public class EncodeException extends Exception { + public EncodeException() { super(); } - - public EncodeException(String s) - { + + public EncodeException(String s) { super(s); } - public EncodeException(char c) - { + public EncodeException(char c) { super("Unencodable char: '" + c + "'"); } } diff --git a/telephony/java/com/android/internal/telephony/gsm/GsmAlphabet.java b/telephony/java/com/android/internal/telephony/GsmAlphabet.java index df34897..8f4c69c 100644 --- a/telephony/java/com/android/internal/telephony/gsm/GsmAlphabet.java +++ b/telephony/java/com/android/internal/telephony/GsmAlphabet.java @@ -14,9 +14,9 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; -import android.telephony.gsm.SmsMessage; +import android.telephony.SmsMessage; import android.util.SparseIntArray; import android.util.Log; @@ -28,16 +28,15 @@ import android.util.Log; * * {@hide} */ -public class GsmAlphabet -{ +public class GsmAlphabet { static final String LOG_TAG = "GSM"; - + //***** Constants /** - * This escapes extended characters, and when present indicates that the + * This escapes extended characters, and when present indicates that the * following character should * be looked up in the "extended" table * @@ -55,8 +54,7 @@ public class GsmAlphabet * should follow GSM_EXTENDED_ESCAPE in the GSM alphabet string */ public static int - charToGsm(char c) - { + charToGsm(char c) { try { return charToGsm(c, false); } catch (EncodeException ex) { @@ -67,7 +65,7 @@ public class GsmAlphabet /** * char to GSM alphabet char - * @param throwException If true, throws EncodeException on invalid char. + * @param throwException If true, throws EncodeException on invalid char. * If false, returns GSM alphabet ' ' char. * * Returns GSM_EXTENDED_ESCAPE if this character is in the extended table @@ -76,10 +74,9 @@ public class GsmAlphabet */ public static int - charToGsm(char c, boolean throwException) throws EncodeException - { + charToGsm(char c, boolean throwException) throws EncodeException { int ret; - + ret = charToGsm.get(c, -1); if (ret == -1) { @@ -99,7 +96,7 @@ public class GsmAlphabet return ret; } - + /** * char to extended GSM alphabet char @@ -110,10 +107,9 @@ public class GsmAlphabet * */ public static int - charToGsmExtended(char c) - { + charToGsmExtended(char c) { int ret; - + ret = charToGsmExtended.get(c, -1); if (ret == -1) { @@ -124,34 +120,32 @@ public class GsmAlphabet } /** - * Converts a character in the GSM alphabet into a char + * Converts a character in the GSM alphabet into a char * * if GSM_EXTENDED_ESCAPE is passed, 0xffff is returned. In this case, - * the following character in the stream should be decoded with + * the following character in the stream should be decoded with * gsmExtendedToChar() * * If an unmappable value is passed (one greater than 127), ' ' is returned */ public static char - gsmToChar(int gsmChar) - { + gsmToChar(int gsmChar) { return (char)gsmToChar.get(gsmChar, ' '); } - + /** - * Converts a character in the extended GSM alphabet into a char + * Converts a character in the extended GSM alphabet into a char * * if GSM_EXTENDED_ESCAPE is passed, ' ' is returned since no second * extension page has yet been defined (see Note 1 in table 6.2.1.1 of * TS 23.038 v7.00) - * + * * If an unmappable value is passed , ' ' is returned */ public static char - gsmExtendedToChar(int gsmChar) - { + gsmExtendedToChar(int gsmChar) { int ret; ret = gsmExtendedToChar.get(gsmChar, -1); @@ -205,7 +199,7 @@ public class GsmAlphabet } /** - * Converts a String into a byte array containing + * Converts a String into a byte array containing * the 7-bit packed GSM Alphabet representation of the string. * * Unencodable chars are encoded as spaces @@ -224,7 +218,7 @@ public class GsmAlphabet } /** - * Converts a String into a byte array containing + * Converts a String into a byte array containing * the 7-bit packed GSM Alphabet representation of the string. * * Byte 0 in the returned byte array is the count of septets used @@ -238,7 +232,7 @@ public class GsmAlphabet * enforced maximum. * @param startingBitOffset the number of padding bits to put before * the start of the first septet at the begining of the array - * @param throwException If true, throws EncodeException on invalid char. + * @param throwException If true, throws EncodeException on invalid char. * If false, replaces unencodable char with GSM alphabet space char. * * @throws EncodeException if String is too large to encode @@ -294,27 +288,26 @@ public class GsmAlphabet * @param bitOffset the bit offset that the septet should be packed at * (septet index * 7) */ - private static void - packSmsChar(byte[] packedChars, int bitOffset, int value) - { + private static void + packSmsChar(byte[] packedChars, int bitOffset, int value) { int byteOffset = bitOffset / 8; int shift = bitOffset % 8; packedChars[++byteOffset] |= value << shift; if (shift > 1) { - packedChars[++byteOffset] = (byte)(value >> (8 - shift)); - } + packedChars[++byteOffset] = (byte)(value >> (8 - shift)); + } } /** - * Convert a GSM alphabet 7 bit packed string (SMS string) into a + * Convert a GSM alphabet 7 bit packed string (SMS string) into a * {@link java.lang.String}. * * See TS 23.038 6.1.2.1 for SMS Character Packing * * @param pdu the raw data from the pdu - * @param offset the byte offset of + * @param offset the byte offset of * @param lengthSeptets string length in septets, not bytes * @return String representation or null on decoding exception */ @@ -324,27 +317,26 @@ public class GsmAlphabet } /** - * Convert a GSM alphabet 7 bit packed string (SMS string) into a + * Convert a GSM alphabet 7 bit packed string (SMS string) into a * {@link java.lang.String}. * * See TS 23.038 6.1.2.1 for SMS Character Packing * * @param pdu the raw data from the pdu - * @param offset the byte offset of + * @param offset the byte offset of * @param lengthSeptets string length in septets, not bytes * @param numPaddingBits the number of padding bits before the start of the * string in the first byte * @return String representation or null on decoding exception */ public static String gsm7BitPackedToString(byte[] pdu, int offset, - int lengthSeptets, int numPaddingBits) - { + int lengthSeptets, int numPaddingBits) { StringBuilder ret = new StringBuilder(lengthSeptets); boolean prevCharWasEscape; - + try { prevCharWasEscape = false; - + for (int i = 0 ; i < lengthSeptets ; i++) { int bitOffset = (7 * i) + numPaddingBits; @@ -381,15 +373,14 @@ public class GsmAlphabet /** - * Convert a GSM alphabet string that's stored in 8-bit unpacked + * Convert a GSM alphabet string that's stored in 8-bit unpacked * format (as it often appears in SIM records) into a String * * Field may be padded with trailing 0xff's. The decode stops * at the first 0xff encountered. */ public static String - gsm8BitUnpackedToString(byte[] data, int offset, int length) - { + gsm8BitUnpackedToString(byte[] data, int offset, int length) { boolean prevWasEscape; StringBuilder ret = new StringBuilder(length); @@ -420,8 +411,8 @@ public class GsmAlphabet prevWasEscape = false; } } - - return ret.toString(); + + return ret.toString(); } /** @@ -429,8 +420,7 @@ public class GsmAlphabet * array */ public static byte[] - stringToGsm8BitPacked(String s) - { + stringToGsm8BitPacked(String s) { byte[] ret; int septets = 0; @@ -452,15 +442,14 @@ public class GsmAlphabet * * Field is padded with 0xff's, string is truncated if necessary */ - + public static void - stringToGsm8BitUnpackedField(String s, byte dest[], int offset, int length) - { + stringToGsm8BitUnpackedField(String s, byte dest[], int offset, int length) { int outByteIndex = offset; // Septets are stored in byte-aligned octets for (int i = 0, sz = s.length() - ; i < sz && (outByteIndex - offset) < length + ; i < sz && (outByteIndex - offset) < length ; i++ ) { char c = s.charAt(i); @@ -475,7 +464,7 @@ public class GsmAlphabet dest[outByteIndex++] = GSM_EXTENDED_ESCAPE; - v = GsmAlphabet.charToGsmExtended(c); + v = GsmAlphabet.charToGsmExtended(c); } dest[outByteIndex++] = (byte)v; @@ -492,8 +481,7 @@ public class GsmAlphabet * needed to represent this character. Counts unencodable char as 1 septet. */ public static int - countGsmSeptets(char c) - { + countGsmSeptets(char c) { try { return countGsmSeptets(c, false); } catch (EncodeException ex) { @@ -509,21 +497,20 @@ public class GsmAlphabet * char. Otherwise, counts invalid char as 1 septet */ public static int - countGsmSeptets(char c, boolean throwsException) throws EncodeException - { - if (charToGsm.get(c, -1) != -1) { - return 1; - } - - if (charToGsmExtended.get(c, -1) != -1) { - return 2; - } + countGsmSeptets(char c, boolean throwsException) throws EncodeException { + if (charToGsm.get(c, -1) != -1) { + return 1; + } + + if (charToGsmExtended.get(c, -1) != -1) { + return 2; + } if (throwsException) { throw new EncodeException(c); - } else { - // count as a space char - return 1; + } else { + // count as a space char + return 1; } } @@ -532,8 +519,7 @@ public class GsmAlphabet * needed to represent this string. Counts unencodable char as 1 septet. */ public static int - countGsmSeptets(CharSequence s) - { + countGsmSeptets(CharSequence s) { try { return countGsmSeptets(s, false); } catch (EncodeException ex) { @@ -549,8 +535,7 @@ public class GsmAlphabet * char. Otherwise, counts invalid char as 1 septet */ public static int - countGsmSeptets(CharSequence s, boolean throwsException) throws EncodeException - { + countGsmSeptets(CharSequence s, boolean throwsException) throws EncodeException { int charIndex = 0; int sz = s.length(); int count = 0; @@ -559,9 +544,9 @@ public class GsmAlphabet count += countGsmSeptets(s.charAt(charIndex), throwsException); charIndex++; } - + return count; - } + } /** * Returns the index into <code>s</code> of the first character @@ -623,7 +608,7 @@ public class GsmAlphabet * @return index of first character that won't fit, or the length * of the entire string if everything fits */ - public static int + public static int findLimitIndex(String s, int start, int limit, int encodingType) throws EncodeException { if (encodingType == SmsMessage.ENCODING_7BIT) { return findGsmSeptetLimitIndex(s, start, limit); @@ -643,10 +628,10 @@ public class GsmAlphabet private static final SparseIntArray gsmToChar = new SparseIntArray(); private static final SparseIntArray charToGsmExtended = new SparseIntArray(); private static final SparseIntArray gsmExtendedToChar = new SparseIntArray(); - + static { int i = 0; - + charToGsm.put('@', i++); charToGsm.put('\u00a3', i++); charToGsm.put('$', i++); @@ -663,7 +648,7 @@ public class GsmAlphabet charToGsm.put('\r', i++); charToGsm.put('\u00c5', i++); charToGsm.put('\u00e5', i++); - + charToGsm.put('\u0394', i++); charToGsm.put('_', i++); charToGsm.put('\u03a6', i++); @@ -680,7 +665,7 @@ public class GsmAlphabet charToGsm.put('\u00e6', i++); charToGsm.put('\u00df', i++); charToGsm.put('\u00c9', i++); - + charToGsm.put(' ', i++); charToGsm.put('!', i++); charToGsm.put('"', i++); @@ -697,7 +682,7 @@ public class GsmAlphabet charToGsm.put('-', i++); charToGsm.put('.', i++); charToGsm.put('/', i++); - + charToGsm.put('0', i++); charToGsm.put('1', i++); charToGsm.put('2', i++); @@ -714,7 +699,7 @@ public class GsmAlphabet charToGsm.put('=', i++); charToGsm.put('>', i++); charToGsm.put('?', i++); - + charToGsm.put('\u00a1', i++); charToGsm.put('A', i++); charToGsm.put('B', i++); @@ -731,7 +716,7 @@ public class GsmAlphabet charToGsm.put('M', i++); charToGsm.put('N', i++); charToGsm.put('O', i++); - + charToGsm.put('P', i++); charToGsm.put('Q', i++); charToGsm.put('R', i++); @@ -748,7 +733,7 @@ public class GsmAlphabet charToGsm.put('\u0147', i++); charToGsm.put('\u00dc', i++); charToGsm.put('\u00a7', i++); - + charToGsm.put('\u00bf', i++); charToGsm.put('a', i++); charToGsm.put('b', i++); @@ -765,7 +750,7 @@ public class GsmAlphabet charToGsm.put('m', i++); charToGsm.put('n', i++); charToGsm.put('o', i++); - + charToGsm.put('p', i++); charToGsm.put('q', i++); charToGsm.put('r', i++); @@ -782,8 +767,8 @@ public class GsmAlphabet charToGsm.put('\u00f1', i++); charToGsm.put('\u00fc', i++); charToGsm.put('\u00e0', i++); - - + + charToGsmExtended.put('\f', 10); charToGsmExtended.put('^', 20); charToGsmExtended.put('{', 40); @@ -794,12 +779,12 @@ public class GsmAlphabet charToGsmExtended.put(']', 62); charToGsmExtended.put('|', 64); charToGsmExtended.put('\u20ac', 101); - + int size = charToGsm.size(); for (int j=0; j<size; j++) { gsmToChar.put(charToGsm.valueAt(j), charToGsm.keyAt(j)); } - + size = charToGsmExtended.size(); for (int j=0; j<size; j++) { gsmExtendedToChar.put(charToGsmExtended.valueAt(j), charToGsmExtended.keyAt(j)); @@ -808,6 +793,6 @@ public class GsmAlphabet sGsmSpaceChar = charToGsm.get(' '); } - + } diff --git a/telephony/java/com/android/internal/telephony/gsm/ISimPhoneBook.aidl b/telephony/java/com/android/internal/telephony/IIccPhoneBook.aidl index 77033a7..f700dfe 100644 --- a/telephony/java/com/android/internal/telephony/gsm/ISimPhoneBook.aidl +++ b/telephony/java/com/android/internal/telephony/IIccPhoneBook.aidl @@ -14,27 +14,27 @@ ** limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; -import com.android.internal.telephony.gsm.AdnRecord; +import com.android.internal.telephony.AdnRecord; -import java.util.List; -/** Interface for applications to access the SIM phone book. + +/** Interface for applications to access the ICC phone book. * * <p>The following code snippet demonstrates a static method to - * retrieve the ISimPhoneBook interface from Android:</p> - * <pre>private static ISimPhoneBook getSimPhoneBookInterface() + * retrieve the IIccPhoneBook interface from Android:</p> + * <pre>private static IIccPhoneBook getSimPhoneBookInterface() throws DeadObjectException { IServiceManager sm = ServiceManagerNative.getDefault(); - ISimPhoneBook spb; - spb = ISimPhoneBook.Stub.asInterface(sm.getService("simphonebook")); + IIccPhoneBook spb; + spb = IIccPhoneBook.Stub.asInterface(sm.getService("iccphonebook")); return spb; } * </pre> */ -interface ISimPhoneBook { +interface IIccPhoneBook { /** * Loads the AdnRecords in efid and returns them as a diff --git a/telephony/java/com/android/internal/telephony/IPhoneSubInfo.aidl b/telephony/java/com/android/internal/telephony/IPhoneSubInfo.aidl index 00cbaf9..e74b9e4 100644 --- a/telephony/java/com/android/internal/telephony/IPhoneSubInfo.aidl +++ b/telephony/java/com/android/internal/telephony/IPhoneSubInfo.aidl @@ -39,9 +39,9 @@ interface IPhoneSubInfo { String getSubscriberId(); /** - * Retrieves the serial number of the SIM, if applicable. + * Retrieves the serial number of the ICC, if applicable. */ - String getSimSerialNumber(); + String getIccSerialNumber(); /** * Retrieves the phone number string for line 1. @@ -53,13 +53,13 @@ interface IPhoneSubInfo { */ String getLine1AlphaTag(); - /** - * Retrieves the voice mail number. - */ + /** + * Retrieves the voice mail number. + */ String getVoiceMailNumber(); - /** - * Retrieves the alpha identifier associated with the voice mail number. - */ + /** + * Retrieves the alpha identifier associated with the voice mail number. + */ String getVoiceMailAlphaTag(); } diff --git a/telephony/java/com/android/internal/telephony/gsm/ISms.aidl b/telephony/java/com/android/internal/telephony/ISms.aidl index 904a54e..257f1e6 100644 --- a/telephony/java/com/android/internal/telephony/gsm/ISms.aidl +++ b/telephony/java/com/android/internal/telephony/ISms.aidl @@ -14,20 +14,20 @@ ** limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; import android.app.PendingIntent; -import com.android.internal.telephony.gsm.SmsRawData; +import com.android.internal.telephony.SmsRawData; -/** Interface for applications to access the SIM phone book. +/** Interface for applications to access the ICC phone book. * * <p>The following code snippet demonstrates a static method to - * retrieve the ISimSms interface from Android:</p> - * <pre>private static ISimSms getSimSmsInterface() + * retrieve the ISms interface from Android:</p> + * <pre>private static ISms getSmsInterface() throws DeadObjectException { IServiceManager sm = ServiceManagerNative.getDefault(); - ISimSms ss; - ss = ISimSms.Stub.asInterface(sm.getService("isms")); + ISms ss; + ss = ISms.Stub.asInterface(sm.getService("isms")); return ss; } * </pre> @@ -35,45 +35,45 @@ import com.android.internal.telephony.gsm.SmsRawData; interface ISms { /** - * Retrieves all messages currently stored on SIM. + * Retrieves all messages currently stored on ICC. * - * @return list of SmsRawData of all sms on SIM + * @return list of SmsRawData of all sms on ICC */ - List<SmsRawData> getAllMessagesFromSimEf(); + List<SmsRawData> getAllMessagesFromIccEf(); /** - * Update the specified message on the SIM. + * Update the specified message on the ICC. * * @param messageIndex record index of message to update - * @param newStatus new message status (STATUS_ON_SIM_READ, - * STATUS_ON_SIM_UNREAD, STATUS_ON_SIM_SENT, - * STATUS_ON_SIM_UNSENT, STATUS_ON_SIM_FREE) + * @param newStatus new message status (STATUS_ON_ICC_READ, + * STATUS_ON_ICC_UNREAD, STATUS_ON_ICC_SENT, + * STATUS_ON_ICC_UNSENT, STATUS_ON_ICC_FREE) * @param pdu the raw PDU to store * @return success or not * */ - boolean updateMessageOnSimEf(int messageIndex, int newStatus, + boolean updateMessageOnIccEf(int messageIndex, int newStatus, in byte[] pdu); /** - * Copy a raw SMS PDU to the SIM. + * Copy a raw SMS PDU to the ICC. * * @param pdu the raw PDU to store - * @param status message status (STATUS_ON_SIM_READ, STATUS_ON_SIM_UNREAD, - * STATUS_ON_SIM_SENT, STATUS_ON_SIM_UNSENT) + * @param status message status (STATUS_ON_ICC_READ, STATUS_ON_ICC_UNREAD, + * STATUS_ON_ICC_SENT, STATUS_ON_ICC_UNSENT) * @return success or not * */ - boolean copyMessageToSimEf(int status, in byte[] pdu, in byte[] smsc); + boolean copyMessageToIccEf(int status, in byte[] pdu, in byte[] smsc); /** * Send a SMS * * @param smsc the SMSC to send the message through, or NULL for the - * defatult SMSC + * default SMSC * @param pdu the raw PDU to send * @param sentIntent if not NULL this <code>Intent</code> is - * broadcast when the message is sucessfully sent, or failed. + * broadcast when the message is successfully sent, or failed. * The result code will be <code>Activity.RESULT_OK<code> for success, * or one of these errors: * <code>RESULT_ERROR_GENERIC_FAILURE</code> @@ -88,13 +88,13 @@ interface ISms { /** * Send a multi-part text based SMS. - * + * * @param destinationAddress the address to send the message to * @param scAddress is the service center address or null to use * the current default SMSC * @param parts an <code>ArrayList</code> of strings that, in order, * comprise the original message - * @param sentIntents if not null, an <code>ArrayList</code> of + * @param sentIntents if not null, an <code>ArrayList</code> of * <code>PendingIntent</code>s (one for each message part) that is * broadcast when the corresponding message part has been sent. * The result code will be <code>Activity.RESULT_OK<code> for success, @@ -102,7 +102,7 @@ interface ISms { * <code>RESULT_ERROR_GENERIC_FAILURE</code> * <code>RESULT_ERROR_RADIO_OFF</code> * <code>RESULT_ERROR_NULL_PDU</code>. - * @param deliveryIntents if not null, an <code>ArrayList</code> of + * @param deliveryIntents if not null, an <code>ArrayList</code> of * <code>PendingIntent</code>s (one for each message part) that is * broadcast when the corresponding message part has been delivered * to the recipient. The raw pdu of the status report is in the diff --git a/telephony/java/com/android/internal/telephony/ITelephony.aidl b/telephony/java/com/android/internal/telephony/ITelephony.aidl index 2b4195b..bab0603 100644 --- a/telephony/java/com/android/internal/telephony/ITelephony.aidl +++ b/telephony/java/com/android/internal/telephony/ITelephony.aidl @@ -21,7 +21,7 @@ import java.util.List; import android.telephony.NeighboringCellInfo; /** - * Interface used to interact with the phone. Mostly this is used by the + * Interface used to interact with the phone. Mostly this is used by the * TelephonyManager class. A few places are still using this directly. * Please clean them up if possible and use TelephonyManager insteadl. * @@ -135,7 +135,7 @@ interface ITelephony { /** * Cancels the missed calls notification. */ - void cancelMissedCallsNotification(); + void cancelMissedCallsNotification(); /** * Supply a pin to unlock the SIM. Blocks until a result is determined. @@ -147,7 +147,7 @@ interface ITelephony { /** * Handles PIN MMI commands (PIN/PIN2/PUK/PUK2), which are initiated * without SEND (so <code>dial</code> is not appropriate). - * + * * @param dialString the MMI command to be executed. * @return true if MMI command is executed. */ @@ -213,4 +213,13 @@ interface ITelephony { int getCallState(); int getDataActivity(); int getDataState(); + + /** + * Returns the current active phone type as integer. + * Returns TelephonyManager.PHONE_TYPE_CDMA if RILConstants.CDMA_PHONE + * and TelephonyManager.PHONE_TYPE_GSM if RILConstants.GSM_PHONE + */ + int getActivePhoneType(); + } + diff --git a/telephony/java/com/android/internal/telephony/SimCard.java b/telephony/java/com/android/internal/telephony/IccCard.java index 03b366f..d7ad492 100644 --- a/telephony/java/com/android/internal/telephony/SimCard.java +++ b/telephony/java/com/android/internal/telephony/IccCard.java @@ -22,35 +22,34 @@ import android.os.Handler; /** * {@hide} */ -public interface SimCard -{ - /* The extra data for broacasting intent INTENT_SIM_STATE_CHANGE */ - static public final String INTENT_KEY_SIM_STATE = "ss"; - /* NOT_READY means the SIM interface is not ready (eg, radio is off or powering on) */ - static public final String INTENT_VALUE_SIM_NOT_READY = "NOT_READY"; - /* ABSENT means SIM is missing */ - static public final String INTENT_VALUE_SIM_ABSENT = "ABSENT"; - /* LOCKED means SIM is locked by pin or by network */ - static public final String INTENT_VALUE_SIM_LOCKED = "LOCKED"; - /* READY means SIM is ready to access */ - static public final String INTENT_VALUE_SIM_READY = "READY"; - /* IMSI means SIM IMSI is ready in property */ - static public final String INTENT_VALUE_SIM_IMSI = "IMSI"; - /* LOADED means all SIM records, including IMSI, are loaded */ - static public final String INTENT_VALUE_SIM_LOADED = "LOADED"; - /* The extra data for broacasting intent INTENT_SIM_STATE_CHANGE */ +public interface IccCard { + /* The extra data for broacasting intent INTENT_ICC_STATE_CHANGE */ + static public final String INTENT_KEY_ICC_STATE = "ss"; + /* NOT_READY means the ICC interface is not ready (eg, radio is off or powering on) */ + static public final String INTENT_VALUE_ICC_NOT_READY = "NOT_READY"; + /* ABSENT means ICC is missing */ + static public final String INTENT_VALUE_ICC_ABSENT = "ABSENT"; + /* LOCKED means ICC is locked by pin or by network */ + static public final String INTENT_VALUE_ICC_LOCKED = "LOCKED"; + /* READY means ICC is ready to access */ + static public final String INTENT_VALUE_ICC_READY = "READY"; + /* IMSI means ICC IMSI is ready in property */ + static public final String INTENT_VALUE_ICC_IMSI = "IMSI"; + /* LOADED means all ICC records, including IMSI, are loaded */ + static public final String INTENT_VALUE_ICC_LOADED = "LOADED"; + /* The extra data for broacasting intent INTENT_ICC_STATE_CHANGE */ static public final String INTENT_KEY_LOCKED_REASON = "reason"; - /* PIN means SIM is locked on PIN1 */ + /* PIN means ICC is locked on PIN1 */ static public final String INTENT_VALUE_LOCKED_ON_PIN = "PIN"; - /* PUK means SIM is locked on PUK1 */ + /* PUK means ICC is locked on PUK1 */ static public final String INTENT_VALUE_LOCKED_ON_PUK = "PUK"; - /* NETWORK means SIM is locked on NETWORK PERSONALIZATION */ + /* NETWORK means ICC is locked on NETWORK PERSONALIZATION */ static public final String INTENT_VALUE_LOCKED_NETWORK = "NETWORK"; /* - UNKNOWN is a transient state, for example, after uesr inputs sim pin under - PIN_REQUIRED state, the query for sim status returns UNKNOWN before it + UNKNOWN is a transient state, for example, after uesr inputs ICC pin under + PIN_REQUIRED state, the query for ICC status returns UNKNOWN before it turns to READY */ public enum State { @@ -73,7 +72,7 @@ public interface SimCard * Notifies handler of any transition into State.ABSENT */ void registerForAbsent(Handler h, int what, Object obj); - void unregisterForAbsent(Handler h); + void unregisterForAbsent(Handler h); /** * Notifies handler of any transition into State.isPinLocked() @@ -88,7 +87,7 @@ public interface SimCard void unregisterForNetworkLocked(Handler h); /** - * Supply the SIM PIN to the SIM + * Supply the ICC PIN to the ICC * * When the operation is complete, onComplete will be sent to it's * Handler. @@ -100,11 +99,11 @@ public interface SimCard * * If the supplied PIN is incorrect: * ((AsyncResult)onComplete.obj).exception != null - * && ((AsyncResult)onComplete.obj).exception + * && ((AsyncResult)onComplete.obj).exception * instanceof com.android.internal.telephony.gsm.CommandException) * && ((CommandException)(((AsyncResult)onComplete.obj).exception)) * .getCommandError() == CommandException.Error.PASSWORD_INCORRECT - * + * * */ @@ -114,30 +113,30 @@ public interface SimCard void supplyPuk2 (String puk2, String newPin2, Message onComplete); /** - * Check whether sim pin lock is enabled + * Check whether ICC pin lock is enabled * This is a sync call which returns the cached pin enabled state * - * @return true for sim locked enabled - * false for sim locked disabled + * @return true for ICC locked enabled + * false for ICC locked disabled */ - boolean getSimLockEnabled (); + boolean getIccLockEnabled (); /** - * Set the sim pin lock enabled or disabled + * Set the ICC pin lock enabled or disabled * When the operation is complete, onComplete will be sent to its handler * * @param enabled "true" for locked "false" for unlocked. - * @param password needed to change the sim pin state, aka. Pin1 + * @param password needed to change the ICC pin state, aka. Pin1 * @param onComplete * onComplete.obj will be an AsyncResult * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail */ - void setSimLockEnabled(boolean enabled, String password, Message onComplete); + void setIccLockEnabled(boolean enabled, String password, Message onComplete); /** - * Change the sim password used in sim pin lock + * Change the ICC password used in ICC pin lock * When the operation is complete, onComplete will be sent to its handler * * @param oldPassword is the old password @@ -147,33 +146,33 @@ public interface SimCard * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail */ - void changeSimLockPassword(String oldPassword, String newPassword, + void changeIccLockPassword(String oldPassword, String newPassword, Message onComplete); /** - * Check whether sim fdn (fixed dialing number) is enabled + * Check whether ICC fdn (fixed dialing number) is enabled * This is a sync call which returns the cached pin enabled state * - * @return true for sim fdn enabled - * false for sim fdn disabled + * @return true for ICC fdn enabled + * false for ICC fdn disabled */ - boolean getSimFdnEnabled (); + boolean getIccFdnEnabled (); /** - * Set the sim fdn enabled or disabled + * Set the ICC fdn enabled or disabled * When the operation is complete, onComplete will be sent to its handler * * @param enabled "true" for locked "false" for unlocked. - * @param password needed to change the sim fdn enable, aka Pin2 + * @param password needed to change the ICC fdn enable, aka Pin2 * @param onComplete * onComplete.obj will be an AsyncResult * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail */ - void setSimFdnEnabled(boolean enabled, String password, Message onComplete); + void setIccFdnEnabled(boolean enabled, String password, Message onComplete); /** - * Change the sim password used in sim fdn enable + * Change the ICC password used in ICC fdn enable * When the operation is complete, onComplete will be sent to its handler * * @param oldPassword is the old password @@ -183,13 +182,13 @@ public interface SimCard * ((AsyncResult)onComplete.obj).exception == null on success * ((AsyncResult)onComplete.obj).exception != null on fail */ - void changeSimFdnPassword(String oldPassword, String newPassword, + void changeIccFdnPassword(String oldPassword, String newPassword, Message onComplete); void supplyNetworkDepersonalization (String pin, Message onComplete); /** - * Returns service provider name stored in SIM card. + * Returns service provider name stored in ICC card. * If there is no service provider name associated or the record is not * yet available, null will be returned <p> * @@ -199,7 +198,7 @@ public interface SimCard * * Also available via Android property "gsm.sim.operator.alpha" * - * @return Service Provider Name stored in SIM card + * @return Service Provider Name stored in ICC card * null if no service provider name associated or the record is not * yet available * diff --git a/telephony/java/com/android/internal/telephony/IccCardApplication.java b/telephony/java/com/android/internal/telephony/IccCardApplication.java new file mode 100644 index 0000000..9f60a6c --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccCardApplication.java @@ -0,0 +1,178 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + + +/** + * See also RIL_AppStatus in include/telephony/ril.h + * + * {@hide} + */ +public class IccCardApplication { + public enum AppType{ + APPTYPE_UNKNOWN, + APPTYPE_SIM, + APPTYPE_USIM, + APPTYPE_RUIM, + APPTYPE_CSIM + }; + + public enum AppState{ + APPSTATE_UNKNOWN, + APPSTATE_DETECTED, + APPSTATE_PIN, + APPSTATE_PUK, + APPSTATE_SUBSCRIPTION_PERSO, + APPSTATE_READY; + + boolean isPinRequired() { + return this == APPSTATE_PIN; + } + + boolean isPukRequired() { + return this == APPSTATE_PUK; + } + + boolean isSubscriptionPersoEnabled() { + return this == APPSTATE_SUBSCRIPTION_PERSO; + } + + boolean isAppReady() { + return this == APPSTATE_READY; + } + + boolean isAppNotReady() { + return this == APPSTATE_UNKNOWN || + this == APPSTATE_DETECTED; + } + }; + + public enum PersoSubState{ + PERSOSUBSTATE_UNKNOWN, + PERSOSUBSTATE_IN_PROGRESS, + PERSOSUBSTATE_READY, + PERSOSUBSTATE_SIM_NETWORK, + PERSOSUBSTATE_SIM_NETWORK_SUBSET, + PERSOSUBSTATE_SIM_CORPORATE, + PERSOSUBSTATE_SIM_SERVICE_PROVIDER, + PERSOSUBSTATE_SIM_SIM, + PERSOSUBSTATE_SIM_NETWORK_PUK, + PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK, + PERSOSUBSTATE_SIM_CORPORATE_PUK, + PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK, + PERSOSUBSTATE_SIM_SIM_PUK, + PERSOSUBSTATE_RUIM_NETWORK1, + PERSOSUBSTATE_RUIM_NETWORK2, + PERSOSUBSTATE_RUIM_HRPD, + PERSOSUBSTATE_RUIM_CORPORATE, + PERSOSUBSTATE_RUIM_SERVICE_PROVIDER, + PERSOSUBSTATE_RUIM_RUIM, + PERSOSUBSTATE_RUIM_NETWORK1_PUK, + PERSOSUBSTATE_RUIM_NETWORK2_PUK, + PERSOSUBSTATE_RUIM_HRPD_PUK, + PERSOSUBSTATE_RUIM_CORPORATE_PUK, + PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK, + PERSOSUBSTATE_RUIM_RUIM_PUK; + + boolean isPersoSubStateUnknown() { + return this == PERSOSUBSTATE_UNKNOWN; + } + }; + + public AppType app_type; + public AppState app_state; + // applicable only if app_state == RIL_APPSTATE_SUBSCRIPTION_PERSO + public PersoSubState perso_substate; + // null terminated string, e.g., from 0xA0, 0x00 -> 0x41, 0x30, 0x30, 0x30 */ + public String aid; + // null terminated string + public String app_label; + // applicable to USIM and CSIM + public int pin1_replaced; + public int pin1; + public int pin2; + + AppType AppTypeFromRILInt(int type) { + AppType newType; + /* RIL_AppType ril.h */ + switch(type) { + case 0: newType = AppType.APPTYPE_UNKNOWN; break; + case 1: newType = AppType.APPTYPE_SIM; break; + case 2: newType = AppType.APPTYPE_USIM; break; + case 3: newType = AppType.APPTYPE_RUIM; break; + case 4: newType = AppType.APPTYPE_CSIM; break; + default: + throw new RuntimeException( + "Unrecognized RIL_AppType: " +type); + } + return newType; + } + + AppState AppStateFromRILInt(int state) { + AppState newState; + /* RIL_AppState ril.h */ + switch(state) { + case 0: newState = AppState.APPSTATE_UNKNOWN; break; + case 1: newState = AppState.APPSTATE_DETECTED; break; + case 2: newState = AppState.APPSTATE_PIN; break; + case 3: newState = AppState.APPSTATE_PUK; break; + case 4: newState = AppState.APPSTATE_SUBSCRIPTION_PERSO; break; + case 5: newState = AppState.APPSTATE_READY; break; + default: + throw new RuntimeException( + "Unrecognized RIL_AppState: " +state); + } + return newState; + } + + PersoSubState PersoSubstateFromRILInt(int substate) { + PersoSubState newSubState; + /* RIL_PeroSubstate ril.h */ + switch(substate) { + case 0: newSubState = PersoSubState.PERSOSUBSTATE_UNKNOWN; break; + case 1: newSubState = PersoSubState.PERSOSUBSTATE_IN_PROGRESS; break; + case 2: newSubState = PersoSubState.PERSOSUBSTATE_READY; break; + case 3: newSubState = PersoSubState.PERSOSUBSTATE_SIM_NETWORK; break; + case 4: newSubState = PersoSubState.PERSOSUBSTATE_SIM_NETWORK_SUBSET; break; + case 5: newSubState = PersoSubState.PERSOSUBSTATE_SIM_CORPORATE; break; + case 6: newSubState = PersoSubState.PERSOSUBSTATE_SIM_SERVICE_PROVIDER; break; + case 7: newSubState = PersoSubState.PERSOSUBSTATE_SIM_SIM; break; + case 8: newSubState = PersoSubState.PERSOSUBSTATE_SIM_NETWORK_PUK; break; + case 9: newSubState = PersoSubState.PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK; break; + case 10: newSubState = PersoSubState.PERSOSUBSTATE_SIM_CORPORATE_PUK; break; + case 11: newSubState = PersoSubState.PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK; break; + case 12: newSubState = PersoSubState.PERSOSUBSTATE_SIM_SIM_PUK; break; + case 13: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_NETWORK1; break; + case 14: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_NETWORK2; break; + case 15: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_HRPD; break; + case 16: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_CORPORATE; break; + case 17: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_SERVICE_PROVIDER; break; + case 18: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_RUIM; break; + case 19: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_NETWORK1_PUK; break; + case 20: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_NETWORK2_PUK; break; + case 21: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_HRPD_PUK ; break; + case 22: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_CORPORATE_PUK; break; + case 23: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK; break; + case 24: newSubState = PersoSubState.PERSOSUBSTATE_RUIM_RUIM_PUK; break; + default: + throw new RuntimeException( + "Unrecognized RIL_PersoSubstate: " +substate); + } + return newSubState; + } + +} diff --git a/telephony/java/com/android/internal/telephony/IccCardStatus.java b/telephony/java/com/android/internal/telephony/IccCardStatus.java new file mode 100644 index 0000000..b602b1c --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccCardStatus.java @@ -0,0 +1,86 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import java.util.ArrayList; + +/** + * See also RIL_CardStatus in include/telephony/ril.h + * + * {@hide} + */ +public class IccCardStatus { + static final int CARD_MAX_APPS = 8; + + public enum CardState { + CARDSTATE_ABSENT, + CARDSTATE_PRESENT, + CARDSTATE_ERROR; + + boolean isCardPresent() { + return this == CARDSTATE_PRESENT; + } + }; + + public enum PinState { + PINSTATE_UNKNOWN, + PINSTATE_ENABLED_NOT_VERIFIED, + PINSTATE_ENABLED_VERIFIED, + PINSTATE_DISABLED, + PINSTATE_ENABLED_BLOCKED, + PINSTATE_ENABLED_PERM_BLOCKED + }; + + public CardState card_state; + public PinState universal_pin_state; + public int gsm_umts_subscription_app_index; + public int cdma_subscription_app_index; + public int num_applications; + + ArrayList<IccCardApplication> application = new ArrayList<IccCardApplication>(CARD_MAX_APPS); + + CardState CardStateFromRILInt(int state) { + CardState newState; + /* RIL_CardState ril.h */ + switch(state) { + case 0: newState = CardState.CARDSTATE_ABSENT; break; + case 1: newState = CardState.CARDSTATE_PRESENT; break; + case 2: newState = CardState.CARDSTATE_ERROR; break; + default: + throw new RuntimeException( + "Unrecognized RIL_CardState: " +state); + } + return newState; + } + + PinState PinStateFromRILInt(int state) { + PinState newState; + /* RIL_PinState ril.h */ + switch(state) { + case 0: newState = PinState.PINSTATE_UNKNOWN; break; + case 1: newState = PinState.PINSTATE_ENABLED_NOT_VERIFIED; break; + case 2: newState = PinState.PINSTATE_ENABLED_VERIFIED; break; + case 3: newState = PinState.PINSTATE_DISABLED; break; + case 4: newState = PinState.PINSTATE_ENABLED_BLOCKED; break; + case 5: newState = PinState.PINSTATE_ENABLED_PERM_BLOCKED; break; + default: + throw new RuntimeException( + "Unrecognized RIL_PinState: " +state); + } + return newState; + } +} diff --git a/telephony/java/com/android/internal/telephony/gsm/SimConstants.java b/telephony/java/com/android/internal/telephony/IccConstants.java index a7e3bbc..59ce5bb 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimConstants.java +++ b/telephony/java/com/android/internal/telephony/IccConstants.java @@ -14,13 +14,13 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; /** * {@hide} */ -public interface SimConstants { - // SIM file ids from TS 51.011 +public interface IccConstants { + // GSM SIM file ids from TS 51.011 public static final int EF_ADN = 0x6F3A; public static final int EF_FDN = 0x6F3B; public static final int EF_SDN = 0x6F49; @@ -42,7 +42,7 @@ public interface SimConstants { public static final int EF_CFIS = 0x6FCB; public static final int EF_IMG = 0x4f20; - // SIM file ids from CPHS (phase 2, version 4.2) CPHS4_2.WW6 + // GSM SIM file ids from CPHS (phase 2, version 4.2) CPHS4_2.WW6 public static final int EF_MAILBOX_CPHS = 0x6F17; public static final int EF_VOICE_MAIL_INDICATOR_CPHS = 0x6F11; public static final int EF_CFF_CPHS = 0x6F13; @@ -50,6 +50,10 @@ public interface SimConstants { public static final int EF_SPN_SHORT_CPHS = 0x6f18; public static final int EF_INFO_CPHS = 0x6f16; + // CDMA RUIM file ids from 3GPP2 C.S0023-0 + public static final int EF_CST = 0x6f32; + public static final int EF_RUIM_SPN =0x6F41; + // SMS record length from TS 51.011 10.5.3 static public final int SMS_RECORD_LENGTH = 176; } diff --git a/telephony/java/com/android/internal/telephony/gsm/SimFileTypeMismatch.java b/telephony/java/com/android/internal/telephony/IccException.java index 72790d0..1659a4e 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimFileTypeMismatch.java +++ b/telephony/java/com/android/internal/telephony/IccException.java @@ -14,20 +14,17 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; /** * {@hide} */ -public class SimFileTypeMismatch extends SimException -{ - SimFileTypeMismatch() - { +public class IccException extends Exception { + public IccException() { } - SimFileTypeMismatch(String s) - { + public IccException(String s) { super(s); } } diff --git a/telephony/java/com/android/internal/telephony/IccFileHandler.java b/telephony/java/com/android/internal/telephony/IccFileHandler.java new file mode 100644 index 0000000..e751c5e --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccFileHandler.java @@ -0,0 +1,513 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.os.*; +import android.util.Log; +import java.util.ArrayList; + +/** + * {@hide} + */ +public abstract class IccFileHandler extends Handler { + + //from TS 11.11 9.1 or elsewhere + static protected final int COMMAND_READ_BINARY = 0xb0; + static protected final int COMMAND_UPDATE_BINARY = 0xd6; + static protected final int COMMAND_READ_RECORD = 0xb2; + static protected final int COMMAND_UPDATE_RECORD = 0xdc; + static protected final int COMMAND_SEEK = 0xa2; + static protected final int COMMAND_GET_RESPONSE = 0xc0; + + // from TS 11.11 9.2.5 + static protected final int READ_RECORD_MODE_ABSOLUTE = 4; + + //***** types of files TS 11.11 9.3 + static protected final int EF_TYPE_TRANSPARENT = 0; + static protected final int EF_TYPE_LINEAR_FIXED = 1; + static protected final int EF_TYPE_CYCLIC = 3; + + //***** types of files TS 11.11 9.3 + static protected final int TYPE_RFU = 0; + static protected final int TYPE_MF = 1; + static protected final int TYPE_DF = 2; + static protected final int TYPE_EF = 4; + + // size of GET_RESPONSE for EF's + static protected final int GET_RESPONSE_EF_SIZE_BYTES = 15; + static protected final int GET_RESPONSE_EF_IMG_SIZE_BYTES = 10; + + // Byte order received in response to COMMAND_GET_RESPONSE + // Refer TS 51.011 Section 9.2.1 + static protected final int RESPONSE_DATA_RFU_1 = 0; + static protected final int RESPONSE_DATA_RFU_2 = 1; + + static protected final int RESPONSE_DATA_FILE_SIZE_1 = 2; + static protected final int RESPONSE_DATA_FILE_SIZE_2 = 3; + + static protected final int RESPONSE_DATA_FILE_ID_1 = 4; + static protected final int RESPONSE_DATA_FILE_ID_2 = 5; + static protected final int RESPONSE_DATA_FILE_TYPE = 6; + static protected final int RESPONSE_DATA_RFU_3 = 7; + static protected final int RESPONSE_DATA_ACCESS_CONDITION_1 = 8; + static protected final int RESPONSE_DATA_ACCESS_CONDITION_2 = 9; + static protected final int RESPONSE_DATA_ACCESS_CONDITION_3 = 10; + static protected final int RESPONSE_DATA_FILE_STATUS = 11; + static protected final int RESPONSE_DATA_LENGTH = 12; + static protected final int RESPONSE_DATA_STRUCTURE = 13; + static protected final int RESPONSE_DATA_RECORD_LENGTH = 14; + + + //***** Events + + /** Finished retrieving size of transparent EF; start loading. */ + static protected final int EVENT_GET_BINARY_SIZE_DONE = 4; + /** Finished loading contents of transparent EF; post result. */ + static protected final int EVENT_READ_BINARY_DONE = 5; + /** Finished retrieving size of records for linear-fixed EF; now load. */ + static protected final int EVENT_GET_RECORD_SIZE_DONE = 6; + /** Finished loading single record from a linear-fixed EF; post result. */ + static protected final int EVENT_READ_RECORD_DONE = 7; + /** Finished retrieving record size; post result. */ + static protected final int EVENT_GET_EF_LINEAR_RECORD_SIZE_DONE = 8; + /** Finished retrieving image instance record; post result. */ + static protected final int EVENT_READ_IMG_DONE = 9; + /** Finished retrieving icon data; post result. */ + static protected final int EVENT_READ_ICON_DONE = 10; + + // member variables + protected PhoneBase phone; + + static class LoadLinearFixedContext { + + int efid; + int recordNum, recordSize, countRecords; + boolean loadAll; + + Message onLoaded; + + ArrayList<byte[]> results; + + LoadLinearFixedContext(int efid, int recordNum, Message onLoaded) { + this.efid = efid; + this.recordNum = recordNum; + this.onLoaded = onLoaded; + this.loadAll = false; + } + + LoadLinearFixedContext(int efid, Message onLoaded) { + this.efid = efid; + this.recordNum = 1; + this.loadAll = true; + this.onLoaded = onLoaded; + } + } + + /** + * Default constructor + */ + protected IccFileHandler(PhoneBase phone) { + super(); + this.phone = phone; + } + + public void dispose() { + } + + //***** Public Methods + + /** + * Load a record from a SIM Linear Fixed EF + * + * @param fileid EF id + * @param recordNum 1-based (not 0-based) record number + * @param onLoaded + * + * ((AsyncResult)(onLoaded.obj)).result is the byte[] + * + */ + public void loadEFLinearFixed(int fileid, int recordNum, Message onLoaded) { + Message response + = obtainMessage(EVENT_GET_RECORD_SIZE_DONE, + new LoadLinearFixedContext(fileid, recordNum, onLoaded)); + + phone.mCM.iccIO(COMMAND_GET_RESPONSE, fileid, null, + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, response); + } + + /** + * Load a image instance record from a SIM Linear Fixed EF-IMG + * + * @param recordNum 1-based (not 0-based) record number + * @param onLoaded + * + * ((AsyncResult)(onLoaded.obj)).result is the byte[] + * + */ + public void loadEFImgLinearFixed(int recordNum, Message onLoaded) { + Message response = obtainMessage(EVENT_READ_IMG_DONE, + new LoadLinearFixedContext(IccConstants.EF_IMG, recordNum, + onLoaded)); + + phone.mCM.iccIO(COMMAND_GET_RESPONSE, IccConstants.EF_IMG, "img", + recordNum, READ_RECORD_MODE_ABSOLUTE, + GET_RESPONSE_EF_IMG_SIZE_BYTES, null, null, response); + } + + /** + * get record size for a linear fixed EF + * + * @param fileid EF id + * @param onLoaded ((AsnyncResult)(onLoaded.obj)).result is the recordSize[] + * int[0] is the record length int[1] is the total length of the EF + * file int[3] is the number of records in the EF file So int[0] * + * int[3] = int[1] + */ + public void getEFLinearRecordSize(int fileid, Message onLoaded) { + Message response + = obtainMessage(EVENT_GET_EF_LINEAR_RECORD_SIZE_DONE, + new LoadLinearFixedContext(fileid, onLoaded)); + phone.mCM.iccIO(COMMAND_GET_RESPONSE, fileid, null, + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, response); + } + + /** + * Load all records from a SIM Linear Fixed EF + * + * @param fileid EF id + * @param onLoaded + * + * ((AsyncResult)(onLoaded.obj)).result is an ArrayList<byte[]> + * + */ + public void loadEFLinearFixedAll(int fileid, Message onLoaded) { + Message response = obtainMessage(EVENT_GET_RECORD_SIZE_DONE, + new LoadLinearFixedContext(fileid,onLoaded)); + + phone.mCM.iccIO(COMMAND_GET_RESPONSE, fileid, null, + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, response); + } + + /** + * Load a SIM Transparent EF + * + * @param fileid EF id + * @param onLoaded + * + * ((AsyncResult)(onLoaded.obj)).result is the byte[] + * + */ + + public void loadEFTransparent(int fileid, Message onLoaded) { + Message response = obtainMessage(EVENT_GET_BINARY_SIZE_DONE, + fileid, 0, onLoaded); + + phone.mCM.iccIO(COMMAND_GET_RESPONSE, fileid, null, + 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, response); + } + + /** + * Load a SIM Transparent EF-IMG. Used right after loadEFImgLinearFixed to + * retrive STK's icon data. + * + * @param fileid EF id + * @param onLoaded + * + * ((AsyncResult)(onLoaded.obj)).result is the byte[] + * + */ + public void loadEFImgTransparent(int fileid, int highOffset, int lowOffset, + int length, Message onLoaded) { + Message response = obtainMessage(EVENT_READ_ICON_DONE, fileid, 0, + onLoaded); + + phone.mCM.iccIO(COMMAND_READ_BINARY, fileid, "img", highOffset, lowOffset, + length, null, null, response); + } + + /** + * Update a record in a linear fixed EF + * @param fileid EF id + * @param recordNum 1-based (not 0-based) record number + * @param data must be exactly as long as the record in the EF + * @param pin2 for CHV2 operations, otherwist must be null + * @param onComplete onComplete.obj will be an AsyncResult + * onComplete.obj.userObj will be a IccIoResult on success + */ + public void updateEFLinearFixed(int fileid, int recordNum, byte[] data, + String pin2, Message onComplete) { + phone.mCM.iccIO(COMMAND_UPDATE_RECORD, fileid, null, + recordNum, READ_RECORD_MODE_ABSOLUTE, data.length, + IccUtils.bytesToHexString(data), pin2, onComplete); + } + + /** + * Update a transparent EF + * @param fileid EF id + * @param data must be exactly as long as the EF + */ + public void updateEFTransparent(int fileid, byte[] data, Message onComplete) { + phone.mCM.iccIO(COMMAND_UPDATE_BINARY, fileid, null, + 0, 0, data.length, + IccUtils.bytesToHexString(data), null, onComplete); + } + + + //***** Abstract Methods + + + //***** Private Methods + + private void sendResult(Message response, Object result, Throwable ex) { + if (response == null) { + return; + } + + AsyncResult.forMessage(response, result, ex); + + response.sendToTarget(); + } + + //***** Overridden from Handler + + public void handleMessage(Message msg) { + AsyncResult ar; + IccIoResult result; + Message response = null; + String str; + LoadLinearFixedContext lc; + + IccException iccException; + byte data[]; + int size; + int fileid; + int recordNum; + int recordSize[]; + + try { + switch (msg.what) { + case EVENT_READ_IMG_DONE: + ar = (AsyncResult) msg.obj; + lc = (LoadLinearFixedContext) ar.userObj; + result = (IccIoResult) ar.result; + response = lc.onLoaded; + + iccException = result.getException(); + if (iccException != null) { + sendResult(response, result.payload, ar.exception); + } + break; + case EVENT_READ_ICON_DONE: + ar = (AsyncResult) msg.obj; + response = (Message) ar.userObj; + result = (IccIoResult) ar.result; + + iccException = result.getException(); + if (iccException != null) { + sendResult(response, result.payload, ar.exception); + } + break; + case EVENT_GET_EF_LINEAR_RECORD_SIZE_DONE: + ar = (AsyncResult)msg.obj; + lc = (LoadLinearFixedContext) ar.userObj; + result = (IccIoResult) ar.result; + response = lc.onLoaded; + + if (ar.exception != null) { + sendResult(response, null, ar.exception); + break; + } + + iccException = result.getException(); + if (iccException != null) { + sendResult(response, null, iccException); + break; + } + + data = result.payload; + + if (TYPE_EF != data[RESPONSE_DATA_FILE_TYPE] || + EF_TYPE_LINEAR_FIXED != data[RESPONSE_DATA_STRUCTURE]) { + throw new IccFileTypeMismatch(); + } + + recordSize = new int[3]; + recordSize[0] = data[RESPONSE_DATA_RECORD_LENGTH] & 0xFF; + recordSize[1] = ((data[RESPONSE_DATA_FILE_SIZE_1] & 0xff) << 8) + + (data[RESPONSE_DATA_FILE_SIZE_2] & 0xff); + recordSize[2] = recordSize[1] / recordSize[0]; + + sendResult(response, recordSize, null); + break; + case EVENT_GET_RECORD_SIZE_DONE: + ar = (AsyncResult)msg.obj; + lc = (LoadLinearFixedContext) ar.userObj; + result = (IccIoResult) ar.result; + response = lc.onLoaded; + + if (ar.exception != null) { + sendResult(response, null, ar.exception); + break; + } + + iccException = result.getException(); + + if (iccException != null) { + sendResult(response, null, iccException); + break; + } + + data = result.payload; + fileid = lc.efid; + recordNum = lc.recordNum; + + if (TYPE_EF != data[RESPONSE_DATA_FILE_TYPE]) { + throw new IccFileTypeMismatch(); + } + + if (EF_TYPE_LINEAR_FIXED != data[RESPONSE_DATA_STRUCTURE]) { + throw new IccFileTypeMismatch(); + } + + lc.recordSize = data[RESPONSE_DATA_RECORD_LENGTH] & 0xFF; + + size = ((data[RESPONSE_DATA_FILE_SIZE_1] & 0xff) << 8) + + (data[RESPONSE_DATA_FILE_SIZE_2] & 0xff); + + lc.countRecords = size / lc.recordSize; + + if (lc.loadAll) { + lc.results = new ArrayList<byte[]>(lc.countRecords); + } + + phone.mCM.iccIO(COMMAND_READ_RECORD, lc.efid, null, + lc.recordNum, + READ_RECORD_MODE_ABSOLUTE, + lc.recordSize, null, null, + obtainMessage(EVENT_READ_RECORD_DONE, lc)); + break; + case EVENT_GET_BINARY_SIZE_DONE: + ar = (AsyncResult)msg.obj; + response = (Message) ar.userObj; + result = (IccIoResult) ar.result; + + if (ar.exception != null) { + sendResult(response, null, ar.exception); + break; + } + + iccException = result.getException(); + + if (iccException != null) { + sendResult(response, null, iccException); + break; + } + + data = result.payload; + + fileid = msg.arg1; + + if (TYPE_EF != data[RESPONSE_DATA_FILE_TYPE]) { + throw new IccFileTypeMismatch(); + } + + if (EF_TYPE_TRANSPARENT != data[RESPONSE_DATA_STRUCTURE]) { + throw new IccFileTypeMismatch(); + } + + size = ((data[RESPONSE_DATA_FILE_SIZE_1] & 0xff) << 8) + + (data[RESPONSE_DATA_FILE_SIZE_2] & 0xff); + + phone.mCM.iccIO(COMMAND_READ_BINARY, fileid, null, + 0, 0, size, null, null, + obtainMessage(EVENT_READ_BINARY_DONE, + fileid, 0, response)); + break; + + case EVENT_READ_RECORD_DONE: + + ar = (AsyncResult)msg.obj; + lc = (LoadLinearFixedContext) ar.userObj; + result = (IccIoResult) ar.result; + response = lc.onLoaded; + + if (ar.exception != null) { + sendResult(response, null, ar.exception); + break; + } + + iccException = result.getException(); + + if (iccException != null) { + sendResult(response, null, iccException); + break; + } + + if (!lc.loadAll) { + sendResult(response, result.payload, null); + } else { + lc.results.add(result.payload); + + lc.recordNum++; + + if (lc.recordNum > lc.countRecords) { + sendResult(response, lc.results, null); + } else { + phone.mCM.iccIO(COMMAND_READ_RECORD, lc.efid, null, + lc.recordNum, + READ_RECORD_MODE_ABSOLUTE, + lc.recordSize, null, null, + obtainMessage(EVENT_READ_RECORD_DONE, lc)); + } + } + + break; + + case EVENT_READ_BINARY_DONE: + ar = (AsyncResult)msg.obj; + response = (Message) ar.userObj; + result = (IccIoResult) ar.result; + + if (ar.exception != null) { + sendResult(response, null, ar.exception); + break; + } + + iccException = result.getException(); + + if (iccException != null) { + sendResult(response, null, iccException); + break; + } + + sendResult(response, result.payload, null); + break; + + }} catch (Exception exc) { + if (response != null) { + sendResult(response, null, exc); + } else { + loge("uncaught exception" + exc); + } + } + } + + protected abstract void logd(String s); + + protected abstract void loge(String s); + +} diff --git a/telephony/java/com/android/internal/telephony/gsm/SimFileNotFound.java b/telephony/java/com/android/internal/telephony/IccFileNotFound.java index 982e2fd..915cea6 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimFileNotFound.java +++ b/telephony/java/com/android/internal/telephony/IccFileNotFound.java @@ -14,25 +14,21 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; /** * {@hide} */ -public class SimFileNotFound extends SimException -{ - SimFileNotFound() - { +public class IccFileNotFound extends IccException { + IccFileNotFound() { } - SimFileNotFound(String s) - { + IccFileNotFound(String s) { super(s); } - SimFileNotFound(int ef) - { - super("SIM EF Not Found 0x" + Integer.toHexString(ef)); + IccFileNotFound(int ef) { + super("ICC EF Not Found 0x" + Integer.toHexString(ef)); } } diff --git a/telephony/java/com/android/internal/telephony/gsm/SimException.java b/telephony/java/com/android/internal/telephony/IccFileTypeMismatch.java index 1c0daba..66fcfa9 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimException.java +++ b/telephony/java/com/android/internal/telephony/IccFileTypeMismatch.java @@ -14,45 +14,17 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; /** * {@hide} */ -public class SimException extends Exception -{ - SimException() - { +public class IccFileTypeMismatch extends IccException { + public IccFileTypeMismatch() { } - SimException(String s) - { + public IccFileTypeMismatch(String s) { super(s); } } - -final class SimVmFixedException extends SimException { - SimVmFixedException() - { - - } - - SimVmFixedException(String s) - { - super(s); - } -} - -final class SimVmNotSupportedException extends SimException { - SimVmNotSupportedException() - { - - } - - SimVmNotSupportedException(String s) - { - super(s); - } -} - diff --git a/telephony/java/com/android/internal/telephony/gsm/SimIoResult.java b/telephony/java/com/android/internal/telephony/IccIoResult.java index 2c4da83..a6e0ec3 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimIoResult.java +++ b/telephony/java/com/android/internal/telephony/IccIoResult.java @@ -14,33 +14,30 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; /** * {@hide} */ public class -SimIoResult -{ +IccIoResult { int sw1; int sw2; - byte[] payload; - public SimIoResult(int sw1, int sw2, byte[] payload) - { + public byte[] payload; + + public IccIoResult(int sw1, int sw2, byte[] payload) { this.sw1 = sw1; this.sw2 = sw2; this.payload = payload; } - public SimIoResult(int sw1, int sw2, String hexString) - { - this(sw1, sw2, SimUtils.hexStringToBytes(hexString)); + public IccIoResult(int sw1, int sw2, String hexString) { + this(sw1, sw2, IccUtils.hexStringToBytes(hexString)); } - public String toString() - { - return "SimIoResponse sw1:0x" + Integer.toHexString(sw1) + " sw2:0x" + public String toString() { + return "IccIoResponse sw1:0x" + Integer.toHexString(sw1) + " sw2:0x" + Integer.toHexString(sw2); } @@ -49,27 +46,25 @@ SimIoResult * See GSM 11.11 Section 9.4 * (the fun stuff is absent in 51.011) */ - public boolean success() - { + public boolean success() { return sw1 == 0x90 || sw1 == 0x91 || sw1 == 0x9e || sw1 == 0x9f; } /** * Returns exception on error or null if success */ - public SimException getException() - { + public IccException getException() { if (success()) return null; - + switch (sw1) { case 0x94: if (sw2 == 0x08) { - return new SimFileTypeMismatch(); + return new IccFileTypeMismatch(); } else { - return new SimFileNotFound(); + return new IccFileNotFound(); } default: - return new SimException("sw1:" + sw1 + " sw2:" + sw2); + return new IccException("sw1:" + sw1 + " sw2:" + sw2); } } } diff --git a/telephony/java/com/android/internal/telephony/IccPhoneBookInterfaceManager.java b/telephony/java/com/android/internal/telephony/IccPhoneBookInterfaceManager.java new file mode 100644 index 0000000..0bcaaa6 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccPhoneBookInterfaceManager.java @@ -0,0 +1,266 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.content.pm.PackageManager; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.os.ServiceManager; +import android.telephony.PhoneNumberUtils; +import android.util.Log; + +import java.util.ArrayList; +import java.util.List; + +/** + * SimPhoneBookInterfaceManager to provide an inter-process communication to + * access ADN-like SIM records. + */ +public abstract class IccPhoneBookInterfaceManager extends IIccPhoneBook.Stub { + protected static final boolean DBG = true; + + protected PhoneBase phone; + protected AdnRecordCache adnCache; + protected Object mLock = new Object(); + protected int recordSize[]; + protected boolean success; + protected List<AdnRecord> records; + + protected static final boolean ALLOW_SIM_OP_IN_UI_THREAD = false; + + protected static final int EVENT_GET_SIZE_DONE = 1; + protected static final int EVENT_LOAD_DONE = 2; + protected static final int EVENT_UPDATE_DONE = 3; + + protected Handler mBaseHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + AsyncResult ar; + + switch (msg.what) { + case EVENT_GET_SIZE_DONE: + ar = (AsyncResult) msg.obj; + synchronized (mLock) { + if (ar.exception == null) { + recordSize = (int[])ar.result; + // recordSize[0] is the record length + // recordSize[1] is the total length of the EF file + // recordSize[2] is the number of records in the EF file + logd("GET_RECORD_SIZE Size " + recordSize[0] + + " total " + recordSize[1] + + " #record " + recordSize[2]); + mLock.notifyAll(); + } + } + break; + case EVENT_UPDATE_DONE: + ar = (AsyncResult) msg.obj; + synchronized (mLock) { + success = (ar.exception == null); + mLock.notifyAll(); + } + break; + case EVENT_LOAD_DONE: + ar = (AsyncResult)msg.obj; + synchronized (mLock) { + if (ar.exception == null) { + records = (List<AdnRecord>) + ((ArrayList<AdnRecord>) ar.result); + } else { + if(DBG) logd("Cannot load ADN records"); + if (records != null) { + records.clear(); + } + } + mLock.notifyAll(); + } + break; + } + } + }; + + public IccPhoneBookInterfaceManager(PhoneBase phone) { + this.phone = phone; + } + + public void dispose() { + } + + protected void publish() { + //NOTE service "simphonebook" added by IccSmsInterfaceManagerProxy + ServiceManager.addService("simphonebook", this); + } + + protected abstract void logd(String msg); + + protected abstract void loge(String msg); + + /** + * Replace oldAdn with newAdn in ADN-like record in EF + * + * getAdnRecordsInEf must be called at least once before this function, + * otherwise an error will be returned + * throws SecurityException if no WRITE_CONTACTS permission + * + * @param efid must be one among EF_ADN, EF_FDN, and EF_SDN + * @param oldTag adn tag to be replaced + * @param oldPhoneNumber adn number to be replaced + * Set both oldTag and oldPhoneNubmer to "" means to replace an + * empty record, aka, insert new record + * @param newTag adn tag to be stored + * @param newPhoneNumber adn number ot be stored + * Set both newTag and newPhoneNubmer to "" means to replace the old + * record with empty one, aka, delete old record + * @param pin2 required to update EF_FDN, otherwise must be null + * @return true for success + */ + public boolean + updateAdnRecordsInEfBySearch (int efid, + String oldTag, String oldPhoneNumber, + String newTag, String newPhoneNumber, String pin2) { + + + if (phone.getContext().checkCallingOrSelfPermission( + android.Manifest.permission.WRITE_CONTACTS) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException( + "Requires android.permission.WRITE_CONTACTS permission"); + } + + + if (DBG) logd("updateAdnRecordsInEfBySearch: efid=" + efid + + " ("+ oldTag + "," + oldPhoneNumber + ")"+ "==>" + + " ("+ newTag + "," + newPhoneNumber + ")"+ " pin2=" + pin2); + synchronized(mLock) { + checkThread(); + success = false; + Message response = mBaseHandler.obtainMessage(EVENT_UPDATE_DONE); + AdnRecord oldAdn = new AdnRecord(oldTag, oldPhoneNumber); + AdnRecord newAdn = new AdnRecord(newTag, newPhoneNumber); + adnCache.updateAdnBySearch(efid, oldAdn, newAdn, pin2, response); + try { + mLock.wait(); + } catch (InterruptedException e) { + logd("interrupted while trying to update by search"); + } + } + return success; + } + + /** + * Update an ADN-like EF record by record index + * + * This is useful for iteration the whole ADN file, such as write the whole + * phone book or erase/format the whole phonebook + * throws SecurityException if no WRITE_CONTACTS permission + * + * @param efid must be one among EF_ADN, EF_FDN, and EF_SDN + * @param newTag adn tag to be stored + * @param newPhoneNumber adn number to be stored + * Set both newTag and newPhoneNubmer to "" means to replace the old + * record with empty one, aka, delete old record + * @param index is 1-based adn record index to be updated + * @param pin2 required to update EF_FDN, otherwise must be null + * @return true for success + */ + public boolean + updateAdnRecordsInEfByIndex(int efid, String newTag, + String newPhoneNumber, int index, String pin2) { + + if (phone.getContext().checkCallingOrSelfPermission( + android.Manifest.permission.WRITE_CONTACTS) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException( + "Requires android.permission.WRITE_CONTACTS permission"); + } + + if (DBG) logd("updateAdnRecordsInEfByIndex: efid=" + efid + + " Index=" + index + " ==> " + + "("+ newTag + "," + newPhoneNumber + ")"+ " pin2=" + pin2); + synchronized(mLock) { + checkThread(); + success = false; + Message response = mBaseHandler.obtainMessage(EVENT_UPDATE_DONE); + AdnRecord newAdn = new AdnRecord(newTag, newPhoneNumber); + adnCache.updateAdnByIndex(efid, newAdn, index, pin2, response); + try { + mLock.wait(); + } catch (InterruptedException e) { + logd("interrupted while trying to update by index"); + } + } + return success; + } + + /** + * Get the capacity of records in efid + * + * @param efid the EF id of a ADN-like ICC + * @return int[3] array + * recordSizes[0] is the single record length + * recordSizes[1] is the total length of the EF file + * recordSizes[2] is the number of records in the EF file + */ + public abstract int[] getAdnRecordsSize(int efid); + + /** + * Loads the AdnRecords in efid and returns them as a + * List of AdnRecords + * + * throws SecurityException if no READ_CONTACTS permission + * + * @param efid the EF id of a ADN-like ICC + * @return List of AdnRecord + */ + public List<AdnRecord> getAdnRecordsInEf(int efid) { + + if (phone.getContext().checkCallingOrSelfPermission( + android.Manifest.permission.READ_CONTACTS) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException( + "Requires android.permission.READ_CONTACTS permission"); + } + + if (DBG) logd("getAdnRecordsInEF: efid=" + efid); + + synchronized(mLock) { + checkThread(); + Message response = mBaseHandler.obtainMessage(EVENT_LOAD_DONE); + adnCache.requestLoadAllAdnLike(efid, response); + try { + mLock.wait(); + } catch (InterruptedException e) { + logd("interrupted while trying to load from the SIM"); + } + } + return records; + } + + protected void checkThread() { + if (!ALLOW_SIM_OP_IN_UI_THREAD) { + // Make sure this isn't the UI thread, since it will block + if (mBaseHandler.getLooper().equals(Looper.myLooper())) { + loge("query() called on the main UI thread!"); + throw new IllegalStateException( + "You cannot call query on this provder from the main UI thread."); + } + } + } +} + diff --git a/telephony/java/com/android/internal/telephony/IccPhoneBookInterfaceManagerProxy.java b/telephony/java/com/android/internal/telephony/IccPhoneBookInterfaceManagerProxy.java new file mode 100644 index 0000000..1c0fc52 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccPhoneBookInterfaceManagerProxy.java @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.content.pm.PackageManager; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.os.ServiceManager; +import android.telephony.PhoneNumberUtils; +import android.util.Log; + +import java.util.ArrayList; +import java.util.List; + + +/** + * SimPhoneBookInterfaceManager to provide an inter-process communication to + * access ADN-like SIM records. + */ +public class IccPhoneBookInterfaceManagerProxy extends IIccPhoneBook.Stub { + private IccPhoneBookInterfaceManager mIccPhoneBookInterfaceManager; + + public IccPhoneBookInterfaceManagerProxy(IccPhoneBookInterfaceManager + iccPhoneBookInterfaceManager) { + mIccPhoneBookInterfaceManager = iccPhoneBookInterfaceManager; + if(ServiceManager.getService("simphonebook") == null) { + ServiceManager.addService("simphonebook", this); + } + } + + public void setmIccPhoneBookInterfaceManager( + IccPhoneBookInterfaceManager iccPhoneBookInterfaceManager) { + this.mIccPhoneBookInterfaceManager = iccPhoneBookInterfaceManager; + } + + public boolean + updateAdnRecordsInEfBySearch (int efid, + String oldTag, String oldPhoneNumber, + String newTag, String newPhoneNumber, + String pin2) throws android.os.RemoteException { + return mIccPhoneBookInterfaceManager.updateAdnRecordsInEfBySearch( + efid, oldTag, oldPhoneNumber, newTag, newPhoneNumber, pin2); + } + + public boolean + updateAdnRecordsInEfByIndex(int efid, String newTag, + String newPhoneNumber, int index, String pin2) throws android.os.RemoteException { + return mIccPhoneBookInterfaceManager.updateAdnRecordsInEfByIndex(efid, + newTag, newPhoneNumber, index, pin2); + } + + public int[] getAdnRecordsSize(int efid) throws android.os.RemoteException { + return mIccPhoneBookInterfaceManager.getAdnRecordsSize(efid); + } + + public List<AdnRecord> getAdnRecordsInEf(int efid) throws android.os.RemoteException { + return mIccPhoneBookInterfaceManager.getAdnRecordsInEf(efid); + } +} diff --git a/telephony/java/com/android/internal/telephony/gsm/SimProvider.java b/telephony/java/com/android/internal/telephony/IccProvider.java index cece4ba..4cbd779 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimProvider.java +++ b/telephony/java/com/android/internal/telephony/IccProvider.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; import android.content.ContentProvider; import android.content.UriMatcher; @@ -31,11 +31,16 @@ import android.util.Log; import java.util.ArrayList; import java.util.List; +import com.android.internal.telephony.IccConstants; +import com.android.internal.telephony.AdnRecord; +import com.android.internal.telephony.IIccPhoneBook; + + /** * {@hide} */ -public class SimProvider extends ContentProvider { - private static final String TAG = "SimProvider"; +public class IccProvider extends ContentProvider { + private static final String TAG = "IccProvider"; private static final boolean DBG = false; @@ -56,9 +61,9 @@ public class SimProvider extends ContentProvider { new UriMatcher(UriMatcher.NO_MATCH); static { - URL_MATCHER.addURI("sim", "adn", ADN); - URL_MATCHER.addURI("sim", "fdn", FDN); - URL_MATCHER.addURI("sim", "sdn", SDN); + URL_MATCHER.addURI("icc", "adn", ADN); + URL_MATCHER.addURI("icc", "fdn", FDN); + URL_MATCHER.addURI("icc", "sdn", SDN); } @@ -81,21 +86,21 @@ public class SimProvider extends ContentProvider { public Cursor query(Uri url, String[] projection, String selection, String[] selectionArgs, String sort) { ArrayList<ArrayList> results; - + if (!mSimulator) { switch (URL_MATCHER.match(url)) { case ADN: - results = loadFromEf(SimConstants.EF_ADN); + results = loadFromEf(IccConstants.EF_ADN); break; - + case FDN: - results = loadFromEf(SimConstants.EF_FDN); + results = loadFromEf(IccConstants.EF_FDN); break; - + case SDN: - results = loadFromEf(SimConstants.EF_SDN); + results = loadFromEf(IccConstants.EF_SDN); break; - + default: throw new IllegalArgumentException("Unknown URL " + url); } @@ -152,11 +157,11 @@ public class SimProvider extends ContentProvider { int match = URL_MATCHER.match(url); switch (match) { case ADN: - efType = SimConstants.EF_ADN; + efType = IccConstants.EF_ADN; break; case FDN: - efType = SimConstants.EF_FDN; + efType = IccConstants.EF_FDN; pin2 = initialValues.getAsString("pin2"); break; @@ -167,7 +172,7 @@ public class SimProvider extends ContentProvider { String tag = initialValues.getAsString("tag"); String number = initialValues.getAsString("number"); - boolean success = addSimRecordToEf(efType, tag, number, pin2); + boolean success = addIccRecordToEf(efType, tag, number, pin2); if (!success) { return null; @@ -183,7 +188,7 @@ public class SimProvider extends ContentProvider { buf.append("fdn/"); break; } - + // TODO: we need to find out the rowId for the newly added record buf.append(0); @@ -218,11 +223,11 @@ public class SimProvider extends ContentProvider { int match = URL_MATCHER.match(url); switch (match) { case ADN: - efType = SimConstants.EF_ADN; + efType = IccConstants.EF_ADN; break; case FDN: - efType = SimConstants.EF_FDN; + efType = IccConstants.EF_FDN; break; default: @@ -269,7 +274,7 @@ public class SimProvider extends ContentProvider { return 0; } - boolean success = deleteSimRecordFromEf(efType, tag, number, pin2); + boolean success = deleteIccRecordFromEf(efType, tag, number, pin2); if (!success) { return 0; } @@ -287,11 +292,11 @@ public class SimProvider extends ContentProvider { int match = URL_MATCHER.match(url); switch (match) { case ADN: - efType = SimConstants.EF_ADN; + efType = IccConstants.EF_ADN; break; case FDN: - efType = SimConstants.EF_FDN; + efType = IccConstants.EF_FDN; pin2 = values.getAsString("pin2"); break; @@ -305,7 +310,7 @@ public class SimProvider extends ContentProvider { String newTag = values.getAsString("newTag"); String newNumber = values.getAsString("newNumber"); - boolean success = updateSimRecordInEf(efType, tag, number, + boolean success = updateIccRecordInEf(efType, tag, number, newTag, newNumber, pin2); if (!success) { @@ -322,17 +327,16 @@ public class SimProvider extends ContentProvider { if (DBG) log("loadFromEf: efType=" + efType); try { - ISimPhoneBook simIpb = ISimPhoneBook.Stub.asInterface( + IIccPhoneBook iccIpb = IIccPhoneBook.Stub.asInterface( ServiceManager.getService("simphonebook")); - if (simIpb != null) { - adnRecords = simIpb.getAdnRecordsInEf(efType); + if (iccIpb != null) { + adnRecords = iccIpb.getAdnRecordsInEf(efType); } } catch (RemoteException ex) { // ignore it } catch (SecurityException ex) { if (DBG) log(ex.toString()); } - if (adnRecords != null) { // Load the results @@ -351,8 +355,8 @@ public class SimProvider extends ContentProvider { } private boolean - addSimRecordToEf(int efType, String name, String number, String pin2) { - if (DBG) log("addSimRecordToEf: efType=" + efType + ", name=" + name + + addIccRecordToEf(int efType, String name, String number, String pin2) { + if (DBG) log("addIccRecordToEf: efType=" + efType + ", name=" + name + ", number=" + number); boolean success = false; @@ -361,11 +365,12 @@ public class SimProvider extends ContentProvider { // updateAdnRecordsInEfBySearch()? In any case, we will leave // the UI level logic to fill that prereq if necessary. But // hopefully, we can remove this requirement. + try { - ISimPhoneBook simIpb = ISimPhoneBook.Stub.asInterface( + IIccPhoneBook iccIpb = IIccPhoneBook.Stub.asInterface( ServiceManager.getService("simphonebook")); - if (simIpb != null) { - success = simIpb.updateAdnRecordsInEfBySearch(efType, "", "", + if (iccIpb != null) { + success = iccIpb.updateAdnRecordsInEfBySearch(efType, "", "", name, number, pin2); } } catch (RemoteException ex) { @@ -373,23 +378,23 @@ public class SimProvider extends ContentProvider { } catch (SecurityException ex) { if (DBG) log(ex.toString()); } - if (DBG) log("addSimRecordToEf: " + success); + if (DBG) log("addIccRecordToEf: " + success); return success; } private boolean - updateSimRecordInEf(int efType, String oldName, String oldNumber, + updateIccRecordInEf(int efType, String oldName, String oldNumber, String newName, String newNumber,String pin2) { - if (DBG) log("updateSimRecordInEf: efType=" + efType + + if (DBG) log("updateIccRecordInEf: efType=" + efType + ", oldname=" + oldName + ", oldnumber=" + oldNumber + ", newname=" + newName + ", newnumber=" + newNumber); boolean success = false; try { - ISimPhoneBook simIpb = ISimPhoneBook.Stub.asInterface( + IIccPhoneBook iccIpb = IIccPhoneBook.Stub.asInterface( ServiceManager.getService("simphonebook")); - if (simIpb != null) { - success = simIpb.updateAdnRecordsInEfBySearch(efType, + if (iccIpb != null) { + success = iccIpb.updateAdnRecordsInEfBySearch(efType, oldName, oldNumber, newName, newNumber, pin2); } } catch (RemoteException ex) { @@ -397,34 +402,30 @@ public class SimProvider extends ContentProvider { } catch (SecurityException ex) { if (DBG) log(ex.toString()); } - - if (DBG) log("updateSimRecordInEf: " + success); + if (DBG) log("updateIccRecordInEf: " + success); return success; } - private boolean deleteSimRecordFromEf(int efType, - String name, String number, - String pin2) { - if (DBG) log("deleteSimRecordFromEf: efType=" + efType + + private boolean deleteIccRecordFromEf(int efType, String name, String number, String pin2) { + if (DBG) log("deleteIccRecordFromEf: efType=" + efType + ", name=" + name + ", number=" + number + ", pin2=" + pin2); boolean success = false; try { - ISimPhoneBook simIpb = ISimPhoneBook.Stub.asInterface( + IIccPhoneBook iccIpb = IIccPhoneBook.Stub.asInterface( ServiceManager.getService("simphonebook")); - if (simIpb != null) { - success = simIpb.updateAdnRecordsInEfBySearch(efType, - name, number, "", "", pin2); + if (iccIpb != null) { + success = iccIpb.updateAdnRecordsInEfBySearch(efType, + name, number, "", "", pin2); } } catch (RemoteException ex) { // ignore it } catch (SecurityException ex) { if (DBG) log(ex.toString()); } - - if (DBG) log("deleteSimRecordFromEf: " + success); + if (DBG) log("deleteIccRecordFromEf: " + success); return success; } @@ -449,7 +450,7 @@ public class SimProvider extends ContentProvider { } private void log(String msg) { - Log.d(TAG, "[SimProvider] " + msg); + Log.d(TAG, "[IccProvider] " + msg); } } diff --git a/telephony/java/com/android/internal/telephony/IccRecords.java b/telephony/java/com/android/internal/telephony/IccRecords.java new file mode 100644 index 0000000..114094b --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccRecords.java @@ -0,0 +1,237 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.os.Registrant; +import android.os.RegistrantList; +import android.util.Log; + +import java.util.ArrayList; + +/** + * {@hide} + */ +public abstract class IccRecords extends Handler implements IccConstants { + + protected static final boolean DBG = true; + //***** Instance Variables + + protected PhoneBase phone; + protected RegistrantList recordsLoadedRegistrants = new RegistrantList(); + + protected int recordsToLoad; // number of pending load requests + + protected AdnRecordCache adnCache; + + //***** Cached SIM State; cleared on channel close + + protected boolean recordsRequested = false; // true if we've made requests for the sim records + + public String iccid; + protected String msisdn = null; // My mobile number + protected String msisdnTag = null; + protected String voiceMailNum = null; + protected String voiceMailTag = null; + protected String newVoiceMailNum = null; + protected String newVoiceMailTag = null; + protected boolean isVoiceMailFixed = false; + protected int countVoiceMessages = 0; + + protected int mncLength = 0; // 0 is used to indicate that the value + // is not initialized + protected int mailboxIndex = 0; // 0 is no mailbox dailing number associated + + protected String spn; + protected int spnDisplayCondition; + + //***** Constants + + // Bitmasks for SPN display rules. + protected static final int SPN_RULE_SHOW_SPN = 0x01; + protected static final int SPN_RULE_SHOW_PLMN = 0x02; + + //***** Event Constants + protected static final int EVENT_SET_MSISDN_DONE = 30; + + //***** Constructor + + public IccRecords(PhoneBase p) { + this.phone = p; + } + + protected abstract void onRadioOffOrNotAvailable(); + + //***** Public Methods + public AdnRecordCache getAdnCache() { + return adnCache; + } + + public void registerForRecordsLoaded(Handler h, int what, Object obj) { + Registrant r = new Registrant(h, what, obj); + recordsLoadedRegistrants.add(r); + + if (recordsToLoad == 0 && recordsRequested == true) { + r.notifyRegistrant(new AsyncResult(null, null, null)); + } + } + + public void unregisterForRecordsLoaded(Handler h) { + recordsLoadedRegistrants.remove(h); + } + + public String getMsisdnNumber() { + return msisdn; + } + + /** + * Set subscriber number to SIM record + * + * The subscriber number is stored in EF_MSISDN (TS 51.011) + * + * When the operation is complete, onComplete will be sent to its handler + * + * @param alphaTag alpha-tagging of the dailing nubmer (up to 10 characters) + * @param number dailing nubmer (up to 20 digits) + * if the number starts with '+', then set to international TOA + * @param onComplete + * onComplete.obj will be an AsyncResult + * ((AsyncResult)onComplete.obj).exception == null on success + * ((AsyncResult)onComplete.obj).exception != null on fail + */ + public void setMsisdnNumber(String alphaTag, String number, + Message onComplete) { + + msisdn = number; + msisdnTag = alphaTag; + + if(DBG) log("Set MSISDN: " + msisdnTag +" " + msisdn); + + + AdnRecord adn = new AdnRecord(msisdnTag, msisdn); + + new AdnRecordLoader(phone).updateEF(adn, EF_MSISDN, EF_EXT1, 1, null, + obtainMessage(EVENT_SET_MSISDN_DONE, onComplete)); + } + + public String getMsisdnAlphaTag() { + return msisdnTag; + } + + public String getVoiceMailNumber() { + return voiceMailNum; + } + + /** + * Return Service Provider Name stored in SIM (EF_SPN=0x6F46) or in RUIM (EF_RUIM_SPN=0x6F41) + * @return null if SIM is not yet ready or no RUIM entry + */ + public String getServiceProviderName() { + return spn; + } + + /** + * Set voice mail number to SIM record + * + * The voice mail number can be stored either in EF_MBDN (TS 51.011) or + * EF_MAILBOX_CPHS (CPHS 4.2) + * + * If EF_MBDN is available, store the voice mail number to EF_MBDN + * + * If EF_MAILBOX_CPHS is enabled, store the voice mail number to EF_CHPS + * + * So the voice mail number will be stored in both EFs if both are available + * + * Return error only if both EF_MBDN and EF_MAILBOX_CPHS fail. + * + * When the operation is complete, onComplete will be sent to its handler + * + * @param alphaTag alpha-tagging of the dailing nubmer (upto 10 characters) + * @param voiceNumber dailing nubmer (upto 20 digits) + * if the number is start with '+', then set to international TOA + * @param onComplete + * onComplete.obj will be an AsyncResult + * ((AsyncResult)onComplete.obj).exception == null on success + * ((AsyncResult)onComplete.obj).exception != null on fail + */ + public abstract void setVoiceMailNumber(String alphaTag, String voiceNumber, + Message onComplete); + + public String getVoiceMailAlphaTag() { + return voiceMailTag; + } + + /** + * Sets the SIM voice message waiting indicator records + * @param line GSM Subscriber Profile Number, one-based. Only '1' is supported + * @param countWaiting The number of messages waiting, if known. Use + * -1 to indicate that an unknown number of + * messages are waiting + */ + public abstract void setVoiceMessageWaiting(int line, int countWaiting); + + /** @return true if there are messages waiting, false otherwise. */ + public boolean getVoiceMessageWaiting() { + return countVoiceMessages != 0; + } + + /** + * Returns number of voice messages waiting, if available + * If not available (eg, on an older CPHS SIM) -1 is returned if + * getVoiceMessageWaiting() is true + */ + public int getCountVoiceMessages() { + return countVoiceMessages; + } + + /** + * Called by STK Service when REFRESH is received. + * @param fileChanged indicates whether any files changed + * @param fileList if non-null, a list of EF files that changed + */ + public abstract void onRefresh(boolean fileChanged, int[] fileList); + + + public boolean getRecordsLoaded() { + if (recordsToLoad == 0 && recordsRequested == true) { + return true; + } else { + return false; + } + } + + //***** Overridden from Handler + public abstract void handleMessage(Message msg); + + protected abstract void onRecordLoaded(); + + protected abstract void onAllRecordsLoaded(); + + /** + * Returns the SpnDisplayRule based on settings on the SIM and the + * specified plmn (currently-registered PLMN). See TS 22.101 Annex A + * and TS 51.011 10.3.11 for details. + * + * If the SPN is not found on the SIM, the rule is always PLMN_ONLY. + */ + protected abstract int getDisplayRule(String plmn); + + protected abstract void log(String s); +} + diff --git a/telephony/java/com/android/internal/telephony/IccSmsInterfaceManager.java b/telephony/java/com/android/internal/telephony/IccSmsInterfaceManager.java new file mode 100644 index 0000000..620f2de --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccSmsInterfaceManager.java @@ -0,0 +1,166 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.app.PendingIntent; +import android.content.Context; +import android.util.Log; + +import java.util.ArrayList; +import java.util.List; + +import static android.telephony.SmsManager.STATUS_ON_ICC_FREE; + +/** + * IccSmsInterfaceManager to provide an inter-process communication to + * access Sms in Icc. + */ +public abstract class IccSmsInterfaceManager extends ISms.Stub { + static final boolean DBG = true; + + protected PhoneBase mPhone; + protected Context mContext; + protected SMSDispatcher mDispatcher; + + protected IccSmsInterfaceManager(PhoneBase phone){ + mPhone = phone; + mContext = phone.getContext(); + } + + protected void enforceReceiveAndSend(String message) { + mContext.enforceCallingPermission( + "android.permission.RECEIVE_SMS", message); + mContext.enforceCallingPermission( + "android.permission.SEND_SMS", message); + } + + /** + * Send a Raw PDU SMS + * + * @param smsc the SMSC to send the message through, or NULL for the + * defatult SMSC + * @param pdu the raw PDU to send + * @param sentIntent if not NULL this <code>Intent</code> is + * broadcast when the message is sucessfully sent, or failed. + * The result code will be <code>Activity.RESULT_OK<code> for success, + * or one of these errors: + * <code>RESULT_ERROR_GENERIC_FAILURE</code> + * <code>RESULT_ERROR_RADIO_OFF</code> + * <code>RESULT_ERROR_NULL_PDU</code>. + * @param deliveryIntent if not NULL this <code>Intent</code> is + * broadcast when the message is delivered to the recipient. The + * raw pdu of the status report is in the extended data ("pdu"). + */ + public void sendRawPdu(byte[] smsc, byte[] pdu, PendingIntent sentIntent, + PendingIntent deliveryIntent) { + Context context = mPhone.getContext(); + + context.enforceCallingPermission( + "android.permission.SEND_SMS", + "Sending SMS message"); + if (DBG) log("sendRawPdu: smsc=" + smsc + + " pdu="+ pdu + " sentIntent" + sentIntent + + " deliveryIntent" + deliveryIntent); + mDispatcher.sendRawPdu(smsc, pdu, sentIntent, deliveryIntent); + } + + /** + * Send a multi-part text based SMS. + * + * @param destinationAddress the address to send the message to + * @param scAddress is the service center address or null to use + * the current default SMSC + * @param parts an <code>ArrayList</code> of strings that, in order, + * comprise the original message + * @param sentIntents if not null, an <code>ArrayList</code> of + * <code>PendingIntent</code>s (one for each message part) that is + * broadcast when the corresponding message part has been sent. + * The result code will be <code>Activity.RESULT_OK<code> for success, + * or one of these errors: + * <code>RESULT_ERROR_GENERIC_FAILURE</code> + * <code>RESULT_ERROR_RADIO_OFF</code> + * <code>RESULT_ERROR_NULL_PDU</code>. + * @param deliveryIntents if not null, an <code>ArrayList</code> of + * <code>PendingIntent</code>s (one for each message part) that is + * broadcast when the corresponding message part has been delivered + * to the recipient. The raw pdu of the status report is in the + * extended data ("pdu"). + */ + public void sendMultipartText(String destinationAddress, String scAddress, List<String> parts, + List<PendingIntent> sentIntents, List<PendingIntent> deliveryIntents) { + Context context = mPhone.getContext(); + + context.enforceCallingPermission( + "android.permission.SEND_SMS", + "Sending SMS message"); + if (DBG) log("sendMultipartText"); + mDispatcher.sendMultipartText(destinationAddress, scAddress, (ArrayList<String>) parts, + (ArrayList<PendingIntent>) sentIntents, (ArrayList<PendingIntent>) deliveryIntents); + } + + /** + * create SmsRawData lists from all sms record byte[] + * Use null to indicate "free" record + * + * @param messages List of message records from EF_SMS. + * @return SmsRawData list of all in-used records + */ + protected ArrayList<SmsRawData> buildValidRawData(ArrayList<byte[]> messages) { + int count = messages.size(); + ArrayList<SmsRawData> ret; + + ret = new ArrayList<SmsRawData>(count); + + for (int i = 0; i < count; i++) { + byte[] ba = messages.get(i); + if (ba[0] == STATUS_ON_ICC_FREE) { + ret.add(null); + } else { + ret.add(new SmsRawData(messages.get(i))); + } + } + + return ret; + } + + /** + * Generates an EF_SMS record from status and raw PDU. + * + * @param status Message status. See TS 51.011 10.5.3. + * @param pdu Raw message PDU. + * @return byte array for the record. + */ + protected byte[] makeSmsRecordData(int status, byte[] pdu) { + byte[] data = new byte[IccConstants.SMS_RECORD_LENGTH]; + + // Status bits for this record. See TS 51.011 10.5.3 + data[0] = (byte)(status & 7); + + System.arraycopy(pdu, 0, data, 1, pdu.length); + + // Pad out with 0xFF's. + for (int j = pdu.length+1; j < IccConstants.SMS_RECORD_LENGTH; j++) { + data[j] = -1; + } + + return data; + } + + protected abstract void log(String msg); + +} + diff --git a/telephony/java/com/android/internal/telephony/IccSmsInterfaceManagerProxy.java b/telephony/java/com/android/internal/telephony/IccSmsInterfaceManagerProxy.java new file mode 100644 index 0000000..a51d074 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccSmsInterfaceManagerProxy.java @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.app.PendingIntent; +import android.os.ServiceManager; + +import java.util.List; + +public class IccSmsInterfaceManagerProxy extends ISms.Stub { + private IccSmsInterfaceManager mIccSmsInterfaceManager; + + public IccSmsInterfaceManagerProxy(IccSmsInterfaceManager + iccSmsInterfaceManager) { + this.mIccSmsInterfaceManager = iccSmsInterfaceManager; + if(ServiceManager.getService("isms") == null) { + ServiceManager.addService("isms", this); + } + } + + public void setmIccSmsInterfaceManager(IccSmsInterfaceManager iccSmsInterfaceManager) { + this.mIccSmsInterfaceManager = iccSmsInterfaceManager; + } + + public boolean + updateMessageOnIccEf(int index, int status, byte[] pdu) throws android.os.RemoteException { + return mIccSmsInterfaceManager.updateMessageOnIccEf(index, status, pdu); + } + + public boolean copyMessageToIccEf(int status, byte[] pdu, + byte[] smsc) throws android.os.RemoteException { + return mIccSmsInterfaceManager.copyMessageToIccEf(status, pdu, smsc); + } + + public List<SmsRawData> getAllMessagesFromIccEf() throws android.os.RemoteException { + return mIccSmsInterfaceManager.getAllMessagesFromIccEf(); + } + + public void sendRawPdu(byte[] smsc, byte[] pdu, PendingIntent sentIntent, + PendingIntent deliveryIntent) throws android.os.RemoteException { + mIccSmsInterfaceManager.sendRawPdu(smsc, pdu, sentIntent, + deliveryIntent); + } + + public void sendMultipartText(String destinationAddress, String scAddress, + List<String> parts, List<PendingIntent> sentIntents, + List<PendingIntent> deliveryIntents) throws android.os.RemoteException { + mIccSmsInterfaceManager.sendMultipartText(destinationAddress, scAddress, + parts, sentIntents, deliveryIntents); + } + +} diff --git a/telephony/java/com/android/internal/telephony/gsm/SimUtils.java b/telephony/java/com/android/internal/telephony/IccUtils.java index 2eecdba..881ed2d 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimUtils.java +++ b/telephony/java/com/android/internal/telephony/IccUtils.java @@ -14,48 +14,48 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; - -import java.io.UnsupportedEncodingException; +package com.android.internal.telephony; import android.graphics.Bitmap; import android.graphics.Color; import android.util.Log; +import com.android.internal.telephony.GsmAlphabet; + +import java.io.UnsupportedEncodingException; + /** * Various methods, useful for dealing with SIM data. */ -public class SimUtils -{ - static final String LOG_TAG="GSM"; +public class IccUtils { + static final String LOG_TAG="IccUtils"; /** * Many fields in GSM SIM's are stored as nibble-swizzled BCD * - * Assumes left-justified field that may be padded right with 0xf + * Assumes left-justified field that may be padded right with 0xf * values. * * Stops on invalid BCD value, returning string so far */ public static String - bcdToString(byte[] data, int offset, int length) - { + bcdToString(byte[] data, int offset, int length) { StringBuilder ret = new StringBuilder(length*2); - + for (int i = offset ; i < offset + length ; i++) { byte b; int v; - + v = data[i] & 0xf; if (v > 9) break; ret.append((char)('0' + v)); v = (data[i] >> 4) & 0xf; if (v > 9) break; - ret.append((char)('0' + v)); + ret.append((char)('0' + v)); } - - return ret.toString(); + + return ret.toString(); } @@ -66,7 +66,7 @@ public class SimUtils * significant nibble. * * Out-of-range digits are treated as 0 for the sake of the time stamp, - * because of this: + * because of this: * * TS 23.040 section 9.2.3.11 * "if the MS receives a non-integer value in the SCTS, it shall @@ -74,13 +74,12 @@ public class SimUtils * exactly as received" */ public static int - bcdByteToInt(byte b) - { + bcdByteToInt(byte b) { int ret = 0; // treat out-of-range BCD values as 0 if ((b & 0xf0) <= 0x90) { - ret = (b >> 4) & 0xf; + ret = (b >> 4) & 0xf; } if ((b & 0x0f) <= 0x09) { @@ -90,6 +89,24 @@ public class SimUtils return ret; } + /** Decodes BCD byte like {@link bcdByteToInt}, but the most significant BCD + * digit is expected in the most significant nibble. + */ + public static int + beBcdByteToInt(byte b) { + int ret = 0; + + // treat out-of-range BCD values as 0 + if ((b & 0xf0) <= 0x90) { + ret = ((b >> 4) & 0xf) * 10; + } + + if ((b & 0x0f) <= 0x09) { + ret += (b & 0xf); + } + + return ret; + } /** * Decodes a string field that's formatted like the EF[ADN] alpha @@ -97,11 +114,11 @@ public class SimUtils * * From TS 51.011 10.5.1: * Coding: - * this alpha tagging shall use either - * - the SMS default 7 bit coded alphabet as defined in - * TS 23.038 [12] with bit 8 set to 0. The alpha identifier + * this alpha tagging shall use either + * - the SMS default 7 bit coded alphabet as defined in + * TS 23.038 [12] with bit 8 set to 0. The alpha identifier * shall be left justified. Unused bytes shall be set to 'FF'; or - * - one of the UCS2 coded options as defined in annex B. + * - one of the UCS2 coded options as defined in annex B. * * Annex B from TS 11.11 V8.13.0: * 1) If the first octet in the alpha string is '80', then the @@ -109,7 +126,7 @@ public class SimUtils * 2) if the first octet in the alpha string is '81', then the * second octet contains a value indicating the number of * characters in the string, and the third octet contains an - * 8 bit number which defines bits 15 to 8 of a 16 bit + * 8 bit number which defines bits 15 to 8 of a 16 bit * base pointer, where bit 16 is set to zero and bits 7 to 1 * are also set to zero. These sixteen bits constitute a * base pointer to a "half page" in the UCS2 code space, to be @@ -127,8 +144,7 @@ public class SimUtils * base pointer to a "half page" in the UCS2 code space... */ public static String - adnStringFieldToString(byte[] data, int offset, int length) - { + adnStringFieldToString(byte[] data, int offset, int length) { if (length >= 1) { if (data[offset] == (byte) 0x80) { int ucslen = (length - 1) / 2; @@ -208,8 +224,7 @@ public class SimUtils } static int - hexCharToInt(char c) - { + hexCharToInt(char c) { if (c >= '0' && c <= '9') return (c - '0'); if (c >= 'A' && c <= 'F') return (c - 'A' + 10); if (c >= 'a' && c <= 'f') return (c - 'a' + 10); @@ -219,17 +234,16 @@ public class SimUtils /** * Converts a hex String to a byte array. - * + * * @param s A string of hexadecimal characters, must be an even number of * chars long * * @return byte array representation - * + * * @throws RuntimeException on invalid format */ public static byte[] - hexStringToBytes(String s) - { + hexStringToBytes(String s) { byte[] ret; if (s == null) return null; @@ -239,10 +253,10 @@ public class SimUtils ret = new byte[sz/2]; for (int i=0 ; i <sz ; i+=2) { - ret[i/2] = (byte) ((hexCharToInt(s.charAt(i)) << 4) + ret[i/2] = (byte) ((hexCharToInt(s.charAt(i)) << 4) | hexCharToInt(s.charAt(i+1))); } - + return ret; } @@ -253,10 +267,9 @@ public class SimUtils * null returns null */ public static String - bytesToHexString(byte[] bytes) - { + bytesToHexString(byte[] bytes) { if (bytes == null) return null; - + StringBuilder ret = new StringBuilder(2*bytes.length); for (int i = 0 ; i < bytes.length ; i++) { @@ -281,10 +294,9 @@ public class SimUtils * empty string returned on decode error */ public static String - networkNameToString(byte[] data, int offset, int length) - { + networkNameToString(byte[] data, int offset, int length) { String ret; - + if ((data[offset] & 0x80) != 0x80 || length < 1) { return ""; } @@ -295,13 +307,12 @@ public class SimUtils int countSeptets; int unusedBits = data[offset] & 7; countSeptets = (((length - 1) * 8) - unusedBits) / 7 ; - ret = GsmAlphabet.gsm7BitPackedToString( - data, offset + 1, countSeptets); + ret = GsmAlphabet.gsm7BitPackedToString(data, offset + 1, countSeptets); break; case 1: // UCS2 try { - ret = new String(data, + ret = new String(data, offset + 1, length - 1, "utf-16"); } catch (UnsupportedEncodingException ex) { ret = ""; @@ -332,7 +343,7 @@ public class SimUtils * @param data The raw data * @param length The length of image body * @return The bitmap - */ + */ public static Bitmap parseToBnW(byte[] data, int length){ int valueIndex = 0; int width = data[valueIndex++] & 0xFF; @@ -369,7 +380,7 @@ public class SimUtils /** * a TS 131.102 image instance of code scheme '11' into color Bitmap - * + * * @param data The raw data * @param length the length of image body * @param transparency with or without transparency diff --git a/telephony/java/com/android/internal/telephony/IccVmFixedException.java b/telephony/java/com/android/internal/telephony/IccVmFixedException.java new file mode 100644 index 0000000..45679c1 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccVmFixedException.java @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +/** + * {@hide} + */ +public final class IccVmFixedException extends IccException { + IccVmFixedException() + { + + } + + public IccVmFixedException(String s) + { + super(s); + } +}
\ No newline at end of file diff --git a/telephony/java/com/android/internal/telephony/IccVmNotSupportedException.java b/telephony/java/com/android/internal/telephony/IccVmNotSupportedException.java new file mode 100644 index 0000000..7e90d24 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/IccVmNotSupportedException.java @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +/** + * {@hide} + */ +public final class IccVmNotSupportedException extends IccException { + IccVmNotSupportedException() + { + + } + + public IccVmNotSupportedException(String s) + { + super(s); + } +} diff --git a/telephony/java/com/android/internal/telephony/MmiCode.java b/telephony/java/com/android/internal/telephony/MmiCode.java index 925b06f..c71ff77 100644 --- a/telephony/java/com/android/internal/telephony/MmiCode.java +++ b/telephony/java/com/android/internal/telephony/MmiCode.java @@ -41,14 +41,14 @@ public interface MmiCode * @return Localized message for UI display, valid only in COMPLETE * or FAILED states. null otherwise */ - + public CharSequence getMessage(); /** * Cancels pending MMI request. * State becomes CANCELLED unless already COMPLETE or FAILED */ - public void cancel(); + public void cancel(); /** * @return true if the network response is a REQUEST for more user input. diff --git a/telephony/java/com/android/internal/telephony/Phone.java b/telephony/java/com/android/internal/telephony/Phone.java index 05e61f2..ed90d32 100644 --- a/telephony/java/com/android/internal/telephony/Phone.java +++ b/telephony/java/com/android/internal/telephony/Phone.java @@ -17,10 +17,14 @@ package com.android.internal.telephony; import android.content.Context; +import android.content.SharedPreferences; import android.os.Handler; import android.os.Message; +import android.preference.PreferenceManager; import android.telephony.CellLocation; import android.telephony.ServiceState; + +import com.android.internal.telephony.DataConnection; import com.android.internal.telephony.gsm.NetworkInfo; import com.android.internal.telephony.gsm.PdpConnection; import com.android.internal.telephony.test.SimulatedRadioControl; @@ -38,13 +42,13 @@ public interface Phone { /** used to enable additional debug messages */ static final boolean DEBUG_PHONE = true; - - /** + + /** * The phone state. One of the following:<p> * <ul> * <li>IDLE = no phone activity</li> - * <li>RINGING = a phone call is ringing or call waiting. + * <li>RINGING = a phone call is ringing or call waiting. * In the latter case, another call is active as well</li> * <li>OFFHOOK = The phone is off hook. At least one call * exists that is dialing, active or holding and no calls are @@ -70,7 +74,7 @@ public interface Phone { CONNECTED, CONNECTING, DISCONNECTED, SUSPENDED; }; - enum DataActivityState { + public enum DataActivityState { /** * The state of a data activity. * <ul> @@ -131,6 +135,8 @@ public interface Phone { static final String REASON_DATA_ENABLED = "dataEnabled"; static final String REASON_GPRS_ATTACHED = "gprsAttached"; static final String REASON_GPRS_DETACHED = "gprsDetached"; + static final String REASON_CDMA_DATA_ATTACHED = "cdmaDataAttached"; + static final String REASON_CDMA_DATA_DETACHED = "cdmaDataDetached"; static final String REASON_APN_CHANGED = "apnChanged"; static final String REASON_APN_SWITCHED = "apnSwitched"; static final String REASON_RESTORE_DEFAULT_APN = "restoreDefaultApn"; @@ -152,12 +158,32 @@ public interface Phone { static final int BM_BOUNDARY = 6; // upper band boundary // Used for preferred network type - static final int NT_AUTO_TYPE = 0; // WCDMA preferred (auto mode) - static final int NT_GSM_TYPE = 1; // GSM only - static final int NT_WCDMA_TYPE = 2; // WCDMA only - - /** - * Get the current ServiceState. Use + // Note NT_* substitute RILConstants.NETWORK_MODE_* above the Phone + int NT_MODE_WCDMA_PREF = 0; /* GSM/WCDMA (WCDMA preferred) */ + int NT_MODE_GSM_ONLY = 1; /* GSM only */ + int NT_MODE_WCDMA_ONLY = 2; /* WCDMA only */ + int NT_MODE_GSM_UMTS = 3; /* GSM/WCDMA (auto mode, according to PRL) + AVAILABLE Application Settings menu*/ + int NT_MODE_CDMA = 4; /* CDMA and EvDo (auto mode, according to PRL) + AVAILABLE Application Settings menu*/ + int NT_MODE_CDMA_NO_EVDO = 5; /* CDMA only */ + int NT_MODE_EVDO_NO_CDMA = 6; /* EvDo only */ + int NT_MODE_GLOBAL = 7; /* GSM/WCDMA, CDMA, and EvDo (auto mode, according to PRL) + AVAILABLE Application Settings menu*/ + int PREFERRED_NT_MODE = NT_MODE_GLOBAL; + + + // Used for CDMA roaming mode + static final int CDMA_RM_HOME = 0; //Home Networks only, as defined in PRL + static final int CDMA_RM_AFFILIATED = 1; //Roaming an Affiliated networks, as defined in PRL + static final int CDMA_RM_ANY = 2; //Roaming on Any Network, as defined in PRL + + // Used for CDMA subscription mode + static final int CDMA_SUBSCRIPTION_RUIM_SIM = 0; //RUIM/SIM (default) + static final int CDMA_SUBSCRIPTION_NV = 1; //NV -> non-volatile memory + + /** + * Get the current ServiceState. Use * <code>registerForServiceStateChanged</code> to be informed of * updates. */ @@ -167,11 +193,12 @@ public interface Phone { * Get the current CellLocation. */ CellLocation getCellLocation(); - + /** * Get the current DataState. No change notification exists at this - * interface -- use - * {@link com.android.internal.telephony.PhoneStateIntentReceiver PhoneStateIntentReceiver} instead. + * interface -- use + * {@link com.android.internal.telephony.PhoneStateIntentReceiver PhoneStateIntentReceiver} + * instead. */ DataState getDataConnectionState(); @@ -181,58 +208,70 @@ public interface Phone { * {@link TelephonyManager} instead. */ DataActivityState getDataActivityState(); - + /** * Gets the context for the phone, as set at initialization time. */ Context getContext(); - /** + /** + * Disables the DNS check (i.e., allows "0.0.0.0"). + * Useful for lab testing environment. + * @param b true disables the check, false enables. + */ + void disableDnsCheck(boolean b); + + /** + * Returns true if the DNS check is currently disabled. + */ + boolean isDnsCheckDisabled(); + + /** * Get current coarse-grained voice call state. - * Use {@link #registerForPhoneStateChanged(Handler, int, Object) + * Use {@link #registerForPhoneStateChanged(Handler, int, Object) * registerForPhoneStateChanged()} for change notification. <p> * If the phone has an active call and call waiting occurs, * then the phone state is RINGING not OFFHOOK - * <strong>Note:</strong> + * <strong>Note:</strong> * This registration point provides notification of finer-grained * changes.<p> * */ State getState(); - /** + /** * Returns a string identifier for this phone interface for parties * outside the phone app process. * @return The string name. */ String getPhoneName(); - /** + /** * Returns an array of string identifiers for the APN types serviced by the * currently active or last connected APN. * @return The string array. */ String[] getActiveApnTypes(); - - /** + + /** * Returns a string identifier for currently active or last connected APN. * @return The string name. */ String getActiveApn(); - - /** + + /** * Get current signal strength. No change notification available on this * interface. Use <code>PhoneStateNotifier</code> or an equivalent. - * An ASU is 0-31 or -1 if unknown (for GSM, dBm = -113 - 2 * asu). + * An ASU is 0-31 or -1 if unknown (for GSM, dBm = -113 - 2 * asu). * The following special values are defined:</p> * <ul><li>0 means "-113 dBm or less".</li> * <li>31 means "-51 dBm or greater".</li></ul> - * + * * @return Current signal strength in ASU's. */ int getSignalStrengthASU(); - - /** + + /** * Notifies when a previously untracked non-ringing/waiting connection has appeared. * This is likely due to some other entity (eg, SIM card application) initiating a call. */ @@ -243,7 +282,7 @@ public interface Phone { */ void unregisterForUnknownConnection(Handler h); - /** + /** * Notifies when any aspect of the voice call state changes. * Resulting events will have an AsyncResult in <code>Message.obj</code>. * AsyncResult.userData will be set to the obj argument here. @@ -252,13 +291,13 @@ public interface Phone { void registerForPhoneStateChanged(Handler h, int what, Object obj); /** - * Unregisters for voice call state change notifications. + * Unregisters for voice call state change notifications. * Extraneous calls are tolerated silently. */ void unregisterForPhoneStateChanged(Handler h); - /** + /** * Notifies when a new ringing or waiting connection has appeared.<p> * * Messages received from this: @@ -267,19 +306,19 @@ public interface Phone { * AsyncResult.result = a Connection. <p> * Please check Connection.isRinging() to make sure the Connection * has not dropped since this message was posted. - * If Connection.isRinging() is true, then + * If Connection.isRinging() is true, then * Connection.getCall() == Phone.getRingingCall() */ void registerForNewRingingConnection(Handler h, int what, Object obj); /** - * Unregisters for new ringing connection notification. + * Unregisters for new ringing connection notification. * Extraneous calls are tolerated silently */ void unregisterForNewRingingConnection(Handler h); - /** + /** * Notifies when an incoming call rings.<p> * * Messages received from this: @@ -288,29 +327,29 @@ public interface Phone { * AsyncResult.result = a Connection. <p> */ void registerForIncomingRing(Handler h, int what, Object obj); - + /** - * Unregisters for ring notification. + * Unregisters for ring notification. * Extraneous calls are tolerated silently */ - + void unregisterForIncomingRing(Handler h); - - - /** + + + /** * Notifies when a voice connection has disconnected, either due to local * or remote hangup or error. - * + * * Messages received from this will have the following members:<p> * <ul><li>Message.obj will be an AsyncResult</li> * <li>AsyncResult.userObj = obj</li> - * <li>AsyncResult.result = a Connection object that is + * <li>AsyncResult.result = a Connection object that is * no longer connected.</li></ul> */ void registerForDisconnect(Handler h, int what, Object obj); /** - * Unregisters for voice disconnection notification. + * Unregisters for voice disconnection notification. * Extraneous calls are tolerated silently */ void unregisterForDisconnect(Handler h); @@ -330,7 +369,7 @@ public interface Phone { void registerForMmiInitiate(Handler h, int what, Object obj); /** - * Unregisters for new MMI initiate notification. + * Unregisters for new MMI initiate notification. * Extraneous calls are tolerated silently */ void unregisterForMmiInitiate(Handler h); @@ -346,7 +385,7 @@ public interface Phone { void registerForMmiComplete(Handler h, int what, Object obj); /** - * Unregisters for MMI complete notification. + * Unregisters for MMI complete notification. * Extraneous calls are tolerated silently */ void unregisterForMmiComplete(Handler h); @@ -355,7 +394,7 @@ public interface Phone { * Returns a list of MMI codes that are pending. (They have initiated * but have not yet completed). * Presently there is only ever one. - * Use <code>registerForMmiInitiate</code> + * Use <code>registerForMmiInitiate</code> * and <code>registerForMmiComplete</code> for change notification. */ public List<? extends MmiCode> getPendingMmiCodes(); @@ -370,14 +409,14 @@ public interface Phone { public void sendUssdResponse(String ussdMessge); /** - * Register for ServiceState changed. + * Register for ServiceState changed. * Message.obj will contain an AsyncResult. * AsyncResult.result will be a ServiceState instance */ void registerForServiceStateChanged(Handler h, int what, Object obj); /** - * Unregisters for ServiceStateChange notification. + * Unregisters for ServiceStateChange notification. * Extraneous calls are tolerated silently */ void unregisterForServiceStateChanged(Handler h); @@ -394,9 +433,9 @@ public interface Phone { void registerForSuppServiceNotification(Handler h, int what, Object obj); /** - * Unregisters for Supplementary Service notifications. + * Unregisters for Supplementary Service notifications. * Extraneous calls are tolerated silently - * + * * @param h Handler to be removed from the registrant list. */ void unregisterForSuppServiceNotification(Handler h); @@ -414,53 +453,85 @@ public interface Phone { /** * Unregister for notifications when a supplementary service attempt fails. * Extraneous calls are tolerated silently - * + * * @param h Handler to be removed from the registrant list. */ void unregisterForSuppServiceFailed(Handler h); - /** - * Returns SIM record load state. Use + /** + * Register for notifications when a sInCall VoicePrivacy is enabled + * + * @param h Handler that receives the notification message. + * @param what User-defined message code. + * @param obj User object. + */ + void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj); + + /** + * Unegister for notifications when a sInCall VoicePrivacy is enabled + * + * @param h Handler to be removed from the registrant list. + */ + void unregisterForInCallVoicePrivacyOn(Handler h); + + /** + * Register for notifications when a sInCall VoicePrivacy is disabled + * + * @param h Handler that receives the notification message. + * @param what User-defined message code. + * @param obj User object. + */ + void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj); + + /** + * Unegister for notifications when a sInCall VoicePrivacy is disabled + * + * @param h Handler to be removed from the registrant list. + */ + void unregisterForInCallVoicePrivacyOff(Handler h); + + /** + * Returns SIM record load state. Use * <code>getSimCard().registerForReady()</code> for change notification. * - * @return true if records from the SIM have been loaded and are + * @return true if records from the SIM have been loaded and are * available (if applicable). If not applicable to the underlying * technology, returns true as well. */ - boolean getSimRecordsLoaded(); + boolean getIccRecordsLoaded(); /** - * Returns the SIM card interface for this phone, or null + * Returns the ICC card interface for this phone, or null * if not applicable to underlying technology. */ - SimCard getSimCard(); + IccCard getIccCard(); /** - * Answers a ringing or waiting call. Active calls, if any, go on hold. + * Answers a ringing or waiting call. Active calls, if any, go on hold. * Answering occurs asynchronously, and final notification occurs via - * {@link #registerForPhoneStateChanged(android.os.Handler, int, + * {@link #registerForPhoneStateChanged(android.os.Handler, int, * java.lang.Object) registerForPhoneStateChanged()}. * * @exception CallStateException when no call is ringing or waiting */ void acceptCall() throws CallStateException; - /** - * Reject (ignore) a ringing call. In GSM, this means UDUB - * (User Determined User Busy). Reject occurs asynchronously, - * and final notification occurs via - * {@link #registerForPhoneStateChanged(android.os.Handler, int, + /** + * Reject (ignore) a ringing call. In GSM, this means UDUB + * (User Determined User Busy). Reject occurs asynchronously, + * and final notification occurs via + * {@link #registerForPhoneStateChanged(android.os.Handler, int, * java.lang.Object) registerForPhoneStateChanged()}. * * @exception CallStateException when no call is ringing or waiting */ void rejectCall() throws CallStateException; - /** + /** * Places any active calls on hold, and makes any held calls * active. Switch occurs asynchronously and may fail. - * Final notification occurs via - * {@link #registerForPhoneStateChanged(android.os.Handler, int, + * Final notification occurs via + * {@link #registerForPhoneStateChanged(android.os.Handler, int, * java.lang.Object) registerForPhoneStateChanged()}. * * @exception CallStateException if a call is ringing, waiting, or @@ -469,24 +540,40 @@ public interface Phone { void switchHoldingAndActive() throws CallStateException; /** - * Whether or not the phone can conference in the current phone + * Whether or not the phone can conference in the current phone * state--that is, one call holding and one call active. - * @return true if the phone can conference; false otherwise. + * @return true if the phone can conference; false otherwise. */ boolean canConference(); /** - * Conferences holding and active. Conference occurs asynchronously - * and may fail. Final notification occurs via - * {@link #registerForPhoneStateChanged(android.os.Handler, int, - * java.lang.Object) registerForPhoneStateChanged()}. - * + * Conferences holding and active. Conference occurs asynchronously + * and may fail. Final notification occurs via + * {@link #registerForPhoneStateChanged(android.os.Handler, int, + * java.lang.Object) registerForPhoneStateChanged()}. + * * @exception CallStateException if canConference() would return false. * In these cases, this operation may not be performed. */ void conference() throws CallStateException; /** + * Enable or disable enhanced Voice Privacy (VP). If enhanced VP is + * disabled, normal VP is enabled. + * + * @param enable whether true or false to enable or disable. + * @param onComplete a callback message when the action is completed. + */ + void enableEnhancedVoicePrivacy(boolean enable, Message onComplete); + + /** + * Get the currently set Voice Privacy (VP) mode. + * + * @param onComplete a callback message when the action is completed. + */ + void getEnhancedVoicePrivacy(Message onComplete); + + /** * Whether or not the phone can do explicit call transfer in the current * phone state--that is, one call holding and one call active. * @return true if the phone can do explicit call transfer; false otherwise. @@ -513,65 +600,65 @@ public interface Phone { void clearDisconnected(); - /** - * Gets the foreground call object, which represents all connections that - * are dialing or active (all connections + /** + * Gets the foreground call object, which represents all connections that + * are dialing or active (all connections * that have their audio path connected).<p> * * The foreground call is a singleton object. It is constant for the life * of this phone. It is never null.<p> - * + * * The foreground call will only ever be in one of these states: - * IDLE, ACTIVE, DIALING, ALERTING, or DISCONNECTED. + * IDLE, ACTIVE, DIALING, ALERTING, or DISCONNECTED. * * State change notification is available via - * {@link #registerForPhoneStateChanged(android.os.Handler, int, + * {@link #registerForPhoneStateChanged(android.os.Handler, int, * java.lang.Object) registerForPhoneStateChanged()}. */ Call getForegroundCall(); - /** + /** * Gets the background call object, which represents all connections that * are holding (all connections that have been accepted or connected, but * do not have their audio path connected). <p> * * The background call is a singleton object. It is constant for the life * of this phone object . It is never null.<p> - * + * * The background call will only ever be in one of these states: * IDLE, HOLDING or DISCONNECTED. * * State change notification is available via - * {@link #registerForPhoneStateChanged(android.os.Handler, int, + * {@link #registerForPhoneStateChanged(android.os.Handler, int, * java.lang.Object) registerForPhoneStateChanged()}. */ Call getBackgroundCall(); - /** - * Gets the ringing call object, which represents an incoming + /** + * Gets the ringing call object, which represents an incoming * connection (if present) that is pending answer/accept. (This connection * may be RINGING or WAITING, and there may be only one.)<p> * The ringing call is a singleton object. It is constant for the life * of this phone. It is never null.<p> - * + * * The ringing call will only ever be in one of these states: * IDLE, INCOMING, WAITING or DISCONNECTED. * * State change notification is available via - * {@link #registerForPhoneStateChanged(android.os.Handler, int, + * {@link #registerForPhoneStateChanged(android.os.Handler, int, * java.lang.Object) registerForPhoneStateChanged()}. */ Call getRingingCall(); - /** + /** * Initiate a new voice connection. This happens asynchronously, so you * cannot assume the audio path is connected (or a call index has been * assigned) until PhoneStateChanged notification has occurred. * * @exception CallStateException if a new outgoing call is not currently - * possible because no more call slots exist or a call exists that is - * dialing, alerting, ringing, or waiting. Other errors are + * possible because no more call slots exist or a call exists that is + * dialing, alerting, ringing, or waiting. Other errors are * handled asynchronously. */ Connection dial(String dialString) throws CallStateException; @@ -579,7 +666,7 @@ public interface Phone { /** * Handles PIN MMI commands (PIN/PIN2/PUK/PUK2), which are initiated * without SEND (so <code>dial</code> is not appropriate). - * + * * @param dialString the MMI command to be executed. * @return true if MMI command is executed. */ @@ -597,7 +684,7 @@ public interface Phone { boolean handleInCallMmiCommands(String command) throws CallStateException; /** - * Play a DTMF tone on the active call. Ignored if there is no active call. + * Play a DTMF tone on the active call. Ignored if there is no active call. * @param c should be one of 0-9, '*' or '#'. Other values will be * silently ignored. */ @@ -619,20 +706,20 @@ public interface Phone { /** - * Sets the radio power on/off state (off is sometimes - * called "airplane mode"). Current state can be gotten via - * {@link #getServiceState()}.{@link + * Sets the radio power on/off state (off is sometimes + * called "airplane mode"). Current state can be gotten via + * {@link #getServiceState()}.{@link * android.telephony.ServiceState#getState() getState()}. - * <strong>Note: </strong>This request is asynchronous. + * <strong>Note: </strong>This request is asynchronous. * getServiceState().getState() will not change immediately after this call. - * registerForServiceStateChanged() to find out when the + * registerForServiceStateChanged() to find out when the * request is complete. * - * @param power true means "on", false means "off". + * @param power true means "on", false means "off". */ void setRadioPower(boolean power); - /** + /** * Get voice message waiting indicator status. No change notification * available on this interface. Use PhoneStateNotifier or similar instead. * @@ -674,8 +761,8 @@ public interface Phone { void setLine1Number(String alphaTag, String number, Message onComplete); /** - * Get the voice mail access phone number. Typically dialed when the - * user holds the "1" key in the phone app. May return null if not + * Get the voice mail access phone number. Typically dialed when the + * user holds the "1" key in the phone app. May return null if not * available or the SIM is not ready.<p> */ String getVoiceMailNumber(); @@ -684,8 +771,8 @@ public interface Phone { * Returns the alpha tag associated with the voice mail number. * If there is no alpha tag associated or the record is not yet available, * returns a default localized string. <p> - * - * Please use this value instead of some other localized string when + * + * Please use this value instead of some other localized string when * showing a name for this number in the UI. For example, call log * entries should show this alpha tag. <p> * @@ -708,29 +795,29 @@ public interface Phone { /** * getCallForwardingOptions - * gets a call forwarding option. The return value of - * ((AsyncResult)onComplete.obj) is an array of CallForwardInfo. - * - * @param commandInterfaceCFReason is one of the valid call forwarding - * CF_REASONS, as defined in - * <code>com.android.internal.telephony.gsm.CommandsInterface</code> + * gets a call forwarding option. The return value of + * ((AsyncResult)onComplete.obj) is an array of CallForwardInfo. + * + * @param commandInterfaceCFReason is one of the valid call forwarding + * CF_REASONS, as defined in + * <code>com.android.internal.telephony.CommandsInterface./code> * @param onComplete a callback message when the action is completed. - * @see com.android.internal.telephony.gsm.CallForwardInfo for details. + * @see com.android.internal.telephony.CallForwardInfo for details. */ void getCallForwardingOption(int commandInterfaceCFReason, Message onComplete); - + /** * setCallForwardingOptions * sets a call forwarding option. - * - * @param commandInterfaceCFReason is one of the valid call forwarding - * CF_REASONS, as defined in - * <code>com.android.internal.telephony.gsm.CommandsInterface</code> - * @param commandInterfaceCFAction is one of the valid call forwarding - * CF_ACTIONS, as defined in - * <code>com.android.internal.telephony.gsm.CommandsInterface</code> - * @param dialingNumber is the target phone number to forward calls to + * + * @param commandInterfaceCFReason is one of the valid call forwarding + * CF_REASONS, as defined in + * <code>com.android.internal.telephony.CommandsInterface./code> + * @param commandInterfaceCFAction is one of the valid call forwarding + * CF_ACTIONS, as defined in + * <code>com.android.internal.telephony.CommandsInterface./code> + * @param dialingNumber is the target phone number to forward calls to * @param timerSeconds is used by CFNRy to indicate the timeout before * forwarding is attempted. * @param onComplete a callback message when the action is completed. @@ -740,83 +827,83 @@ public interface Phone { String dialingNumber, int timerSeconds, Message onComplete); - + /** * getOutgoingCallerIdDisplay - * gets outgoing caller id display. The return value of + * gets outgoing caller id display. The return value of * ((AsyncResult)onComplete.obj) is an array of int, with a length of 2. - * + * * @param onComplete a callback message when the action is completed. - * @see com.android.internal.telephony.gsm.CommandsInterface.getCLIR for details. + * @see com.android.internal.telephony.CommandsInterface.getCLIR for details. */ void getOutgoingCallerIdDisplay(Message onComplete); - + /** * setOutgoingCallerIdDisplay - * sets a call forwarding option. - * - * @param commandInterfaceCLIRMode is one of the valid call CLIR - * modes, as defined in - * <code>com.android.internal.telephony.gsm.CommandsInterface</code> + * sets a call forwarding option. + * + * @param commandInterfaceCLIRMode is one of the valid call CLIR + * modes, as defined in + * <code>com.android.internal.telephony.CommandsInterface./code> * @param onComplete a callback message when the action is completed. */ void setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode, Message onComplete); - + /** * getCallWaiting - * gets call waiting activation state. The return value of + * gets call waiting activation state. The return value of * ((AsyncResult)onComplete.obj) is an array of int, with a length of 1. - * + * * @param onComplete a callback message when the action is completed. - * @see com.android.internal.telephony.gsm.CommandsInterface.queryCallWaiting for details. + * @see com.android.internal.telephony.CommandsInterface.queryCallWaiting for details. */ void getCallWaiting(Message onComplete); - + /** * setCallWaiting - * sets a call forwarding option. - * - * @param enable is a boolean representing the state that you are + * sets a call forwarding option. + * + * @param enable is a boolean representing the state that you are * requesting, true for enabled, false for disabled. * @param onComplete a callback message when the action is completed. */ void setCallWaiting(boolean enable, Message onComplete); - + /** * Scan available networks. This method is asynchronous; . * On completion, <code>response.obj</code> is set to an AsyncResult with * one of the following members:.<p> *<ul> - * <li><code>response.obj.result</code> will be a <code>List</code> of - * <code>com.android.internal.telephony.gsm.NetworkInfo</code> objects, or</li> - * <li><code>response.obj.exception</code> will be set with an exception + * <li><code>response.obj.result</code> will be a <code>List</code> of + * <code>com.android.internal.telephony.gsm.NetworkInfo</code> objects, or</li> + * <li><code>response.obj.exception</code> will be set with an exception * on failure.</li> * </ul> */ - void getAvailableNetworks(Message response); + void getAvailableNetworks(Message response); /** * Switches network selection mode to "automatic", re-scanning and * re-selecting a network if appropriate. - * - * @param response The message to dispatch when the network selection + * + * @param response The message to dispatch when the network selection * is complete. - * - * @see #selectNetworkManually(com.android.internal.telephony.gsm.NetworkInfo, + * + * @see #selectNetworkManually(com.android.internal.telephony.gsm.NetworkInfo, * android.os.Message ) */ void setNetworkSelectionModeAutomatic(Message response); /** - * Manually selects a network. <code>response</code> is + * Manually selects a network. <code>response</code> is * dispatched when this is complete. <code>response.obj</code> will be * an AsyncResult, and <code>response.obj.exception</code> will be non-null * on failure. - * + * * @see #setNetworkSelectionModeAutomatic(Message) */ - void selectNetworkManually(NetworkInfo network, + void selectNetworkManually(NetworkInfo network, Message response); /** @@ -843,7 +930,7 @@ public interface Phone { * of available cell IDs. Cell IDs are in hexadecimal format. * * @param response callback message that is dispatched when the query - * completes. + * completes. */ void getNeighboringCids(Message response); @@ -856,28 +943,28 @@ public interface Phone { * <code>AsyncResult</code>. <code>Message.obj.result</code> will be * a Connection object.<p> * - * Message.arg1 will be the post dial character being processed, + * Message.arg1 will be the post dial character being processed, * or 0 ('\0') if end of string.<p> * - * If Connection.getPostDialState() == WAIT, - * the application must call - * {@link com.android.internal.telephony.Connection#proceedAfterWaitChar() - * Connection.proceedAfterWaitChar()} or - * {@link com.android.internal.telephony.Connection#cancelPostDial() + * If Connection.getPostDialState() == WAIT, + * the application must call + * {@link com.android.internal.telephony.Connection#proceedAfterWaitChar() + * Connection.proceedAfterWaitChar()} or + * {@link com.android.internal.telephony.Connection#cancelPostDial() * Connection.cancelPostDial()} - * for the telephony system to continue playing the post-dial + * for the telephony system to continue playing the post-dial * DTMF sequence.<p> * - * If Connection.getPostDialState() == WILD, - * the application must call + * If Connection.getPostDialState() == WILD, + * the application must call * {@link com.android.internal.telephony.Connection#proceedAfterWildChar * Connection.proceedAfterWildChar()} - * or - * {@link com.android.internal.telephony.Connection#cancelPostDial() + * or + * {@link com.android.internal.telephony.Connection#cancelPostDial() * Connection.cancelPostDial()} - * for the telephony system to continue playing the + * for the telephony system to continue playing the * post-dial DTMF sequence.<p> - * + * * Only one post dial character handler may be set. <p> * Calling this method with "h" equal to null unsets this handler.<p> */ @@ -885,19 +972,19 @@ public interface Phone { /** - * Mutes or unmutes the microphone for the active call. The microphone - * is automatically unmuted if a call is answered, dialed, or resumed + * Mutes or unmutes the microphone for the active call. The microphone + * is automatically unmuted if a call is answered, dialed, or resumed * from a holding state. - * - * @param muted true to mute the microphone, + * + * @param muted true to mute the microphone, * false to activate the microphone. */ void setMute(boolean muted); /** - * Gets current mute status. Use - * {@link #registerForPhoneStateChanged(android.os.Handler, int, + * Gets current mute status. Use + * {@link #registerForPhoneStateChanged(android.os.Handler, int, * java.lang.Object) registerForPhoneStateChanged()} * as a change notifcation, although presently phone state changed is not * fired when setMute() is called. @@ -908,12 +995,12 @@ public interface Phone { /** * Invokes RIL_REQUEST_OEM_HOOK_RAW on RIL implementation. - * + * * @param data The data for the request. - * @param response <strong>On success</strong>, + * @param response <strong>On success</strong>, * (byte[])(((AsyncResult)response.obj).result) - * <strong>On failure</strong>, - * (((AsyncResult)response.obj).result) == null and + * <strong>On failure</strong>, + * (((AsyncResult)response.obj).result) == null and * (((AsyncResult)response.obj).exception) being an instance of * com.android.internal.telephony.gsm.CommandException * @@ -923,13 +1010,13 @@ public interface Phone { /** * Invokes RIL_REQUEST_OEM_HOOK_Strings on RIL implementation. - * + * * @param strings The strings to make available as the request data. - * @param response <strong>On success</strong>, "response" bytes is + * @param response <strong>On success</strong>, "response" bytes is * made available as: * (String[])(((AsyncResult)response.obj).result). - * <strong>On failure</strong>, - * (((AsyncResult)response.obj).result) == null and + * <strong>On failure</strong>, + * (((AsyncResult)response.obj).result) == null and * (((AsyncResult)response.obj).exception) being an instance of * com.android.internal.telephony.gsm.CommandException * @@ -940,6 +1027,7 @@ public interface Phone { /** * Get the current active PDP context list * + * @deprecated * @param response <strong>On success</strong>, "response" bytes is * made available as: * (String[])(((AsyncResult)response.obj).result). @@ -951,13 +1039,34 @@ public interface Phone { void getPdpContextList(Message response); /** + * Get the current active Data Call list, substitutes getPdpContextList + * + * @param response <strong>On success</strong>, "response" bytes is + * made available as: + * (String[])(((AsyncResult)response.obj).result). + * <strong>On failure</strong>, + * (((AsyncResult)response.obj).result) == null and + * (((AsyncResult)response.obj).exception) being an instance of + * com.android.internal.telephony.gsm.CommandException + */ + void getDataCallList(Message response); + + /** * Get current mutiple PDP link status - * + * + * @deprecated * @return list of pdp link connections */ List<PdpConnection> getCurrentPdpList (); /** + * Get current mutiple data connection status + * + * @return list of data connections + */ + List<DataConnection> getCurrentDataConnectionList (); + + /** * Udpate LAC and CID in service state for currnet GSM netowrk registration * * If get different LAC and/or CID, notifyServiceState will be sent @@ -981,11 +1090,11 @@ public interface Phone { void disableLocationUpdates(); /** - * For unit tests; don't send notifications to "Phone" + * For unit tests; don't send notifications to "Phone" * mailbox registrants if true. */ void setUnitTestMode(boolean f); - + /** * @return true If unit test mode is enabled */ @@ -1019,8 +1128,29 @@ public interface Phone { void setDataRoamingEnabled(boolean enable); /** + * Query the CDMA roaming preference setting + * + * @param response is callback message to report one of CDMA_RM_* + */ + void queryCdmaRoamingPreference(Message response); + + /** + * Requests to set the CDMA roaming preference + * @param cdmaRoamingType one of CDMA_RM_* + * @param response is callback message + */ + void setCdmaRoamingPreference(int cdmaRoamingType, Message response); + + /** + * Requests to set the CDMA subscription mode + * @param cdmaSubscriptionType one of CDMA_SUBSCRIPTION_* + * @param response is callback message + */ + void setCdmaSubscription(int cdmaSubscriptionType, Message response); + + /** * If this is a simulated phone interface, returns a SimulatedRadioControl. - * @ return A SimulatedRadioControl if this is a simulated interface; + * @ return A SimulatedRadioControl if this is a simulated interface; * otherwise, null. */ SimulatedRadioControl getSimulatedRadioControl(); @@ -1109,7 +1239,7 @@ public interface Phone { public String[] getDnsServers(String apnType); /** - * Retrieves the unique device ID, e.g., IMEI for GSM phones. + * Retrieves the unique device ID, e.g., IMEI for GSM phones and MEID for CDMA phones. */ String getDeviceId(); @@ -1125,7 +1255,81 @@ public interface Phone { String getSubscriberId(); /** - * Retrieves the serial number of the SIM, if applicable. + * Retrieves the serial number of the ICC, if applicable. + */ + String getIccSerialNumber(); + + //***** CDMA support methods + + + /** + * Retrieves the ESN for CDMA phones. */ - String getSimSerialNumber(); + String getEsn(); + + /** + * Retrieves MEID for CDMA phones. + */ + String getMeid(); + + /** + * Retrieves the PhoneSubInfo of the Phone + */ + public PhoneSubInfo getPhoneSubInfo(); + + /** + * Retrieves the IccSmsInterfaceManager of the Phone + */ + public IccSmsInterfaceManager getIccSmsInterfaceManager(); + + /** + * Retrieves the IccPhoneBookInterfaceManager of the Phone + */ + public IccPhoneBookInterfaceManager getIccPhoneBookInterfaceManager(); + + /** + * setTTYModeEnabled + * sets a TTY mode option. + * + * @param enable is a boolean representing the state that you are + * requesting, true for enabled, false for disabled. + * @param onComplete a callback message when the action is completed + */ + void setTTYModeEnabled(boolean enable, Message onComplete); + + /** + * queryTTYModeEnabled + * query the status of the TTY mode + * + * @param onComplete a callback message when the action is completed. + */ + void queryTTYModeEnabled(Message onComplete); + + /** + * Activate or deactivate cell broadcast SMS. + * + * @param activate + * 0 = activate, 1 = deactivate + * @param response + * Callback message is empty on completion + */ + void activateCellBroadcastSms(int activate, Message response); + + /** + * Query the current configuration of cdma cell broadcast SMS. + * + * @param response + * Callback message is empty on completion + */ + void getCellBroadcastSmsConfig(Message response); + + /** + * Configure cell broadcast SMS. + * + * @param response + * Callback message is empty on completion + */ + public void setCellBroadcastSmsConfig(int[] configValuesArray, Message response); + + public void notifyDataActivity(); } diff --git a/telephony/java/com/android/internal/telephony/PhoneBase.java b/telephony/java/com/android/internal/telephony/PhoneBase.java index 4fb5f61..259de62 100644 --- a/telephony/java/com/android/internal/telephony/PhoneBase.java +++ b/telephony/java/com/android/internal/telephony/PhoneBase.java @@ -20,23 +20,30 @@ import android.app.ActivityManagerNative; import android.app.IActivityManager; import android.content.Context; import android.content.res.Configuration; +import android.content.SharedPreferences; import android.os.AsyncResult; import android.os.Handler; import android.os.Looper; +import android.os.Message; import android.os.RegistrantList; import android.os.SystemProperties; +import android.preference.PreferenceManager; import android.telephony.ServiceState; +import android.text.TextUtils; import android.util.Log; + import com.android.internal.R; +import com.android.internal.telephony.gsm.PdpConnection; import com.android.internal.telephony.test.SimulatedRadioControl; import java.util.List; import java.util.Locale; + /** - * (<em>Not for SDK use</em>) + * (<em>Not for SDK use</em>) * A base implementation for the com.android.internal.telephony.Phone interface. - * + * * Note that implementations of Phone.java are expected to be used * from a single application thread. This should be the same thread that * originally called PhoneFactory to obtain the interface. @@ -46,42 +53,101 @@ import java.util.Locale; */ public abstract class PhoneBase implements Phone { - private static final String LOG_TAG = "GSM"; + private static final String LOG_TAG = "PHONE"; + private static final boolean LOCAL_DEBUG = true; + + // Key used to read and write the saved network selection value + public static final String NETWORK_SELECTION_KEY = "network_selection_key"; + + // Key used to read/write "disable data connection on boot" pref (used for testing) + public static final String DATA_DISABLED_ON_BOOT_KEY = "disabled_on_boot_key"; + + //***** Event Constants + protected static final int EVENT_RADIO_AVAILABLE = 1; + /** Supplementary Service Notification received. */ + protected static final int EVENT_SSN = 2; + protected static final int EVENT_SIM_RECORDS_LOADED = 3; + protected static final int EVENT_MMI_DONE = 4; + protected static final int EVENT_RADIO_ON = 5; + protected static final int EVENT_GET_BASEBAND_VERSION_DONE = 6; + protected static final int EVENT_USSD = 7; + protected static final int EVENT_RADIO_OFF_OR_NOT_AVAILABLE = 8; + protected static final int EVENT_GET_IMEI_DONE = 9; + protected static final int EVENT_GET_IMEISV_DONE = 10; + protected static final int EVENT_GET_SIM_STATUS_DONE = 11; + protected static final int EVENT_SET_CALL_FORWARD_DONE = 12; + protected static final int EVENT_GET_CALL_FORWARD_DONE = 13; + protected static final int EVENT_CALL_RING = 14; + // Used to intercept the carrier selection calls so that + // we can save the values. + protected static final int EVENT_SET_NETWORK_MANUAL_COMPLETE = 15; + protected static final int EVENT_SET_NETWORK_AUTOMATIC_COMPLETE = 16; + protected static final int EVENT_SET_CLIR_COMPLETE = 17; + protected static final int EVENT_REGISTERED_TO_NETWORK = 18; + protected static final int EVENT_SET_VM_NUMBER_DONE = 19; + // Events for CDMA support + protected static final int EVENT_GET_DEVICE_IDENTITY_DONE = 20; + protected static final int EVENT_RUIM_RECORDS_LOADED = 21; + protected static final int EVENT_NV_READY = 22; + protected static final int EVENT_SET_ENHANCED_VP = 23; + + // Key used to read/write current CLIR setting + public static final String CLIR_KEY = "clir_key"; + + // Key used to read/write "disable DNS server check" pref (used for testing) + public static final String DNS_SERVER_CHECK_DISABLED_KEY = "dns_server_check_disabled_key"; + + //***** Instance Variables + public CommandsInterface mCM; + protected IccFileHandler mIccFileHandler; + boolean mDnsCheckDisabled = false; + + /** + * Set a system property, unless we're in unit test mode + */ + public void + setSystemProperty(String property, String value) { + if(getUnitTestMode()) { + return; + } + SystemProperties.set(property, value); + } - protected final RegistrantList mPhoneStateRegistrants + + protected final RegistrantList mPhoneStateRegistrants = new RegistrantList(); - protected final RegistrantList mNewRingingConnectionRegistrants + protected final RegistrantList mNewRingingConnectionRegistrants = new RegistrantList(); - protected final RegistrantList mIncomingRingRegistrants + protected final RegistrantList mIncomingRingRegistrants = new RegistrantList(); - - protected final RegistrantList mDisconnectRegistrants + + protected final RegistrantList mDisconnectRegistrants = new RegistrantList(); - protected final RegistrantList mServiceStateRegistrants + protected final RegistrantList mServiceStateRegistrants = new RegistrantList(); - - protected final RegistrantList mMmiCompleteRegistrants + + protected final RegistrantList mMmiCompleteRegistrants = new RegistrantList(); - protected final RegistrantList mMmiRegistrants + protected final RegistrantList mMmiRegistrants = new RegistrantList(); - protected final RegistrantList mUnknownConnectionRegistrants + protected final RegistrantList mUnknownConnectionRegistrants = new RegistrantList(); - - protected final RegistrantList mSuppServiceFailedRegistrants + + protected final RegistrantList mSuppServiceFailedRegistrants = new RegistrantList(); - + protected Looper mLooper; /* to insure registrants are in correct thread*/ protected Context mContext; - /** - * PhoneNotifier is an abstraction for all system-wide - * state change notification. DefaultPhoneNotifier is + /** + * PhoneNotifier is an abstraction for all system-wide + * state change notification. DefaultPhoneNotifier is * used here unless running we're inside a unit test. */ protected PhoneNotifier mNotifier; @@ -94,7 +160,7 @@ public abstract class PhoneBase implements Phone { * Constructs a PhoneBase in normal (non-unit test) mode. * * @param context Context object from hosting application - * @param notifier An instance of DefaultPhoneNotifier, + * @param notifier An instance of DefaultPhoneNotifier, * unless unit testing. */ protected PhoneBase(PhoneNotifier notifier, Context context) { @@ -105,13 +171,13 @@ public abstract class PhoneBase implements Phone { * Constructs a PhoneBase in normal (non-unit test) mode. * * @param context Context object from hosting application - * @param notifier An instance of DefaultPhoneNotifier, + * @param notifier An instance of DefaultPhoneNotifier, * unless unit testing. - * @param unitTestMode when true, prevents notifications + * @param unitTestMode when true, prevents notifications * of state change events */ - protected PhoneBase(PhoneNotifier notifier, Context context, - boolean unitTestMode) { + protected PhoneBase(PhoneNotifier notifier, Context context, + boolean unitTestMode) { this.mNotifier = notifier; this.mContext = context; mLooper = Looper.myLooper(); @@ -119,6 +185,9 @@ public abstract class PhoneBase implements Phone { setLocaleByCarrier(); setUnitTestMode(unitTestMode); + + SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context); + mDnsCheckDisabled = sp.getBoolean(DNS_SERVER_CHECK_DISABLED_KEY, false); } // Inherited documentation suffices. @@ -126,6 +195,26 @@ public abstract class PhoneBase implements Phone { return mContext; } + /** + * Disables the DNS check (i.e., allows "0.0.0.0"). + * Useful for lab testing environment. + * @param b true disables the check, false enables. + */ + public void disableDnsCheck(boolean b) { + mDnsCheckDisabled = b; + SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); + SharedPreferences.Editor editor = sp.edit(); + editor.putBoolean(DNS_SERVER_CHECK_DISABLED_KEY, b); + editor.commit(); + } + + /** + * Returns true if the DNS check is currently disabled. + */ + public boolean isDnsCheckDisabled() { + return mDnsCheckDisabled; + } + // Inherited documentation suffices. public void registerForPhoneStateChanged(Handler h, int what, Object obj) { checkCorrectThread(h); @@ -137,29 +226,29 @@ public abstract class PhoneBase implements Phone { public void unregisterForPhoneStateChanged(Handler h) { mPhoneStateRegistrants.remove(h); } - + /** * Notify registrants of a PhoneStateChanged. - * Subclasses of Phone probably want to replace this with a + * Subclasses of Phone probably want to replace this with a * version scoped to their packages */ protected void notifyCallStateChangedP() { AsyncResult ar = new AsyncResult(null, this, null); mPhoneStateRegistrants.notifyRegistrants(ar); } - + // Inherited documentation suffices. public void registerForUnknownConnection(Handler h, int what, Object obj) { checkCorrectThread(h); - + mUnknownConnectionRegistrants.addUnique(h, what, obj); } - + // Inherited documentation suffices. public void unregisterForUnknownConnection(Handler h) { mUnknownConnectionRegistrants.remove(h); } - + // Inherited documentation suffices. public void registerForNewRingingConnection( Handler h, int what, Object obj) { @@ -173,12 +262,33 @@ public abstract class PhoneBase implements Phone { mNewRingingConnectionRegistrants.remove(h); } + // Inherited documentation suffices. + public void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj){ + mCM.registerForInCallVoicePrivacyOn(h,what,obj); + } + + // Inherited documentation suffices. + public void unregisterForInCallVoicePrivacyOn(Handler h){ + mCM.unregisterForInCallVoicePrivacyOn(h); + } + + // Inherited documentation suffices. + public void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj){ + mCM.registerForInCallVoicePrivacyOff(h,what,obj); + } + + // Inherited documentation suffices. + public void unregisterForInCallVoicePrivacyOff(Handler h){ + mCM.unregisterForInCallVoicePrivacyOff(h); + } + + /** * Notifiy registrants of a new ringing Connection. - * Subclasses of Phone probably want to replace this with a + * Subclasses of Phone probably want to replace this with a * version scoped to their packages */ - protected void notifyNewRingingConnectionP(Connection cn) { + protected void notifyNewRingingConnectionP(Connection cn) { AsyncResult ar = new AsyncResult(null, cn, null); mNewRingingConnectionRegistrants.notifyRegistrants(ar); } @@ -187,15 +297,15 @@ public abstract class PhoneBase implements Phone { public void registerForIncomingRing( Handler h, int what, Object obj) { checkCorrectThread(h); - + mIncomingRingRegistrants.addUnique(h, what, obj); } - + // Inherited documentation suffices. public void unregisterForIncomingRing(Handler h) { mIncomingRingRegistrants.remove(h); } - + // Inherited documentation suffices. public void registerForDisconnect(Handler h, int what, Object obj) { checkCorrectThread(h); @@ -211,15 +321,15 @@ public abstract class PhoneBase implements Phone { // Inherited documentation suffices. public void registerForSuppServiceFailed(Handler h, int what, Object obj) { checkCorrectThread(h); - + mSuppServiceFailedRegistrants.addUnique(h, what, obj); } - + // Inherited documentation suffices. public void unregisterForSuppServiceFailed(Handler h) { mSuppServiceFailedRegistrants.remove(h); } - + // Inherited documentation suffices. public void registerForMmiInitiate(Handler h, int what, Object obj) { checkCorrectThread(h); @@ -231,7 +341,7 @@ public abstract class PhoneBase implements Phone { public void unregisterForMmiInitiate(Handler h) { mMmiRegistrants.remove(h); } - + // Inherited documentation suffices. public void registerForMmiComplete(Handler h, int what, Object obj) { checkCorrectThread(h); @@ -247,10 +357,31 @@ public abstract class PhoneBase implements Phone { } /** - * Subclasses should override this. See documentation in superclass. + * Method to retrieve the saved operator id from the Shared Preferences */ - public abstract List getPendingMmiCodes(); - + private String getSavedNetworkSelection() { + // open the shared preferences and search with our key. + SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); + return sp.getString(NETWORK_SELECTION_KEY, ""); + } + + /** + * Method to restore the previously saved operator id, or reset to + * automatic selection, all depending upon the value in the shared + * preferences. + */ + public void restoreSavedNetworkSelection(Message response) { + // retrieve the operator id + String networkSelection = getSavedNetworkSelection(); + + // set to auto if the id is empty, otherwise select the network. + if (TextUtils.isEmpty(networkSelection)) { + mCM.setNetworkSelectionModeAutomatic(response); + } else { + mCM.setNetworkSelectionModeManual(networkSelection, response); + } + } + // Inherited documentation suffices. public void setUnitTestMode(boolean f) { mUnitTestMode = f; @@ -260,11 +391,11 @@ public abstract class PhoneBase implements Phone { public boolean getUnitTestMode() { return mUnitTestMode; } - + /** * To be invoked when a voice call Connection disconnects. * - * Subclasses of Phone probably want to replace this with a + * Subclasses of Phone probably want to replace this with a * version scoped to their packages */ protected void notifyDisconnectP(Connection cn) { @@ -286,7 +417,7 @@ public abstract class PhoneBase implements Phone { } /** - * Subclasses of Phone probably want to replace this with a + * Subclasses of Phone probably want to replace this with a * version scoped to their packages */ protected void notifyServiceStateChangedP(ServiceState ss) { @@ -312,7 +443,7 @@ public abstract class PhoneBase implements Phone { private void checkCorrectThread(Handler h) { if (h.getLooper() != mLooper) { throw new RuntimeException( - "com.android.internal.telephony.Phone must be used from within one thread"); + "com.android.internal.telephony.Phone must be used from within one thread"); } } @@ -401,4 +532,107 @@ public abstract class PhoneBase implements Phone { } } } + + /* + * Retrieves the Handler of the Phone instance + */ + public abstract Handler getHandler(); + + /** + * Retrieves the IccFileHandler of the Phone instance + */ + public abstract IccFileHandler getIccFileHandler(); + + + /** + * Query the status of the CDMA roaming preference + */ + public void queryCdmaRoamingPreference(Message response) { + mCM.queryCdmaRoamingPreference(response); + } + + /** + * Set the status of the CDMA roaming preference + */ + public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) { + mCM.setCdmaRoamingPreference(cdmaRoamingType, response); + } + + /** + * Set the status of the CDMA subscription mode + */ + public void setCdmaSubscription(int cdmaSubscriptionType, Message response) { + mCM.setCdmaSubscription(cdmaSubscriptionType, response); + } + + /** + * Set the preferred Network Type: Global, CDMA only or GSM/UMTS only + */ + public void setPreferredNetworkType(int networkType, Message response) { + mCM.setPreferredNetworkType(networkType, response); + } + + /** + * Set the status of the preferred Network Type: Global, CDMA only or GSM/UMTS only + */ + public void getPreferredNetworkType(Message response) { + mCM.getPreferredNetworkType(response); + } + + public void setTTYModeEnabled(boolean enable, Message onComplete) { + // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. + Log.e(LOG_TAG, "Error! This function should never be executed, inactive CDMAPhone."); + } + + public void queryTTYModeEnabled(Message onComplete) { + // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. + Log.e(LOG_TAG, "Error! This function should never be executed, inactive CDMAPhone."); + } + + /** + * This should only be called in GSM mode. + * Only here for some backward compatibility + * issues concerning the GSMPhone class. + * @deprecated + */ + public List<PdpConnection> getCurrentPdpList() { + return null; + } + + public void enableEnhancedVoicePrivacy(boolean enable, Message onComplete) { + // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. + Log.e(LOG_TAG, "Error! This function should never be executed, inactive CDMAPhone."); + } + + public void getEnhancedVoicePrivacy(Message onComplete) { + // This function should be overridden by the class CDMAPhone. Not implemented in GSMPhone. + Log.e(LOG_TAG, "Error! This function should never be executed, inactive CDMAPhone."); + } + + public void setBandMode(int bandMode, Message response) { + mCM.setBandMode(bandMode, response); + } + + public void queryAvailableBandMode(Message response) { + mCM.queryAvailableBandMode(response); + } + + public void invokeOemRilRequestRaw(byte[] data, Message response) { + mCM.invokeOemRilRequestRaw(data, response); + } + + public void invokeOemRilRequestStrings(String[] strings, Message response) { + mCM.invokeOemRilRequestStrings(strings, response); + } + + public void notifyDataActivity() { + mNotifier.notifyDataActivity(this); + } + + public void notifyDataConnection(String reason) { + mNotifier.notifyDataConnection(this, reason); + } + + public abstract String getPhoneName(); + } diff --git a/telephony/java/com/android/internal/telephony/PhoneFactory.java b/telephony/java/com/android/internal/telephony/PhoneFactory.java index 0ca5f45..3db0499 100644 --- a/telephony/java/com/android/internal/telephony/PhoneFactory.java +++ b/telephony/java/com/android/internal/telephony/PhoneFactory.java @@ -16,80 +16,55 @@ package com.android.internal.telephony; -import java.util.ArrayList; -import java.util.List; -import java.io.IOException; -import java.net.InetSocketAddress; - -import java.util.Collections; - -import android.util.Log; -import com.android.internal.telephony.gsm.GSMPhone; -import com.android.internal.telephony.gsm.RIL; -import com.android.internal.telephony.test.ModelInterpreter; -import com.android.internal.telephony.test.SimulatedCommands; -import android.os.Looper; -import android.os.SystemProperties; import android.content.Context; -import android.content.Intent; import android.net.LocalServerSocket; -import android.app.ActivityManagerNative; +import android.os.Looper; +import android.provider.Settings; +import android.util.Log; + +import com.android.internal.telephony.cdma.CDMAPhone; +import com.android.internal.telephony.gsm.GSMPhone; /** * {@hide} */ -public class PhoneFactory -{ - static final String LOG_TAG="GSM"; - +public class PhoneFactory { + static final String LOG_TAG = "PHONE"; static final int SOCKET_OPEN_RETRY_MILLIS = 2 * 1000; static final int SOCKET_OPEN_MAX_RETRY = 3; - //***** Class Variables + //***** Class Variables - static private ArrayList<Phone> sPhones = new ArrayList<Phone>(); + static private Phone sProxyPhone = null; + static private CommandsInterface sCommandsInterface = null; static private boolean sMadeDefaults = false; static private PhoneNotifier sPhoneNotifier; static private Looper sLooper; + static private Context sContext; - static private Object testMailbox; - - //***** Class Methods + static final int preferredNetworkMode = RILConstants.PREFERRED_NETWORK_MODE; - private static void - useNewRIL(Context context) - { - ModelInterpreter mi = null; - GSMPhone phone; + static final int preferredCdmaSubscription = RILConstants.PREFERRED_CDMA_SUBSCRIPTION; - try { - if (false) { - mi = new ModelInterpreter(new InetSocketAddress("127.0.0.1", 6502)); - } - - phone = new GSMPhone(context, new RIL(context), sPhoneNotifier); + //***** Class Methods - registerPhone (phone); - } catch (IOException ex) { - Log.e(LOG_TAG, "Error creating ModelInterpreter", ex); - } + public static void makeDefaultPhones(Context context) { + makeDefaultPhone(context); } - /** * FIXME replace this with some other way of making these * instances */ - public static void - makeDefaultPhones(Context context) - { - synchronized(Phone.class) { - if (!sMadeDefaults) { + public static void makeDefaultPhone(Context context) { + synchronized(Phone.class) { + if (!sMadeDefaults) { sLooper = Looper.myLooper(); + sContext = context; if (sLooper == null) { throw new RuntimeException( - "PhoneFactory.makeDefaultPhones must be called from Looper thread"); + "PhoneFactory.makeDefaultPhone must be called from Looper thread"); } int retryCount = 0; @@ -109,7 +84,7 @@ public class PhoneFactory break; } else if (retryCount > SOCKET_OPEN_MAX_RETRY) { throw new RuntimeException("PhoneFactory probably already running"); - }else { + } else { try { Thread.sleep(SOCKET_OPEN_RETRY_MILLIS); } catch (InterruptedException er) { @@ -119,44 +94,71 @@ public class PhoneFactory sPhoneNotifier = new DefaultPhoneNotifier(); - if ((SystemProperties.get("ro.radio.noril","")).equals("")) { - useNewRIL(context); - } else { - GSMPhone phone; - phone = new GSMPhone(context, new SimulatedCommands(), sPhoneNotifier); - registerPhone (phone); + //Get preferredNetworkMode from Settings.System + int networkMode = Settings.Secure.getInt(context.getContentResolver(), + Settings.Secure.PREFERRED_NETWORK_MODE, preferredNetworkMode); + Log.i(LOG_TAG, "Network Mode set to " + Integer.toString(networkMode)); + + //Get preferredNetworkMode from Settings.System + int cdmaSubscription = Settings.Secure.getInt(context.getContentResolver(), + Settings.Secure.PREFERRED_CDMA_SUBSCRIPTION, preferredCdmaSubscription); + Log.i(LOG_TAG, "Cdma Subscription set to " + Integer.toString(cdmaSubscription)); + + //reads the system properties and makes commandsinterface + sCommandsInterface = new RIL(context, networkMode, cdmaSubscription); + + switch(networkMode) { + case RILConstants.NETWORK_MODE_WCDMA_PREF: + case RILConstants.NETWORK_MODE_GSM_ONLY: + case RILConstants.NETWORK_MODE_WCDMA_ONLY: + case RILConstants.NETWORK_MODE_GSM_UMTS: + sProxyPhone = new PhoneProxy(new GSMPhone(context, + sCommandsInterface, sPhoneNotifier)); + Log.i(LOG_TAG, "Creating GSMPhone"); + break; + case RILConstants.NETWORK_MODE_CDMA: + case RILConstants.NETWORK_MODE_CDMA_NO_EVDO: + case RILConstants.NETWORK_MODE_EVDO_NO_CDMA: + sProxyPhone = new PhoneProxy(new CDMAPhone(context, + sCommandsInterface, sPhoneNotifier)); + Log.i(LOG_TAG, "Creating CDMAPhone"); + break; + case RILConstants.NETWORK_MODE_GLOBAL: + default: + sProxyPhone = new PhoneProxy(new CDMAPhone(context, + sCommandsInterface, sPhoneNotifier)); + Log.i(LOG_TAG, "Creating CDMAPhone"); } - sMadeDefaults = true; } } } - public static Phone getDefaultPhone() - { - if (!sMadeDefaults) { - throw new IllegalStateException("Default phones haven't been made yet!"); - } - + public static Phone getDefaultPhone() { if (sLooper != Looper.myLooper()) { throw new RuntimeException( "PhoneFactory.getDefaultPhone must be called from Looper thread"); } - synchronized (sPhones) { - return sPhones.isEmpty() ? null : sPhones.get(0); + if (!sMadeDefaults) { + throw new IllegalStateException("Default phones haven't been made yet!"); } + return sProxyPhone; } - - public static void registerPhone(Phone p) - { - if (sLooper != Looper.myLooper()) { - throw new RuntimeException( - "PhoneFactory.getDefaultPhone must be called from Looper thread"); + + public static Phone getCdmaPhone() { + synchronized(PhoneProxy.lockForRadioTechnologyChange) { + Phone phone = new CDMAPhone(sContext, sCommandsInterface, sPhoneNotifier); + return phone; } - synchronized (sPhones) { - sPhones.add(p); + } + + public static Phone getGsmPhone() { + synchronized(PhoneProxy.lockForRadioTechnologyChange) { + Phone phone = new GSMPhone(sContext, sCommandsInterface, sPhoneNotifier); + return phone; } } } + diff --git a/telephony/java/com/android/internal/telephony/PhoneProxy.java b/telephony/java/com/android/internal/telephony/PhoneProxy.java new file mode 100644 index 0000000..dd36f0b --- /dev/null +++ b/telephony/java/com/android/internal/telephony/PhoneProxy.java @@ -0,0 +1,675 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + + +import android.app.ActivityManagerNative; +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; +import android.os.Handler; +import android.os.Message; +import android.preference.PreferenceManager; +import android.telephony.CellLocation; +import android.telephony.ServiceState; +import android.util.Log; + +import com.android.internal.telephony.cdma.CDMAPhone; +import com.android.internal.telephony.gsm.GSMPhone; +import com.android.internal.telephony.gsm.NetworkInfo; +import com.android.internal.telephony.gsm.PdpConnection; +import com.android.internal.telephony.test.SimulatedRadioControl; + +import java.util.List; + +public class PhoneProxy extends Handler implements Phone { + public final static Object lockForRadioTechnologyChange = new Object(); +// private static boolean radioTechnologyChangeGsmToCdma = false; +// private static boolean radioTechnologyChangeCdmaToGsm = false; + + private Phone mActivePhone; + private String mOutgoingPhone; + private CommandsInterface mCommandsInterface; + private IccSmsInterfaceManagerProxy mIccSmsInterfaceManagerProxy; + private IccPhoneBookInterfaceManagerProxy mIccPhoneBookInterfaceManagerProxy; + private PhoneSubInfoProxy mPhoneSubInfoProxy; + + private static final int EVENT_RADIO_TECHNOLOGY_CHANGED = 1; + private static final String LOG_TAG = "PHONE"; + + //***** Class Methods + public PhoneProxy(Phone phone) { + mActivePhone = phone; + mIccSmsInterfaceManagerProxy = new IccSmsInterfaceManagerProxy( + phone.getIccSmsInterfaceManager()); + mIccPhoneBookInterfaceManagerProxy = new IccPhoneBookInterfaceManagerProxy( + phone.getIccPhoneBookInterfaceManager()); + mPhoneSubInfoProxy = new PhoneSubInfoProxy(phone.getPhoneSubInfo()); + mCommandsInterface = ((PhoneBase)mActivePhone).mCM; + mCommandsInterface.registerForRadioTechnologyChanged( + this, EVENT_RADIO_TECHNOLOGY_CHANGED, null); + } + + @Override + public void handleMessage(Message msg) { + switch(msg.what) { + case EVENT_RADIO_TECHNOLOGY_CHANGED: + //switch Phone from CDMA to GSM or vice versa + mOutgoingPhone = ((PhoneBase)mActivePhone).getPhoneName(); + logd("Switching phone from " + mOutgoingPhone + "Phone to " + + (mOutgoingPhone.equals("GSM") ? "CDMAPhone" : "GSMPhone") ); + boolean oldPowerState = false; //old power state to off + if (mCommandsInterface.getRadioState().isOn()) { + oldPowerState = true; + logd("Setting Radio Power to Off"); + mCommandsInterface.setRadioPower(false, null); + } + if(mOutgoingPhone.equals("GSM")) { + logd("Make a new CDMAPhone and destroy the old GSMPhone."); + + ((GSMPhone)mActivePhone).dispose(); + Phone oldPhone = mActivePhone; + + //Give the garbage collector a hint to start the garbage collection asap + // NOTE this has been disabled since radio technology change could happen during + // e.g. a multimedia playing and could slow the system. Tests needs to be done + // to see the effects of the GC call here when system is busy. + //System.gc(); + + mActivePhone = PhoneFactory.getCdmaPhone(); + logd("Resetting Radio"); + mCommandsInterface.setRadioPower(oldPowerState, null); + ((GSMPhone)oldPhone).removeReferences(); + oldPhone = null; + } else { + logd("Make a new GSMPhone and destroy the old CDMAPhone."); + + ((CDMAPhone)mActivePhone).dispose(); + //mActivePhone = null; + Phone oldPhone = mActivePhone; + + // Give the GC a hint to start the garbage collection asap + // NOTE this has been disabled since radio technology change could happen during + // e.g. a multimedia playing and could slow the system. Tests needs to be done + // to see the effects of the GC call here when system is busy. + //System.gc(); + + mActivePhone = PhoneFactory.getGsmPhone(); + logd("Resetting Radio:"); + mCommandsInterface.setRadioPower(oldPowerState, null); + ((CDMAPhone)oldPhone).removeReferences(); + oldPhone = null; + } + + //Set the new interfaces in the proxy's + mIccSmsInterfaceManagerProxy.setmIccSmsInterfaceManager( + mActivePhone.getIccSmsInterfaceManager()); + mIccPhoneBookInterfaceManagerProxy.setmIccPhoneBookInterfaceManager( + mActivePhone.getIccPhoneBookInterfaceManager()); + mPhoneSubInfoProxy.setmPhoneSubInfo(this.mActivePhone.getPhoneSubInfo()); + mCommandsInterface = ((PhoneBase)mActivePhone).mCM; + + //Send an Intent to the PhoneApp that we had a radio technology change + Intent intent = new Intent(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED); + intent.putExtra(Phone.PHONE_NAME_KEY, mActivePhone.getPhoneName()); + ActivityManagerNative.broadcastStickyIntent(intent, null); + + break; + default: + Log.e(LOG_TAG, "Error! This handler was not registered for this message type. Message: " + + msg.what); + break; + } + super.handleMessage(msg); + } + + private void logv(String msg) { + Log.v(LOG_TAG, "[PhoneProxy] " + msg); + } + + private void logd(String msg) { + Log.d(LOG_TAG, "[PhoneProxy] " + msg); + } + + private void logw(String msg) { + Log.w(LOG_TAG, "[PhoneProxy] " + msg); + } + + private void loge(String msg) { + Log.e(LOG_TAG, "[PhoneProxy] " + msg); + } + + + public ServiceState getServiceState() { + return mActivePhone.getServiceState(); + } + + public CellLocation getCellLocation() { + return mActivePhone.getCellLocation(); + } + + public DataState getDataConnectionState() { + return mActivePhone.getDataConnectionState(); + } + + public DataActivityState getDataActivityState() { + return mActivePhone.getDataActivityState(); + } + + public Context getContext() { + return mActivePhone.getContext(); + } + + public void disableDnsCheck(boolean b) { + mActivePhone.disableDnsCheck(b); + } + + public boolean isDnsCheckDisabled() { + return mActivePhone.isDnsCheckDisabled(); + } + + public State getState() { + return mActivePhone.getState(); + } + + public String getPhoneName() { + return mActivePhone.getPhoneName(); + } + + public String[] getActiveApnTypes() { + return mActivePhone.getActiveApnTypes(); + } + + public String getActiveApn() { + return mActivePhone.getActiveApn(); + } + + public int getSignalStrengthASU() { + return mActivePhone.getSignalStrengthASU(); + } + + public void registerForUnknownConnection(Handler h, int what, Object obj) { + mActivePhone.registerForUnknownConnection(h, what, obj); + } + + public void unregisterForUnknownConnection(Handler h) { + mActivePhone.unregisterForUnknownConnection(h); + } + + public void registerForPhoneStateChanged(Handler h, int what, Object obj) { + mActivePhone.registerForPhoneStateChanged(h, what, obj); + } + + public void unregisterForPhoneStateChanged(Handler h) { + mActivePhone.unregisterForPhoneStateChanged(h); + } + + public void registerForNewRingingConnection(Handler h, int what, Object obj) { + mActivePhone.registerForNewRingingConnection(h, what, obj); + } + + public void unregisterForNewRingingConnection(Handler h) { + mActivePhone.unregisterForNewRingingConnection(h); + } + + public void registerForIncomingRing(Handler h, int what, Object obj) { + mActivePhone.registerForIncomingRing(h, what, obj); + } + + public void unregisterForIncomingRing(Handler h) { + mActivePhone.unregisterForIncomingRing(h); + } + + public void registerForDisconnect(Handler h, int what, Object obj) { + mActivePhone.registerForDisconnect(h, what, obj); + } + + public void unregisterForDisconnect(Handler h) { + mActivePhone.unregisterForDisconnect(h); + } + + public void registerForMmiInitiate(Handler h, int what, Object obj) { + mActivePhone.registerForMmiInitiate(h, what, obj); + } + + public void unregisterForMmiInitiate(Handler h) { + mActivePhone.unregisterForMmiInitiate(h); + } + + public void registerForMmiComplete(Handler h, int what, Object obj) { + mActivePhone.registerForMmiComplete(h, what, obj); + } + + public void unregisterForMmiComplete(Handler h) { + mActivePhone.unregisterForMmiComplete(h); + } + + public List<? extends MmiCode> getPendingMmiCodes() { + return mActivePhone.getPendingMmiCodes(); + } + + public void sendUssdResponse(String ussdMessge) { + mActivePhone.sendUssdResponse(ussdMessge); + } + + public void registerForServiceStateChanged(Handler h, int what, Object obj) { + mActivePhone.registerForServiceStateChanged(h, what, obj); + } + + public void unregisterForServiceStateChanged(Handler h) { + mActivePhone.unregisterForServiceStateChanged(h); + } + + public void registerForSuppServiceNotification(Handler h, int what, Object obj) { + mActivePhone.registerForSuppServiceNotification(h, what, obj); + } + + public void unregisterForSuppServiceNotification(Handler h) { + mActivePhone.unregisterForSuppServiceNotification(h); + } + + public void registerForSuppServiceFailed(Handler h, int what, Object obj) { + mActivePhone.registerForSuppServiceFailed(h, what, obj); + } + + public void unregisterForSuppServiceFailed(Handler h) { + mActivePhone.unregisterForSuppServiceFailed(h); + } + + public void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj){ + mActivePhone.registerForInCallVoicePrivacyOn(h,what,obj); + } + + public void unregisterForInCallVoicePrivacyOn(Handler h){ + mActivePhone.unregisterForInCallVoicePrivacyOn(h); + } + + public void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj){ + mActivePhone.registerForInCallVoicePrivacyOff(h,what,obj); + } + + public void unregisterForInCallVoicePrivacyOff(Handler h){ + mActivePhone.unregisterForInCallVoicePrivacyOff(h); + } + + public boolean getIccRecordsLoaded() { + return mActivePhone.getIccRecordsLoaded(); + } + + public IccCard getIccCard() { + return mActivePhone.getIccCard(); + } + + public void acceptCall() throws CallStateException { + mActivePhone.acceptCall(); + } + + public void rejectCall() throws CallStateException { + mActivePhone.rejectCall(); + } + + public void switchHoldingAndActive() throws CallStateException { + mActivePhone.switchHoldingAndActive(); + } + + public boolean canConference() { + return mActivePhone.canConference(); + } + + public void conference() throws CallStateException { + mActivePhone.conference(); + } + + public void enableEnhancedVoicePrivacy(boolean enable, Message onComplete) { + mActivePhone.enableEnhancedVoicePrivacy(enable, onComplete); + } + + public void getEnhancedVoicePrivacy(Message onComplete) { + mActivePhone.getEnhancedVoicePrivacy(onComplete); + } + + public boolean canTransfer() { + return mActivePhone.canTransfer(); + } + + public void explicitCallTransfer() throws CallStateException { + mActivePhone.explicitCallTransfer(); + } + + public void clearDisconnected() { + mActivePhone.clearDisconnected(); + } + + public Call getForegroundCall() { + return mActivePhone.getForegroundCall(); + } + + public Call getBackgroundCall() { + return mActivePhone.getBackgroundCall(); + } + + public Call getRingingCall() { + return mActivePhone.getRingingCall(); + } + + public Connection dial(String dialString) throws CallStateException { + return mActivePhone.dial(dialString); + } + + public boolean handlePinMmi(String dialString) { + return mActivePhone.handlePinMmi(dialString); + } + + public boolean handleInCallMmiCommands(String command) throws CallStateException { + return mActivePhone.handleInCallMmiCommands(command); + } + + public void sendDtmf(char c) { + mActivePhone.sendDtmf(c); + } + + public void startDtmf(char c) { + mActivePhone.startDtmf(c); + } + + public void stopDtmf() { + mActivePhone.stopDtmf(); + } + + public void setRadioPower(boolean power) { + mActivePhone.setRadioPower(power); + } + + public boolean getMessageWaitingIndicator() { + return mActivePhone.getMessageWaitingIndicator(); + } + + public boolean getCallForwardingIndicator() { + return mActivePhone.getCallForwardingIndicator(); + } + + public String getLine1Number() { + return mActivePhone.getLine1Number(); + } + + public String getLine1AlphaTag() { + return mActivePhone.getLine1AlphaTag(); + } + + public void setLine1Number(String alphaTag, String number, Message onComplete) { + mActivePhone.setLine1Number(alphaTag, number, onComplete); + } + + public String getVoiceMailNumber() { + return mActivePhone.getVoiceMailNumber(); + } + + public String getVoiceMailAlphaTag() { + return mActivePhone.getVoiceMailAlphaTag(); + } + + public void setVoiceMailNumber(String alphaTag,String voiceMailNumber, + Message onComplete) { + mActivePhone.setVoiceMailNumber(alphaTag, voiceMailNumber, onComplete); + } + + public void getCallForwardingOption(int commandInterfaceCFReason, + Message onComplete) { + mActivePhone.getCallForwardingOption(commandInterfaceCFReason, + onComplete); + } + + public void setCallForwardingOption(int commandInterfaceCFReason, + int commandInterfaceCFAction, String dialingNumber, + int timerSeconds, Message onComplete) { + mActivePhone.setCallForwardingOption(commandInterfaceCFReason, + commandInterfaceCFAction, dialingNumber, timerSeconds, onComplete); + } + + public void getOutgoingCallerIdDisplay(Message onComplete) { + mActivePhone.getOutgoingCallerIdDisplay(onComplete); + } + + public void setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode, + Message onComplete) { + mActivePhone.setOutgoingCallerIdDisplay(commandInterfaceCLIRMode, + onComplete); + } + + public void getCallWaiting(Message onComplete) { + mActivePhone.getCallWaiting(onComplete); + } + + public void setCallWaiting(boolean enable, Message onComplete) { + mActivePhone.setCallWaiting(enable, onComplete); + } + + public void getAvailableNetworks(Message response) { + mActivePhone.getAvailableNetworks(response); + } + + public void setNetworkSelectionModeAutomatic(Message response) { + mActivePhone.setNetworkSelectionModeAutomatic(response); + } + + public void selectNetworkManually(NetworkInfo network, Message response) { + mActivePhone.selectNetworkManually(network, response); + } + + public void setPreferredNetworkType(int networkType, Message response) { + mActivePhone.setPreferredNetworkType(networkType, response); + } + + public void getPreferredNetworkType(Message response) { + mActivePhone.getPreferredNetworkType(response); + } + + public void getNeighboringCids(Message response) { + mActivePhone.getNeighboringCids(response); + } + + public void setOnPostDialCharacter(Handler h, int what, Object obj) { + mActivePhone.setOnPostDialCharacter(h, what, obj); + } + + public void setMute(boolean muted) { + mActivePhone.setMute(muted); + } + + public boolean getMute() { + return mActivePhone.getMute(); + } + + public void invokeOemRilRequestRaw(byte[] data, Message response) { + mActivePhone.invokeOemRilRequestRaw(data, response); + } + + public void invokeOemRilRequestStrings(String[] strings, Message response) { + mActivePhone.invokeOemRilRequestStrings(strings, response); + } + + /** + * @deprecated + */ + public void getPdpContextList(Message response) { + mActivePhone.getPdpContextList(response); + } + + public void getDataCallList(Message response) { + mActivePhone.getDataCallList(response); + } + + /** + * @deprecated + */ + public List<PdpConnection> getCurrentPdpList() { + return mActivePhone.getCurrentPdpList(); + } + + public List<DataConnection> getCurrentDataConnectionList() { + return mActivePhone.getCurrentDataConnectionList(); + } + + public void updateServiceLocation(Message response) { + mActivePhone.updateServiceLocation(response); + } + + public void enableLocationUpdates() { + mActivePhone.enableLocationUpdates(); + } + + public void disableLocationUpdates() { + mActivePhone.disableLocationUpdates(); + } + + public void setUnitTestMode(boolean f) { + mActivePhone.setUnitTestMode(f); + } + + public boolean getUnitTestMode() { + return mActivePhone.getUnitTestMode(); + } + + public void setBandMode(int bandMode, Message response) { + mActivePhone.setBandMode(bandMode, response); + } + + public void queryAvailableBandMode(Message response) { + mActivePhone.queryAvailableBandMode(response); + } + + public boolean getDataRoamingEnabled() { + return mActivePhone.getDataRoamingEnabled(); + } + + public void setDataRoamingEnabled(boolean enable) { + mActivePhone.setDataRoamingEnabled(enable); + } + + public void queryCdmaRoamingPreference(Message response) { + mActivePhone.queryCdmaRoamingPreference(response); + } + + public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) { + mActivePhone.setCdmaRoamingPreference(cdmaRoamingType, response); + } + + public void setCdmaSubscription(int cdmaSubscriptionType, Message response) { + mActivePhone.setCdmaSubscription(cdmaSubscriptionType, response); + } + + public SimulatedRadioControl getSimulatedRadioControl() { + return mActivePhone.getSimulatedRadioControl(); + } + + public boolean enableDataConnectivity() { + return mActivePhone.enableDataConnectivity(); + } + + public boolean disableDataConnectivity() { + return mActivePhone.disableDataConnectivity(); + } + + public int enableApnType(String type) { + return mActivePhone.enableApnType(type); + } + + public int disableApnType(String type) { + return mActivePhone.disableApnType(type); + } + + public boolean isDataConnectivityPossible() { + return mActivePhone.isDataConnectivityPossible(); + } + + public String getInterfaceName(String apnType) { + return mActivePhone.getInterfaceName(apnType); + } + + public String getIpAddress(String apnType) { + return mActivePhone.getIpAddress(apnType); + } + + public String getGateway(String apnType) { + return mActivePhone.getGateway(apnType); + } + + public String[] getDnsServers(String apnType) { + return mActivePhone.getDnsServers(apnType); + } + + public String getDeviceId() { + return mActivePhone.getDeviceId(); + } + + public String getDeviceSvn() { + return mActivePhone.getDeviceSvn(); + } + + public String getSubscriberId() { + return mActivePhone.getSubscriberId(); + } + + public String getIccSerialNumber() { + return mActivePhone.getIccSerialNumber(); + } + + public String getEsn() { + return mActivePhone.getEsn(); + } + + public String getMeid() { + return mActivePhone.getMeid(); + } + + public PhoneSubInfo getPhoneSubInfo(){ + return mActivePhone.getPhoneSubInfo(); + } + + public IccSmsInterfaceManager getIccSmsInterfaceManager(){ + return mActivePhone.getIccSmsInterfaceManager(); + } + + public IccPhoneBookInterfaceManager getIccPhoneBookInterfaceManager(){ + return mActivePhone.getIccPhoneBookInterfaceManager(); + } + + public void setTTYModeEnabled(boolean enable, Message onComplete) { + mActivePhone.setTTYModeEnabled(enable, onComplete); + } + + public void queryTTYModeEnabled(Message onComplete) { + mActivePhone.queryTTYModeEnabled(onComplete); + } + + public void activateCellBroadcastSms(int activate, Message response) { + mActivePhone.activateCellBroadcastSms(activate, response); + } + + public void getCellBroadcastSmsConfig(Message response) { + mActivePhone.getCellBroadcastSmsConfig(response); + } + + public void setCellBroadcastSmsConfig(int[] configValuesArray, Message response) { + mActivePhone.setCellBroadcastSmsConfig(configValuesArray, response); + } + + public void notifyDataActivity() { + mActivePhone.notifyDataActivity(); + } +} + diff --git a/telephony/java/com/android/internal/telephony/PhoneStateIntentReceiver.java b/telephony/java/com/android/internal/telephony/PhoneStateIntentReceiver.java index 61d4c9f..fd822cd 100644 --- a/telephony/java/com/android/internal/telephony/PhoneStateIntentReceiver.java +++ b/telephony/java/com/android/internal/telephony/PhoneStateIntentReceiver.java @@ -32,11 +32,11 @@ import android.util.Log; * * Use android.telephony.TelephonyManager and PhoneStateListener instead. * - * + * */ @Deprecated public final class PhoneStateIntentReceiver extends BroadcastReceiver { - private static final String LOG_TAG = "PhoneStateIntRecv"; + private static final String LOG_TAG = "PHONE"; private static final boolean DBG = false; public static final String INTENT_KEY_ASU = "asu"; @@ -182,7 +182,7 @@ public final class PhoneStateIntentReceiver extends BroadcastReceiver { if (TelephonyIntents.ACTION_SIGNAL_STRENGTH_CHANGED.equals(action)) { mAsu = intent.getIntExtra(INTENT_KEY_ASU, mAsu); if (DBG) Log.d(LOG_TAG, "onReceiveIntent: set asu=" + mAsu); - + if (mTarget != null && getNotifySignalStrength()) { Message message = Message.obtain(mTarget, mAsuEventWhat); mTarget.sendMessage(message); diff --git a/telephony/java/com/android/internal/telephony/PhoneSubInfo.java b/telephony/java/com/android/internal/telephony/PhoneSubInfo.java index 644d1f4..4d1f7e5 100644 --- a/telephony/java/com/android/internal/telephony/PhoneSubInfo.java +++ b/telephony/java/com/android/internal/telephony/PhoneSubInfo.java @@ -1,10 +1,25 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ package com.android.internal.telephony; import android.content.Context; -import android.os.ServiceManager; -import com.android.internal.telephony.*; +import android.util.Log; public class PhoneSubInfo extends IPhoneSubInfo.Stub { + static final String LOG_TAG = "PHONE"; private Phone mPhone; private Context mContext; private static final String READ_PHONE_STATE = @@ -13,10 +28,17 @@ public class PhoneSubInfo extends IPhoneSubInfo.Stub { public PhoneSubInfo(Phone phone) { mPhone = phone; mContext = phone.getContext(); - ServiceManager.addService("iphonesubinfo", this); } + + public void dispose() { + } + + protected void finalize() { + Log.d(LOG_TAG, "PhoneSubInfo finalized"); + } + /** - * Retrieves the unique device ID, e.g., IMEI for GSM phones. + * Retrieves the unique device ID, e.g., IMEI for GSM phones and MEID for CDMA phones. */ public String getDeviceId() { mContext.enforceCallingOrSelfPermission(READ_PHONE_STATE, "Requires READ_PHONE_STATE"); @@ -41,11 +63,11 @@ public class PhoneSubInfo extends IPhoneSubInfo.Stub { } /** - * Retrieves the serial number of the SIM, if applicable. + * Retrieves the serial number of the ICC, if applicable. */ - public String getSimSerialNumber() { + public String getIccSerialNumber() { mContext.enforceCallingOrSelfPermission(READ_PHONE_STATE, "Requires READ_PHONE_STATE"); - return mPhone.getSimSerialNumber(); + return mPhone.getIccSerialNumber(); } /** diff --git a/telephony/java/com/android/internal/telephony/PhoneSubInfoProxy.java b/telephony/java/com/android/internal/telephony/PhoneSubInfoProxy.java new file mode 100644 index 0000000..450b3a7 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/PhoneSubInfoProxy.java @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.os.ServiceManager; + + +public class PhoneSubInfoProxy extends IPhoneSubInfo.Stub { + private PhoneSubInfo mPhoneSubInfo; + + public PhoneSubInfoProxy(PhoneSubInfo phoneSubInfo) { + mPhoneSubInfo = phoneSubInfo; + if(ServiceManager.getService("iphonesubinfo") == null) { + ServiceManager.addService("iphonesubinfo", this); + } + } + + public void setmPhoneSubInfo(PhoneSubInfo phoneSubInfo) { + this.mPhoneSubInfo = phoneSubInfo; + } + + public String getDeviceId() { + return mPhoneSubInfo.getDeviceId(); + } + + public String getDeviceSvn() { + return mPhoneSubInfo.getDeviceSvn(); + } + + /** + * Retrieves the unique sbuscriber ID, e.g., IMSI for GSM phones. + */ + public String getSubscriberId() { + return mPhoneSubInfo.getSubscriberId(); + } + + /** + * Retrieves the serial number of the ICC, if applicable. + */ + public String getIccSerialNumber() { + return mPhoneSubInfo.getIccSerialNumber(); + } + + /** + * Retrieves the phone number string for line 1. + */ + public String getLine1Number() { + return mPhoneSubInfo.getLine1Number(); + } + + /** + * Retrieves the alpha identifier for line 1. + */ + public String getLine1AlphaTag() { + return mPhoneSubInfo.getLine1AlphaTag(); + } + + /** + * Retrieves the voice mail number. + */ + public String getVoiceMailNumber() { + return mPhoneSubInfo.getVoiceMailNumber(); + } + + /** + * Retrieves the alpha identifier associated with the voice mail number. + */ + public String getVoiceMailAlphaTag() { + return mPhoneSubInfo.getVoiceMailAlphaTag(); + } +} diff --git a/telephony/java/com/android/internal/telephony/gsm/RIL.java b/telephony/java/com/android/internal/telephony/RIL.java index e2d0f72..f5d3b32 100644 --- a/telephony/java/com/android/internal/telephony/gsm/RIL.java +++ b/telephony/java/com/android/internal/telephony/RIL.java @@ -14,9 +14,8 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; -import static com.android.internal.telephony.gsm.RILConstants.*; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; @@ -32,22 +31,36 @@ import android.os.Parcel; import android.os.PowerManager; import android.os.PowerManager.WakeLock; import android.telephony.PhoneNumberUtils; -import android.telephony.gsm.SmsManager; -import android.telephony.gsm.SmsMessage; import android.telephony.NeighboringCellInfo; -import android.util.Config; +import android.telephony.SmsManager; +import android.telephony.SmsMessage; import android.util.Log; +import android.util.Config; -import java.io.IOException; +import static com.android.internal.telephony.RILConstants.*; + +import com.android.internal.telephony.CallForwardInfo; +import com.android.internal.telephony.CommandException; +import com.android.internal.telephony.gsm.NetworkInfo; +import com.android.internal.telephony.gsm.PDPContextState; +import com.android.internal.telephony.gsm.SuppServiceNotification; +import com.android.internal.telephony.IccCardApplication; +import com.android.internal.telephony.IccCardStatus; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.RILConstants; +import com.android.internal.telephony.SmsResponse; + +import java.io.ByteArrayInputStream; +import java.io.DataInputStream; import java.io.InputStream; +import java.io.IOException; import java.util.ArrayList; import java.util.Collections; /** * {@hide} */ -class RILRequest -{ +class RILRequest { static final String LOG_TAG = "RILJ"; //***** Class Variables @@ -67,14 +80,14 @@ class RILRequest /** * Retrieves a new RILRequest instance from the pool. - * + * * @param request RIL_REQUEST_* * @param result sent when operation completes * @return a RILRequest instance from the pool. */ static RILRequest obtain(int request, Message result) { RILRequest rr = null; - + synchronized(sPoolSync) { if (sPool != null) { rr = sPool; @@ -83,7 +96,7 @@ class RILRequest sPoolSize--; } } - + if (rr == null) { rr = new RILRequest(); } @@ -108,7 +121,7 @@ class RILRequest /** * Returns a RILRequest instance to the pool. - * + * * Note: This should only be called once per use. */ void release() { @@ -121,21 +134,18 @@ class RILRequest } } - private RILRequest() - { + private RILRequest() { } static void - resetSerial() - { + resetSerial() { synchronized(sSerialMonitor) { sNextSerial = 0; } } String - serialString() - { + serialString() { //Cheesy way to do %04d StringBuilder sb = new StringBuilder(8); String sn; @@ -154,14 +164,13 @@ class RILRequest } void - onError(int error) - { + onError(int error) { CommandException ex; ex = CommandException.fromRilErrno(error); if (RIL.RILJ_LOGD) Log.d(LOG_TAG, serialString() + "< " - + RIL.requestToString(mRequest) + + RIL.requestToString(mRequest) + " error: " + ex); if (mResult != null) { @@ -180,11 +189,10 @@ class RILRequest /** * RIL implementation of the CommandsInterface. * FIXME public only for testing - * + * * {@hide} */ -public final class RIL extends BaseCommands implements CommandsInterface -{ +public final class RIL extends BaseCommands implements CommandsInterface { static final String LOG_TAG = "RILJ"; private static final boolean DBG = false; static final boolean RILJ_LOGD = Config.LOGD; @@ -194,20 +202,20 @@ public final class RIL extends BaseCommands implements CommandsInterface //***** Instance Variables LocalSocket mSocket; - HandlerThread mSenderThread; + HandlerThread mSenderThread; RILSender mSender; Thread mReceiverThread; RILReceiver mReceiver; private Context mContext; WakeLock mWakeLock; int mRequestMessagesPending; - + // Is this the first radio state change? private boolean mInitialRadioStateChange = true; //I'd rather this be LinkedList or something ArrayList<RILRequest> mRequestsList = new ArrayList<RILRequest>(); - + Object mLastNITZTimeInfo; //***** Events @@ -238,20 +246,18 @@ public final class RIL extends BaseCommands implements CommandsInterface } } }; - - class RILSender extends Handler implements Runnable - { + + class RILSender extends Handler implements Runnable { public RILSender(Looper looper) { super(looper); } - + // Only allocated once byte[] dataLength = new byte[4]; //***** Runnable implementation public void - run() - { + run() { //setup if needed } @@ -259,11 +265,10 @@ public final class RIL extends BaseCommands implements CommandsInterface //***** Handler implemementation public void - handleMessage(Message msg) - { + handleMessage(Message msg) { RILRequest rr = (RILRequest)(msg.obj); RILRequest req = null; - + switch (msg.what) { case EVENT_SEND: /** @@ -300,7 +305,7 @@ public final class RIL extends BaseCommands implements CommandsInterface if (data.length > RIL_MAX_COMMAND_BYTES) { throw new RuntimeException( - "Parcel larger than max bytes allowed! " + "Parcel larger than max bytes allowed! " + data.length); } @@ -311,7 +316,7 @@ public final class RIL extends BaseCommands implements CommandsInterface //Log.v(LOG_TAG, "writing packet: " + data.length + " bytes"); - s.getOutputStream().write(dataLength); + s.getOutputStream().write(dataLength); s.getOutputStream().write(data); } catch (IOException ex) { Log.e(LOG_TAG, "IOException", ex); @@ -351,12 +356,12 @@ public final class RIL extends BaseCommands implements CommandsInterface Log.d(LOG_TAG, "WAKE_LOCK_TIMEOUT " + " mReqPending=" + mRequestMessagesPending + " mRequestList=" + count); - + for (int i = 0; i < count; i++) { rr = mRequestsList.get(i); Log.d(LOG_TAG, i + ": [" + rr.mSerial + "] " + requestToString(rr.mRequest)); - + } } } @@ -383,8 +388,7 @@ public final class RIL extends BaseCommands implements CommandsInterface * @throws IOException */ private static int readRilMessage(InputStream is, byte[] buffer) - throws IOException - { + throws IOException { int countRead; int offset; int remaining; @@ -429,20 +433,17 @@ public final class RIL extends BaseCommands implements CommandsInterface return messageLength; } - class RILReceiver implements Runnable - { + class RILReceiver implements Runnable { byte[] buffer; - RILReceiver() - { + RILReceiver() { buffer = new byte[RIL_MAX_COMMAND_BYTES]; } public void - run() - { + run() { int retryCount = 0; - + try {for (;;) { LocalSocket s = null; LocalSocketAddress l; @@ -460,23 +461,23 @@ public final class RIL extends BaseCommands implements CommandsInterface } catch (IOException ex2) { //ignore failure to close after failure to connect } - + // don't print an error message after the the first time // or after the 8th time if (retryCount == 8) { - Log.e (LOG_TAG, + Log.e (LOG_TAG, "Couldn't find '" + SOCKET_NAME_RIL + "' socket after " + retryCount + " times, continuing to retry silently"); } else if (retryCount > 0 && retryCount < 8) { - Log.i (LOG_TAG, + Log.i (LOG_TAG, "Couldn't find '" + SOCKET_NAME_RIL + "' socket; retrying after timeout"); } try { - Thread.sleep(SOCKET_OPEN_RETRY_MILLIS); + Thread.sleep(SOCKET_OPEN_RETRY_MILLIS); } catch (InterruptedException er) { } @@ -492,7 +493,7 @@ public final class RIL extends BaseCommands implements CommandsInterface int length = 0; try { InputStream is = mSocket.getInputStream(); - + for (;;) { Parcel p; @@ -524,9 +525,9 @@ public final class RIL extends BaseCommands implements CommandsInterface + "' socket"); setRadioState (RadioState.RADIO_UNAVAILABLE); - + try { - mSocket.close(); + mSocket.close(); } catch (IOException ex) { } @@ -551,15 +552,39 @@ public final class RIL extends BaseCommands implements CommandsInterface - //***** Constructor - + //***** Constructors public - RIL(Context context) - { + RIL(Context context) { + this(context, RILConstants.PREFERRED_NETWORK_MODE, + RILConstants.PREFERRED_CDMA_SUBSCRIPTION); + } + + public RIL(Context context, int networkMode, int cdmaSubscription) { super(context); + mCdmaSubscription = cdmaSubscription; + mNetworkMode = networkMode; + //At startup mPhoneType is first set from networkMode + switch(networkMode) { + case RILConstants.NETWORK_MODE_WCDMA_PREF: + case RILConstants.NETWORK_MODE_GSM_ONLY: + case RILConstants.NETWORK_MODE_WCDMA_ONLY: + case RILConstants.NETWORK_MODE_GSM_UMTS: + mPhoneType = RILConstants.GSM_PHONE; + break; + case RILConstants.NETWORK_MODE_CDMA: + case RILConstants.NETWORK_MODE_CDMA_NO_EVDO: + case RILConstants.NETWORK_MODE_EVDO_NO_CDMA: + mPhoneType = RILConstants.CDMA_PHONE; + break; + case RILConstants.NETWORK_MODE_GLOBAL: + mPhoneType = RILConstants.CDMA_PHONE; + break; + default: + mPhoneType = RILConstants.CDMA_PHONE; + } PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE); - mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, LOG_TAG); + mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, LOG_TAG); mWakeLock.setReferenceCounted(false); mRequestMessagesPending = 0; @@ -583,9 +608,8 @@ public final class RIL extends BaseCommands implements CommandsInterface //***** CommandsInterface implementation - @Override public void - setOnNITZTime(Handler h, int what, Object obj) - { + @Override public void + setOnNITZTime(Handler h, int what, Object obj) { super.setOnNITZTime(h, what, obj); // Send the last NITZ time if we have it @@ -597,9 +621,10 @@ public final class RIL extends BaseCommands implements CommandsInterface } } - public void - getSimStatus(Message result) - { + public void + getIccStatus(Message result) { + //Note: This RIL request has not been renamed to ICC, + // but this request is also valid for SIM and RUIM RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_SIM_STATUS, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -607,9 +632,10 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - supplySimPin(String pin, Message result) - { + public void + supplyIccPin(String pin, Message result) { + //Note: This RIL request has not been renamed to ICC, + // but this request is also valid for SIM and RUIM RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_SIM_PIN, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -620,9 +646,10 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - supplySimPuk(String puk, String newPin, Message result) - { + public void + supplyIccPuk(String puk, String newPin, Message result) { + //Note: This RIL request has not been renamed to ICC, + // but this request is also valid for SIM and RUIM RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_SIM_PUK, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -634,9 +661,10 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - supplySimPin2(String pin, Message result) - { + public void + supplyIccPin2(String pin, Message result) { + //Note: This RIL request has not been renamed to ICC, + // but this request is also valid for SIM and RUIM RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_SIM_PIN2, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -647,9 +675,10 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - supplySimPuk2(String puk, String newPin2, Message result) - { + public void + supplyIccPuk2(String puk, String newPin2, Message result) { + //Note: This RIL request has not been renamed to ICC, + // but this request is also valid for SIM and RUIM RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_SIM_PUK2, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -662,8 +691,9 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - changeSimPin(String oldPin, String newPin, Message result) - { + changeIccPin(String oldPin, String newPin, Message result) { + //Note: This RIL request has not been renamed to ICC, + // but this request is also valid for SIM and RUIM RILRequest rr = RILRequest.obtain(RIL_REQUEST_CHANGE_SIM_PIN, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -676,8 +706,9 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - changeSimPin2(String oldPin2, String newPin2, Message result) - { + changeIccPin2(String oldPin2, String newPin2, Message result) { + //Note: This RIL request has not been renamed to ICC, + // but this request is also valid for SIM and RUIM RILRequest rr = RILRequest.obtain(RIL_REQUEST_CHANGE_SIM_PIN2, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -690,8 +721,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - changeBarringPassword(String facility, String oldPwd, String newPwd, Message result) - { + changeBarringPassword(String facility, String oldPwd, String newPwd, Message result) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_CHANGE_BARRING_PASSWORD, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -704,9 +734,8 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - supplyNetworkDepersonalization(String netpin, Message result) - { + public void + supplyNetworkDepersonalization(String netpin, Message result) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -716,10 +745,9 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - - public void - getCurrentCalls (Message result) - { + + public void + getCurrentCalls (Message result) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_CURRENT_CALLS, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -727,19 +755,22 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - getPDPContextList(Message result) - { - RILRequest rr = RILRequest.obtain(RIL_REQUEST_PDP_CONTEXT_LIST, result); + public void + getPDPContextList(Message result) { + getDataCallList(result); + } + + public void + getDataCallList(Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_DATA_CALL_LIST, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); send(rr); } - public void - dial (String address, int clirMode, Message result) - { + public void + dial (String address, int clirMode, Message result) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_DIAL, result); rr.mp.writeString(address); @@ -750,19 +781,20 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - getIMSI(Message result) - { + public void + getIMSI(Message result) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_IMSI, result); - if (RILJ_LOGD) riljLog(rr.serialString() + "> getIMSI:RIL_REQUEST_GET_IMSI " + RIL_REQUEST_GET_IMSI + " " + requestToString(rr.mRequest)); + if (RILJ_LOGD) riljLog(rr.serialString() + + "> getIMSI:RIL_REQUEST_GET_IMSI " + + RIL_REQUEST_GET_IMSI + + " " + requestToString(rr.mRequest)); send(rr); } public void - getIMEI(Message result) - { + getIMEI(Message result) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_IMEI, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -771,8 +803,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - getIMEISV(Message result) - { + getIMEISV(Message result) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_IMEISV, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -781,14 +812,14 @@ public final class RIL extends BaseCommands implements CommandsInterface } - public void - hangupConnection (int gsmIndex, Message result) - { + public void + hangupConnection (int gsmIndex, Message result) { if (RILJ_LOGD) riljLog("hangupConnection: gsmIndex=" + gsmIndex); RILRequest rr = RILRequest.obtain(RIL_REQUEST_HANGUP, result); - if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + gsmIndex); + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + + gsmIndex); rr.mp.writeInt(1); rr.mp.writeInt(gsmIndex); @@ -796,10 +827,9 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - hangupWaitingOrBackground (Message result) - { - RILRequest rr = RILRequest.obtain(RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND, + public void + hangupWaitingOrBackground (Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -808,11 +838,10 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - hangupForegroundResumeBackground (Message result) - { - RILRequest rr + hangupForegroundResumeBackground (Message result) { + RILRequest rr = RILRequest.obtain( - RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND, + RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -820,11 +849,10 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - switchWaitingOrHoldingAndActive (Message result) - { - RILRequest rr + switchWaitingOrHoldingAndActive (Message result) { + RILRequest rr = RILRequest.obtain( - RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE, + RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -832,9 +860,8 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - conference (Message result) - { - RILRequest rr + conference (Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CONFERENCE, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -843,10 +870,25 @@ public final class RIL extends BaseCommands implements CommandsInterface } + public void setPreferredVoicePrivacy(boolean enable, Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE, + result); + + rr.mp.writeInt(1); + rr.mp.writeInt(enable ? 1:0); + + send(rr); + } + + public void getPreferredVoicePrivacy(Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE, + result); + send(rr); + } + public void - separateConnection (int gsmIndex, Message result) - { - RILRequest rr + separateConnection (int gsmIndex, Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SEPARATE_CONNECTION, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) @@ -859,9 +901,8 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - acceptCall (Message result) - { - RILRequest rr + acceptCall (Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_ANSWER, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -869,10 +910,9 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - rejectCall (Message result) - { - RILRequest rr + public void + rejectCall (Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_UDUB, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -881,8 +921,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - explicitCallTransfer (Message result) - { + explicitCallTransfer (Message result) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_EXPLICIT_CALL_TRANSFER, result); @@ -892,9 +931,8 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - getLastCallFailCause (Message result) - { - RILRequest rr + getLastCallFailCause (Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_LAST_CALL_FAIL_CAUSE, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -902,11 +940,21 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - getLastPdpFailCause (Message result) - { - RILRequest rr - = RILRequest.obtain(RIL_REQUEST_LAST_PDP_FAIL_CAUSE, result); + /** + * @deprecated + */ + public void + getLastPdpFailCause (Message result) { + getLastDataCallFailCause (result); + } + + /** + * The preferred new alternative to getLastPdpFailCause + */ + public void + getLastDataCallFailCause (Message result) { + RILRequest rr + = RILRequest.obtain(RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -914,9 +962,8 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - setMute (boolean enableMute, Message response) - { - RILRequest rr + setMute (boolean enableMute, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_MUTE, response); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) @@ -929,9 +976,8 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - getMute (Message response) - { - RILRequest rr + getMute (Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_MUTE, response); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -940,9 +986,8 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - getSignalStrength (Message result) - { - RILRequest rr + getSignalStrength (Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIGNAL_STRENGTH, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -950,10 +995,9 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - getRegistrationState (Message result) - { - RILRequest rr + public void + getRegistrationState (Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_REGISTRATION_STATE, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -961,10 +1005,9 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - getGPRSRegistrationState (Message result) - { - RILRequest rr + public void + getGPRSRegistrationState (Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_GPRS_REGISTRATION_STATE, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -972,10 +1015,9 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - getOperator(Message result) - { - RILRequest rr + public void + getOperator(Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_OPERATOR, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -983,14 +1025,13 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void - sendDtmf(char c, Message result) - { - RILRequest rr + public void + sendDtmf(char c, Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_DTMF, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); - + rr.mp.writeString(Character.toString(c)); send(rr); @@ -1020,9 +1061,8 @@ public final class RIL extends BaseCommands implements CommandsInterface public void - sendSMS (String smscPDU, String pdu, Message result) - { - RILRequest rr + sendSMS (String smscPDU, String pdu, Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SEND_SMS, result); rr.mp.writeInt(2); @@ -1030,19 +1070,82 @@ public final class RIL extends BaseCommands implements CommandsInterface rr.mp.writeString(pdu); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); - + + send(rr); + } + + public void + sendCdmaSms(byte[] pdu, Message result) { + int address_nbr_of_digits; + int subaddr_nbr_of_digits; + int bearerDataLength; + ByteArrayInputStream bais = new ByteArrayInputStream(pdu); + DataInputStream dis = new DataInputStream(bais); + + RILRequest rr + = RILRequest.obtain(RIL_REQUEST_CDMA_SEND_SMS, result); + + try { + rr.mp.writeInt(dis.readInt()); //teleServiceId + rr.mp.writeByte((byte) dis.readInt()); //servicePresent + rr.mp.writeInt(dis.readInt()); //serviceCategory + rr.mp.writeInt(dis.read()); //address_digit_mode + rr.mp.writeInt(dis.read()); //address_nbr_mode + rr.mp.writeInt(dis.read()); //address_ton + rr.mp.writeInt(dis.read()); //address_nbr_plan + address_nbr_of_digits = (byte) dis.read(); + rr.mp.writeByte((byte) address_nbr_of_digits); + for(int i=0; i < address_nbr_of_digits; i++){ + rr.mp.writeByte(dis.readByte()); // address_orig_bytes[i] + } + rr.mp.writeInt(dis.read()); //subaddressType + rr.mp.writeByte((byte) dis.read()); //subaddr_odd + subaddr_nbr_of_digits = (byte) dis.read(); + rr.mp.writeByte((byte) subaddr_nbr_of_digits); + for(int i=0; i < subaddr_nbr_of_digits; i++){ + rr.mp.writeByte(dis.readByte()); //subaddr_orig_bytes[i] + } + + bearerDataLength = dis.read(); + rr.mp.writeInt(bearerDataLength); + for(int i=0; i < bearerDataLength; i++){ + rr.mp.writeByte(dis.readByte()); //bearerData[i] + } + }catch (IOException ex){ + if (RILJ_LOGD) riljLog("sendSmsCdma: conversion from input stream to object failed: " + + ex); + } + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); + send(rr); } public void deleteSmsOnSim(int index, Message response) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_DELETE_SMS_ON_SIM, response); - + rr.mp.writeInt(1); rr.mp.writeInt(index); - if (RILJ_LOGD) { - riljLog(rr.serialString() + "> " + if (Config.LOGD) { + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + + requestToString(rr.mRequest) + + " " + index); + } + + send(rr); + } + + public void deleteSmsOnRuim(int index, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM, + response); + + rr.mp.writeInt(1); + rr.mp.writeInt(index); + + if (Config.LOGD) { + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + index); } @@ -1052,17 +1155,35 @@ public final class RIL extends BaseCommands implements CommandsInterface public void writeSmsToSim(int status, String smsc, String pdu, Message response) { status = translateStatus(status); - + RILRequest rr = RILRequest.obtain(RIL_REQUEST_WRITE_SMS_TO_SIM, response); - + rr.mp.writeInt(status); rr.mp.writeString(pdu); rr.mp.writeString(smsc); - - if (RILJ_LOGD) { - riljLog(rr.serialString() + "> " - + requestToString(rr.mRequest) + + if (Config.LOGD) { + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + + requestToString(rr.mRequest) + + " " + status); + } + + send(rr); + } + + public void writeSmsToRuim(int status, String pdu, Message response) { + status = translateStatus(status); + + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM, + response); + + rr.mp.writeInt(status); + rr.mp.writeString(pdu); + + if (Config.LOGD) { + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + + requestToString(rr.mRequest) + " " + status); } @@ -1075,101 +1196,166 @@ public final class RIL extends BaseCommands implements CommandsInterface */ private int translateStatus(int status) { switch(status & 0x7) { - case SmsManager.STATUS_ON_SIM_READ: + case SmsManager.STATUS_ON_ICC_READ: return 1; - case SmsManager.STATUS_ON_SIM_UNREAD: + case SmsManager.STATUS_ON_ICC_UNREAD: return 0; - case SmsManager.STATUS_ON_SIM_SENT: + case SmsManager.STATUS_ON_ICC_SENT: return 3; - case SmsManager.STATUS_ON_SIM_UNSENT: + case SmsManager.STATUS_ON_ICC_UNSENT: return 2; } - + // Default to READ. return 1; } - public void - setupDefaultPDP(String apn, String user, String password, Message result) - { - RILRequest rr - = RILRequest.obtain(RIL_REQUEST_SETUP_DEFAULT_PDP, result); + /** + * @deprecated + */ + public void + setupDefaultPDP(String apn, String user, String password, Message result) { + String radioTechnology = "1"; //0 for CDMA, 1 for GSM/UMTS + String profile = ""; //profile number, NULL for GSM/UMTS + setupDataCall(radioTechnology, profile, apn, user, + password, result); - rr.mp.writeInt(3); + } + + /** + * @deprecated + */ + public void + deactivateDefaultPDP(int cid, Message result) { + deactivateDataCall(cid, result); + } + + /** + * The preferred new alternative to setupDefaultPDP that is + * CDMA-compatible. + * + */ + public void + setupDataCall(String radioTechnology, String profile, String apn, + String user, String password, Message result) { + RILRequest rr + = RILRequest.obtain(RIL_REQUEST_SETUP_DATA_CALL, result); + + rr.mp.writeInt(5); + + rr.mp.writeString(radioTechnology); + rr.mp.writeString(profile); rr.mp.writeString(apn); rr.mp.writeString(user); rr.mp.writeString(password); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + apn); - + send(rr); } public void - deactivateDefaultPDP(int cid, Message result) - { - RILRequest rr - = RILRequest.obtain(RIL_REQUEST_DEACTIVATE_DEFAULT_PDP, result); + deactivateDataCall(int cid, Message result) { + RILRequest rr + = RILRequest.obtain(RIL_REQUEST_DEACTIVATE_DATA_CALL, result); rr.mp.writeInt(1); rr.mp.writeString(Integer.toString(cid)); - if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + cid); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + + requestToString(rr.mRequest) + " " + cid); + send(rr); } public void - setRadioPower(boolean on, Message result) - { - RILRequest rr + setRadioPower(boolean on, Message result) { + //if radio is OFF set preferred NW type and cmda subscription + if(mInitialRadioStateChange) { + synchronized (mStateMonitor) { + if (!mState.isOn()) { + RILRequest rrPnt = RILRequest.obtain( + RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE, null); + + rrPnt.mp.writeInt(1); + rrPnt.mp.writeInt(mNetworkMode); + if (RILJ_LOGD) riljLog(rrPnt.serialString() + "> " + + requestToString(rrPnt.mRequest) + " : " + mNetworkMode); + + send(rrPnt); + + RILRequest rrCs = RILRequest.obtain( + RIL_REQUEST_CDMA_SET_SUBSCRIPTION, null); + rrCs.mp.writeInt(1); + rrCs.mp.writeInt(mCdmaSubscription); + if (RILJ_LOGD) riljLog(rrCs.serialString() + "> " + + requestToString(rrCs.mRequest) + " : " + mCdmaSubscription); + send(rrCs); + } + } + } + RILRequest rr = RILRequest.obtain(RIL_REQUEST_RADIO_POWER, result); rr.mp.writeInt(1); rr.mp.writeInt(on ? 1 : 0); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); - + send(rr); } public void - setSuppServiceNotifications(boolean enable, Message result) - { - RILRequest rr + setSuppServiceNotifications(boolean enable, Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION, result); rr.mp.writeInt(1); rr.mp.writeInt(enable ? 1 : 0); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " - + requestToString(rr.mRequest)); + + requestToString(rr.mRequest)); send(rr); } - public void - acknowledgeLastIncomingSMS(boolean success, Message result) - { - RILRequest rr + public void + acknowledgeLastIncomingSMS(boolean success, Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SMS_ACKNOWLEDGE, result); rr.mp.writeInt(1); rr.mp.writeInt(success ? 1 : 0); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); - + send(rr); } - + public void - simIO (int command, int fileid, String path, int p1, int p2, int p3, - String data, String pin2, Message result) - { - RILRequest rr + acknowledgeLastIncomingCdmaSms(boolean success, Message result) { + RILRequest rr + = RILRequest.obtain(RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE, result); + + rr.mp.writeInt(success ? 0 : 1); //RIL_CDMA_SMS_ErrorClass + // cause code according to X.S004-550E + rr.mp.writeInt(39); //39 means other terminal problem; is not interpreted for success. + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); + + send(rr); + } + + + public void + iccIO (int command, int fileid, String path, int p1, int p2, int p3, + String data, String pin2, Message result) { + //Note: This RIL request has not been renamed to ICC, + // but this request is also valid for SIM and RUIM + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SIM_IO, result); - + rr.mp.writeInt(command); rr.mp.writeInt(fileid); rr.mp.writeString(path); @@ -1179,51 +1365,48 @@ public final class RIL extends BaseCommands implements CommandsInterface rr.mp.writeString(data); rr.mp.writeString(pin2); - if (RILJ_LOGD) riljLog(rr.serialString() + "> simIO: " + requestToString(rr.mRequest) - + " 0x" + Integer.toHexString(command) - + " 0x" + Integer.toHexString(fileid) + " " + if (RILJ_LOGD) riljLog(rr.serialString() + "> iccIO: " + requestToString(rr.mRequest) + + " 0x" + Integer.toHexString(command) + + " 0x" + Integer.toHexString(fileid) + " " + p1 + "," + p2 + "," + p3); - + send(rr); } - + public void - getCLIR(Message result) - { - RILRequest rr + getCLIR(Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_GET_CLIR, result); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); - + send(rr); } public void - setCLIR(int clirMode, Message result) - { - RILRequest rr + setCLIR(int clirMode, Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_CLIR, result); // count ints rr.mp.writeInt(1); rr.mp.writeInt(clirMode); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + clirMode); - + send(rr); } public void - queryCallWaiting(int serviceClass, Message response) - { - RILRequest rr + queryCallWaiting(int serviceClass, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_QUERY_CALL_WAITING, response); rr.mp.writeInt(1); rr.mp.writeInt(serviceClass); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + serviceClass); @@ -1231,77 +1414,71 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - setCallWaiting(boolean enable, int serviceClass, Message response) - { - RILRequest rr + setCallWaiting(boolean enable, int serviceClass, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_CALL_WAITING, response); - + rr.mp.writeInt(2); rr.mp.writeInt(enable ? 1 : 0); rr.mp.writeInt(serviceClass); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + enable + ", " + serviceClass); - + send(rr); } public void - setNetworkSelectionModeAutomatic(Message response) - { - RILRequest rr - = RILRequest.obtain(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, + setNetworkSelectionModeAutomatic(Message response) { + RILRequest rr + = RILRequest.obtain(RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, response); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); - + send(rr); } - public void - setNetworkSelectionModeManual(String operatorNumeric, Message response) - { - RILRequest rr - = RILRequest.obtain(RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL, + public void + setNetworkSelectionModeManual(String operatorNumeric, Message response) { + RILRequest rr + = RILRequest.obtain(RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL, response); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + operatorNumeric); rr.mp.writeString(operatorNumeric); - + send(rr); } - public void - getNetworkSelectionMode(Message response) - { - RILRequest rr - = RILRequest.obtain(RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE, + public void + getNetworkSelectionMode(Message response) { + RILRequest rr + = RILRequest.obtain(RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE, response); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); - + send(rr); } - public void - getAvailableNetworks(Message response) - { - RILRequest rr - = RILRequest.obtain(RIL_REQUEST_QUERY_AVAILABLE_NETWORKS, + public void + getAvailableNetworks(Message response) { + RILRequest rr + = RILRequest.obtain(RIL_REQUEST_QUERY_AVAILABLE_NETWORKS, response); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); - + send(rr); } public void - setCallForward(int action, int cfReason, int serviceClass, - String number, int timeSeconds, Message response) - { - RILRequest rr + setCallForward(int action, int cfReason, int serviceClass, + String number, int timeSeconds, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_CALL_FORWARD, response); rr.mp.writeInt(action); @@ -1310,19 +1487,18 @@ public final class RIL extends BaseCommands implements CommandsInterface rr.mp.writeInt(PhoneNumberUtils.toaFromString(number)); rr.mp.writeString(number); rr.mp.writeInt (timeSeconds); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) - + " " + action + " " + cfReason + " " + serviceClass + + " " + action + " " + cfReason + " " + serviceClass + timeSeconds); - + send(rr); } public void queryCallForwardStatus(int cfReason, int serviceClass, - String number, Message response) - { - RILRequest rr + String number, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_QUERY_CALL_FORWARD_STATUS, response); rr.mp.writeInt(2); // 2 is for query action, not in used anyway @@ -1331,7 +1507,7 @@ public final class RIL extends BaseCommands implements CommandsInterface rr.mp.writeInt(PhoneNumberUtils.toaFromString(number)); rr.mp.writeString(number); rr.mp.writeInt (0); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + " " + cfReason + " " + serviceClass); @@ -1339,8 +1515,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } public void - queryCLIP(Message response) - { + queryCLIP(Message response) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_QUERY_CLIP, response); @@ -1351,11 +1526,10 @@ public final class RIL extends BaseCommands implements CommandsInterface public void - getBasebandVersion (Message response) - { - RILRequest rr + getBasebandVersion (Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_BASEBAND_VERSION, response); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); send(rr); @@ -1363,14 +1537,13 @@ public final class RIL extends BaseCommands implements CommandsInterface public void queryFacilityLock (String facility, String password, int serviceClass, - Message response) - { + Message response) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_QUERY_FACILITY_LOCK, response); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); // count strings - rr.mp.writeInt(3); + rr.mp.writeInt(3); rr.mp.writeString(facility); rr.mp.writeString(password); @@ -1382,8 +1555,7 @@ public final class RIL extends BaseCommands implements CommandsInterface public void setFacilityLock (String facility, boolean lockState, String password, - int serviceClass, Message response) - { + int serviceClass, Message response) { String lockString; RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_FACILITY_LOCK, response); @@ -1402,11 +1574,10 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - + public void - sendUSSD (String ussdString, Message response) - { - RILRequest rr + sendUSSD (String ussdString, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_SEND_USSD, response); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) @@ -1429,9 +1600,8 @@ public final class RIL extends BaseCommands implements CommandsInterface } - public void resetRadio(Message result) - { - RILRequest rr + public void resetRadio(Message result) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_RESET_RADIO, result); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -1439,13 +1609,12 @@ public final class RIL extends BaseCommands implements CommandsInterface send(rr); } - public void invokeOemRilRequestRaw(byte[] data, Message response) - { - RILRequest rr + public void invokeOemRilRequestRaw(byte[] data, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_OEM_HOOK_RAW, response); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) - + "[" + SimUtils.bytesToHexString(data) + "]"); + + "[" + IccUtils.bytesToHexString(data) + "]"); rr.mp.writeByteArray(data); @@ -1453,9 +1622,8 @@ public final class RIL extends BaseCommands implements CommandsInterface } - public void invokeOemRilRequestStrings(String[] strings, Message response) - { - RILRequest rr + public void invokeOemRilRequestStrings(String[] strings, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_OEM_HOOK_STRINGS, response); if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); @@ -1592,29 +1760,27 @@ public final class RIL extends BaseCommands implements CommandsInterface RILRequest rr = RILRequest.obtain(RIL_REQUEST_SET_LOCATION_UPDATES, response); rr.mp.writeInt(1); rr.mp.writeInt(enable ? 1 : 0); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + ": " + enable); - + send(rr); } //***** Private Methods - private void sendScreenState(boolean on) - { + private void sendScreenState(boolean on) { RILRequest rr = RILRequest.obtain(RIL_REQUEST_SCREEN_STATE, null); rr.mp.writeInt(1); rr.mp.writeInt(on ? 1 : 0); - + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + ": " + on); - + send(rr); } - + protected void - onRadioAvailable() - { + onRadioAvailable() { // In case screen state was lost (due to process crash), // this ensures that the RIL knows the correct screen state. @@ -1633,13 +1799,18 @@ public final class RIL extends BaseCommands implements CommandsInterface case 2: newState = RadioState.SIM_NOT_READY; break; case 3: newState = RadioState.SIM_LOCKED_OR_ABSENT; break; case 4: newState = RadioState.SIM_READY; break; - default: + case 5: newState = RadioState.RUIM_NOT_READY; break; + case 6: newState = RadioState.RUIM_READY; break; + case 7: newState = RadioState.RUIM_LOCKED_OR_ABSENT; break; + case 8: newState = RadioState.NV_NOT_READY; break; + case 9: newState = RadioState.NV_READY; break; + + default: throw new RuntimeException( "Unrecognized RIL_RadioState: " +state); } if (mInitialRadioStateChange) { - mInitialRadioStateChange = false; if (newState.isOn()) { /* If this is our first notification, make sure the radio * is powered off. This gets the radio into a known state, @@ -1648,12 +1819,15 @@ public final class RIL extends BaseCommands implements CommandsInterface * and/or radio knowing. */ if (RILJ_LOGD) Log.d(LOG_TAG, "Radio ON @ init; reset to OFF"); - setRadioPower(false, null); - return; + setRadioPower(false, null); + } else { + if (DBG) Log.d(LOG_TAG, "Radio OFF @ init"); + setRadioState(newState); } + mInitialRadioStateChange = false; + } else { + setRadioState(newState); } - - setRadioState(newState); } /** @@ -1661,13 +1835,12 @@ public final class RIL extends BaseCommands implements CommandsInterface * a) There is outstanding RIL request sent to RIL deamon and no replied * b) There is a request waiting to be sent out. * - * There is a WAKE_LOCK_TIMEOUT to release the lock, though it shouldn't + * There is a WAKE_LOCK_TIMEOUT to release the lock, though it shouldn't * happen often. */ private void - acquireWakeLock() - { + acquireWakeLock() { synchronized (mWakeLock) { mWakeLock.acquire(); mRequestMessagesPending++; @@ -1679,8 +1852,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } private void - releaseWakeLockIfDone() - { + releaseWakeLockIfDone() { synchronized (mWakeLock) { if (mWakeLock.isHeld() && (mRequestMessagesPending == 0) && @@ -1692,8 +1864,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } private void - send(RILRequest rr) - { + send(RILRequest rr) { Message msg; msg = mSender.obtainMessage(EVENT_SEND, rr); @@ -1704,8 +1875,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } private void - processResponse (Parcel p) - { + processResponse (Parcel p) { int type; type = p.readInt(); @@ -1714,15 +1884,12 @@ public final class RIL extends BaseCommands implements CommandsInterface processUnsolicited (p); } else if (type == RESPONSE_SOLICITED) { processSolicited (p); - } + } releaseWakeLockIfDone(); } - - - private RILRequest findAndRemoveRequestFromList(int serial) - { + private RILRequest findAndRemoveRequestFromList(int serial) { synchronized (mRequestsList) { for (int i = 0, s = mRequestsList.size() ; i < s ; i++) { RILRequest rr = mRequestsList.get(i); @@ -1738,8 +1905,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } private void - processSolicited (Parcel p) - { + processSolicited (Parcel p) { int serial, error; boolean found = false; @@ -1751,7 +1917,7 @@ public final class RIL extends BaseCommands implements CommandsInterface rr = findAndRemoveRequestFromList(serial); if (rr == null) { - Log.w(LOG_TAG, "Unexpected solicited response! sn: " + Log.w(LOG_TAG, "Unexpected solicited response! sn: " + serial + " error: " + error); return; } @@ -1763,14 +1929,14 @@ public final class RIL extends BaseCommands implements CommandsInterface } Object ret; - + try {switch (rr.mRequest) { /* cat libs/telephony/ril_commands.h \ | egrep "^ *{RIL_" \ | sed -re 's/\{([^,]+),[^,]+,([^}]+).+/case \1: ret = \2(p); break;/' */ - case RIL_REQUEST_GET_SIM_STATUS: ret = responseSimStatus(p); break; + case RIL_REQUEST_GET_SIM_STATUS: ret = responseIccCardStatus(p); break; case RIL_REQUEST_ENTER_SIM_PIN: ret = responseVoid(p); break; case RIL_REQUEST_ENTER_SIM_PUK: ret = responseVoid(p); break; case RIL_REQUEST_ENTER_SIM_PIN2: ret = responseVoid(p); break; @@ -1796,8 +1962,8 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_REQUEST_DTMF: ret = responseVoid(p); break; case RIL_REQUEST_SEND_SMS: ret = responseSMS(p); break; case RIL_REQUEST_SEND_SMS_EXPECT_MORE: ret = responseSMS(p); break; - case RIL_REQUEST_SETUP_DEFAULT_PDP: ret = responseStrings(p); break; - case RIL_REQUEST_SIM_IO: ret = responseSIM_IO(p); break; + case RIL_REQUEST_SETUP_DATA_CALL: ret = responseStrings(p); break; + case RIL_REQUEST_SIM_IO: ret = responseICC_IO(p); break; case RIL_REQUEST_SEND_USSD: ret = responseVoid(p); break; case RIL_REQUEST_CANCEL_USSD: ret = responseVoid(p); break; case RIL_REQUEST_GET_CLIR: ret = responseInts(p); break; @@ -1810,7 +1976,7 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_REQUEST_GET_IMEI: ret = responseString(p); break; case RIL_REQUEST_GET_IMEISV: ret = responseString(p); break; case RIL_REQUEST_ANSWER: ret = responseVoid(p); break; - case RIL_REQUEST_DEACTIVATE_DEFAULT_PDP: ret = responseVoid(p); break; + case RIL_REQUEST_DEACTIVATE_DATA_CALL: ret = responseVoid(p); break; case RIL_REQUEST_QUERY_FACILITY_LOCK: ret = responseInts(p); break; case RIL_REQUEST_SET_FACILITY_LOCK: ret = responseVoid(p); break; case RIL_REQUEST_CHANGE_BARRING_PASSWORD: ret = responseVoid(p); break; @@ -1822,39 +1988,61 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_REQUEST_DTMF_STOP: ret = responseVoid(p); break; case RIL_REQUEST_BASEBAND_VERSION: ret = responseString(p); break; case RIL_REQUEST_SEPARATE_CONNECTION: ret = responseVoid(p); break; - case RIL_REQUEST_SET_MUTE: ret =responseVoid(p); break; - case RIL_REQUEST_GET_MUTE: ret = responseInts(p); break; - case RIL_REQUEST_QUERY_CLIP: ret = responseInts(p); break; - case RIL_REQUEST_LAST_PDP_FAIL_CAUSE: ret = responseInts(p); break; - case RIL_REQUEST_PDP_CONTEXT_LIST: ret = responseContextList(p); break; - case RIL_REQUEST_RESET_RADIO: ret = responseVoid(p); break; - case RIL_REQUEST_OEM_HOOK_RAW: ret = responseRaw(p); break; - case RIL_REQUEST_OEM_HOOK_STRINGS: ret = responseStrings(p); break; + case RIL_REQUEST_SET_MUTE: ret = responseVoid(p); break; + case RIL_REQUEST_GET_MUTE: ret = responseInts(p); break; + case RIL_REQUEST_QUERY_CLIP: ret = responseInts(p); break; + case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: ret = responseInts(p); break; + case RIL_REQUEST_DATA_CALL_LIST: ret = responseDataCallList(p); break; + case RIL_REQUEST_RESET_RADIO: ret = responseVoid(p); break; + case RIL_REQUEST_OEM_HOOK_RAW: ret = responseRaw(p); break; + case RIL_REQUEST_OEM_HOOK_STRINGS: ret = responseStrings(p); break; case RIL_REQUEST_SCREEN_STATE: ret = responseVoid(p); break; - case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: ret = responseVoid(p); break; - case RIL_REQUEST_WRITE_SMS_TO_SIM: ret = responseInts(p); break; - case RIL_REQUEST_DELETE_SMS_ON_SIM: ret = responseVoid(p); break; - case RIL_REQUEST_SET_BAND_MODE: ret = responseVoid(p); break; - case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: ret = responseInts(p); break; - case RIL_REQUEST_STK_GET_PROFILE: ret = responseString(p); break; - case RIL_REQUEST_STK_SET_PROFILE: ret = responseVoid(p); break; - case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: ret = responseString(p); break; - case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: ret = responseVoid(p); break; - case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: ret = responseInts(p); break; - case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: ret = responseVoid(p); break; - case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: ret = responseVoid(p); break; - case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: ret = responseInts(p); break; + case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: ret = responseVoid(p); break; + case RIL_REQUEST_WRITE_SMS_TO_SIM: ret = responseInts(p); break; + case RIL_REQUEST_DELETE_SMS_ON_SIM: ret = responseVoid(p); break; + case RIL_REQUEST_SET_BAND_MODE: ret = responseVoid(p); break; + case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: ret = responseInts(p); break; + case RIL_REQUEST_STK_GET_PROFILE: ret = responseString(p); break; + case RIL_REQUEST_STK_SET_PROFILE: ret = responseVoid(p); break; + case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: ret = responseString(p); break; + case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE: ret = responseVoid(p); break; + case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM: ret = responseInts(p); break; + case RIL_REQUEST_EXPLICIT_CALL_TRANSFER: ret = responseVoid(p); break; + case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: ret = responseVoid(p); break; + case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: ret = responseInts(p); break; case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: ret = responseCellList(p); break; - case RIL_REQUEST_SET_LOCATION_UPDATES: ret = responseVoid(p); break; - + case RIL_REQUEST_SET_LOCATION_UPDATES: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_SET_SUBSCRIPTION: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE: ret = responseInts(p); break; + case RIL_REQUEST_SET_TTY_MODE: ret = responseVoid(p); break; + case RIL_REQUEST_QUERY_TTY_MODE: ret = responseInts(p); break; + case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE: ret = responseInts(p); break; + case RIL_REQUEST_CDMA_FLASH: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_BURST_DTMF: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_SEND_SMS: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE: ret = responseVoid(p); break; + case RIL_REQUEST_GET_BROADCAST_CONFIG: ret = responseBR_SMS_CNF(p); break; + case RIL_REQUEST_SET_BROADCAST_CONFIG: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG: ret = responseCDMA_BR_CNF(p); break; + case RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG: ret = responseVoid(p); break; + case RIL_REQUEST_BROADCAST_ACTIVATION: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_VALIDATE_AKEY: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_BROADCAST_ACTIVATION: ret = responseVoid(p); break; + case RIL_REQUEST_CDMA_SUBSCRIPTION: ret = responseStrings(p); break; + case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: ret = responseInts(p); break; + case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: ret = responseVoid(p); break; + case RIL_REQUEST_DEVICE_IDENTITY: ret = responseStrings(p); break; default: - throw new RuntimeException("Unrecognized solicited response: " + rr.mRequest); + throw new RuntimeException("Unrecognized solicited response: " + rr.mRequest); //break; }} catch (Throwable tr) { // Exceptions here usually mean invalid RIL responses - - Log.w(LOG_TAG, rr.serialString() + "< " - + requestToString(rr.mRequest) + " exception, possible invalid RIL response", tr); + + Log.w(LOG_TAG, rr.serialString() + "< " + + requestToString(rr.mRequest) + + " exception, possible invalid RIL response", tr); if (rr.mResult != null) { AsyncResult.forMessage(rr.mResult, null, tr); @@ -1866,18 +2054,17 @@ public final class RIL extends BaseCommands implements CommandsInterface if (RILJ_LOGD) riljLog(rr.serialString() + "< " + requestToString(rr.mRequest) + " " + retToString(rr.mRequest, ret)); - + if (rr.mResult != null) { AsyncResult.forMessage(rr.mResult, ret, null); rr.mResult.sendToTarget(); } - + rr.release(); } private String - retToString(int req, Object ret) - { + retToString(int req, Object ret) { if (ret == null) return ""; switch (req) { // Don't log these return values, for privacy's sake. @@ -1938,8 +2125,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } private void - processUnsolicited (Parcel p) - { + processUnsolicited (Parcel p) { int response; Object ret; @@ -1961,7 +2147,7 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_UNSOL_ON_USSD: ret = responseStrings(p); break; case RIL_UNSOL_NITZ_TIME_RECEIVED: ret = responseString(p); break; case RIL_UNSOL_SIGNAL_STRENGTH: ret = responseInts(p); break; - case RIL_UNSOL_PDP_CONTEXT_LIST_CHANGED: ret = responseContextList(p);break; + case RIL_UNSOL_DATA_CALL_LIST_CHANGED: ret = responseDataCallList(p);break; case RIL_UNSOL_SUPP_SVC_NOTIFICATION: ret = responseSuppServiceNotification(p); break; case RIL_UNSOL_STK_SESSION_END: ret = responseVoid(p); break; case RIL_UNSOL_STK_PROACTIVE_COMMAND: ret = responseString(p); break; @@ -1971,8 +2157,12 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_UNSOL_SIM_REFRESH: ret = responseInts(p); break; case RIL_UNSOL_CALL_RING: ret = responseVoid(p); break; case RIL_UNSOL_RESTRICTED_STATE_CHANGED: ret = responseInts(p); break; - default: - throw new RuntimeException("Unrecognized unsol response: " + response); + case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: ret = responseVoid(p); break; + case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: ret = responseCdmaSms(p); break; + case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: ret = responseString(p); break; + case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: ret = responseVoid(p); break; + default: + throw new RuntimeException("Unrecognized unsol response: " + response); //break; (implied) }} catch (Throwable tr) { Log.e(LOG_TAG, "Exception processing unsol response: " + response + @@ -1984,7 +2174,7 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: /* has bonus radio state int */ setRadioStateFromRILInt(p.readInt()); - + if (RILJ_LOGD) unsljLogMore(response, mState.toString()); break; case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: @@ -2009,7 +2199,7 @@ public final class RIL extends BaseCommands implements CommandsInterface SmsMessage sms; - sms = SmsMessage.newFromCMT(a); + sms = SmsMessage.newFromCMT(a); if (mSMSRegistrant != null) { mSMSRegistrant .notifyRegistrant(new AsyncResult(null, sms, null)); @@ -2041,7 +2231,7 @@ public final class RIL extends BaseCommands implements CommandsInterface break; case RIL_UNSOL_ON_USSD: String[] resp = (String[])ret; - + if (resp.length < 2) { resp = new String[2]; resp[0] = ((String[])ret)[0]; @@ -2053,7 +2243,7 @@ public final class RIL extends BaseCommands implements CommandsInterface new AsyncResult (null, resp, null)); } break; - case RIL_UNSOL_NITZ_TIME_RECEIVED: + case RIL_UNSOL_NITZ_TIME_RECEIVED: if (RILJ_LOGD) unsljLogRet(response, ret); // has bonus long containing milliseconds since boot that the NITZ @@ -2066,7 +2256,7 @@ public final class RIL extends BaseCommands implements CommandsInterface result[1] = Long.valueOf(nitzReceiveTime); if (mNITZTimeRegistrant != null) { - + mNITZTimeRegistrant .notifyRegistrant(new AsyncResult (null, result, null)); } else { @@ -2074,22 +2264,21 @@ public final class RIL extends BaseCommands implements CommandsInterface mLastNITZTimeInfo = result; } break; - + case RIL_UNSOL_SIGNAL_STRENGTH: // Note this is set to "verbose" because it happens // frequently if (RILJ_LOGV) unsljLogvRet(response, ret); - + if (mSignalStrengthRegistrant != null) { mSignalStrengthRegistrant.notifyRegistrant( new AsyncResult (null, ret, null)); } break; - case RIL_UNSOL_PDP_CONTEXT_LIST_CHANGED: + case RIL_UNSOL_DATA_CALL_LIST_CHANGED: if (RILJ_LOGD) unsljLogRet(response, ret); - mPDPRegistrants - .notifyRegistrants(new AsyncResult(null, ret, null)); + mDataConnectionRegistrants.notifyRegistrants(new AsyncResult(null, ret, null)); break; case RIL_UNSOL_SUPP_SVC_NOTIFICATION: @@ -2140,21 +2329,21 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_UNSOL_SIM_SMS_STORAGE_FULL: if (RILJ_LOGD) unsljLog(response); - if (mSimSmsFullRegistrant != null) { - mSimSmsFullRegistrant.notifyRegistrant(); + if (mIccSmsFullRegistrant != null) { + mIccSmsFullRegistrant.notifyRegistrant(); } break; - case RIL_UNSOL_SIM_REFRESH: + case RIL_UNSOL_SIM_REFRESH: if (RILJ_LOGD) unsljLogRet(response, ret); - if (mSimRefreshRegistrant != null) { - mSimRefreshRegistrant.notifyRegistrant( + if (mIccRefreshRegistrant != null) { + mIccRefreshRegistrant.notifyRegistrant( new AsyncResult (null, ret, null)); } break; - - case RIL_UNSOL_CALL_RING: + + case RIL_UNSOL_CALL_RING: if (RILJ_LOGD) unsljLog(response); if (mRingRegistrant != null) { @@ -2168,12 +2357,40 @@ public final class RIL extends BaseCommands implements CommandsInterface mRestrictedStateRegistrant.notifyRegistrant( new AsyncResult (null, ret, null)); } + + case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: + if (mIccStatusChangedRegistrants != null) { + mIccStatusChangedRegistrants.notifyRegistrants(); + } + break; + + case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: + SmsMessage sms = (SmsMessage) ret; + + if (mSMSRegistrant != null) { + mSMSRegistrant + .notifyRegistrant(new AsyncResult(null, sms, null)); + } + break; + + case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: + // TODO T: waiting for SMS BC feature + break; + + case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: + if (Config.LOGD) { + if (RILJ_LOGD) riljLog("[UNSL]< RUIM_SMS_STORAGE_FULL"); + } + + if (mIccSmsFullRegistrant != null) { + mIccSmsFullRegistrant.notifyRegistrant(); + } + break; } } private Object - responseInts(Parcel p) - { + responseInts(Parcel p) { int numInts; int response[]; @@ -2190,14 +2407,12 @@ public final class RIL extends BaseCommands implements CommandsInterface private Object - responseVoid(Parcel p) - { + responseVoid(Parcel p) { return null; } private Object - responseCallForward(Parcel p) - { + responseCallForward(Parcel p) { int numInfos; CallForwardInfo infos[]; @@ -2220,22 +2435,28 @@ public final class RIL extends BaseCommands implements CommandsInterface } private Object - responseSuppServiceNotification(Parcel p) - { + responseSuppServiceNotification(Parcel p) { SuppServiceNotification notification = new SuppServiceNotification(); - + notification.notificationType = p.readInt(); notification.code = p.readInt(); notification.index = p.readInt(); notification.type = p.readInt(); notification.number = p.readString(); - + return notification; } - + private Object - responseString(Parcel p) - { + responseCdmaSms(Parcel p) { + SmsMessage sms; + sms = SmsMessage.newFromParcel(p); + + return sms; + } + + private Object + responseString(Parcel p) { String response; response = p.readString(); @@ -2244,8 +2465,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } private Object - responseStrings(Parcel p) - { + responseStrings(Parcel p) { int num; String response[]; @@ -2259,13 +2479,12 @@ public final class RIL extends BaseCommands implements CommandsInterface response[i] = p.readString(); } } - + return response; } private Object - responseRaw(Parcel p) - { + responseRaw(Parcel p) { int num; byte response[]; @@ -2275,8 +2494,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } private Object - responseSMS(Parcel p) - { + responseSMS(Parcel p) { int messageRef; String ackPDU; @@ -2290,46 +2508,110 @@ public final class RIL extends BaseCommands implements CommandsInterface private Object - responseSIM_IO(Parcel p) - { + responseICC_IO(Parcel p) { int sw1, sw2; byte data[] = null; Message ret; - + sw1 = p.readInt(); sw2 = p.readInt(); String s = p.readString(); - return new SimIoResult(sw1, sw2, s); + return new IccIoResult(sw1, sw2, s); } private Object - responseSimStatus(Parcel p) - { - int status; - - status = ((int[])responseInts(p))[0]; - switch (status){ - case RIL_SIM_ABSENT: return SimStatus.SIM_ABSENT; - case RIL_SIM_NOT_READY: return SimStatus.SIM_NOT_READY; - case RIL_SIM_READY: return SimStatus.SIM_READY; - case RIL_SIM_PIN: return SimStatus.SIM_PIN; - case RIL_SIM_PUK: return SimStatus.SIM_PUK; - case RIL_SIM_NETWORK_PERSONALIZATION: - return SimStatus.SIM_NETWORK_PERSONALIZATION; - default: - // Unrecognized SIM status. Treat it like a missing SIM. - Log.e(LOG_TAG, "Unrecognized RIL_REQUEST_GET_SIM_STATUS result: " + status); - return SimStatus.SIM_ABSENT; + responseIccCardStatus(Parcel p) { + RadioState currentRadioState; + IccCardApplication ca; + + currentRadioState = getRadioState(); + + IccCardStatus status = new IccCardStatus(); + status.card_state = status.CardStateFromRILInt(p.readInt()); + status.universal_pin_state = status.PinStateFromRILInt(p.readInt()); + status.gsm_umts_subscription_app_index = p.readInt(); + status.cdma_subscription_app_index = p.readInt(); + status.num_applications = p.readInt(); + + // limit to maximum allowed applications + if (status.num_applications > IccCardStatus.CARD_MAX_APPS) { + status.num_applications = IccCardStatus.CARD_MAX_APPS; } - } + for (int i = 0 ; i < status.num_applications ; i++) { + ca = new IccCardApplication(); + ca.app_type = ca.AppTypeFromRILInt(p.readInt()); + ca.app_state = ca.AppStateFromRILInt(p.readInt()); + ca.perso_substate = ca.PersoSubstateFromRILInt(p.readInt()); + ca.aid = p.readString(); + ca.app_label = p.readString(); + ca.pin1_replaced = p.readInt(); + ca.pin1 = p.readInt(); + ca.pin2 = p.readInt(); + status.application.add(ca); + } + + // this is common for all radio technologies + if (!status.card_state.isCardPresent()) { + return IccStatus.ICC_ABSENT; + } + + // check radio technology + if( currentRadioState == RadioState.RADIO_OFF || + currentRadioState == RadioState.RADIO_UNAVAILABLE || + currentRadioState == RadioState.SIM_NOT_READY || + currentRadioState == RadioState.RUIM_NOT_READY || + currentRadioState == RadioState.NV_NOT_READY || + currentRadioState == RadioState.NV_READY ) { + return IccStatus.ICC_NOT_READY; + } + + if( currentRadioState == RadioState.SIM_LOCKED_OR_ABSENT || + currentRadioState == RadioState.SIM_READY || + currentRadioState == RadioState.RUIM_LOCKED_OR_ABSENT || + currentRadioState == RadioState.RUIM_READY) { + + int index; + + // check for CDMA radio technology + if (currentRadioState == RadioState.RUIM_LOCKED_OR_ABSENT || + currentRadioState == RadioState.RUIM_READY) { + index = status.cdma_subscription_app_index; + } + else { + index = status.gsm_umts_subscription_app_index; + } + + // check if PIN required + if (status.application.get(index).app_state.isPinRequired()) { + return IccStatus.ICC_PIN; + } + if (status.application.get(index).app_state.isPukRequired()) { + return IccStatus.ICC_PUK; + } + if (status.application.get(index).app_state.isSubscriptionPersoEnabled()) { + return IccStatus.ICC_NETWORK_PERSONALIZATION; + } + if (status.application.get(index).app_state.isAppReady()) { + return IccStatus.ICC_READY; + } + if (status.application.get(index).app_state.isAppNotReady()) { + return IccStatus.ICC_NOT_READY; + } + return IccStatus.ICC_NOT_READY; + } + + // Unrecognized ICC status. Treat it like a missing ICC. + Log.e(LOG_TAG, "Unrecognized RIL_REQUEST_GET_SIM_STATUS result: " + status); + return IccStatus.ICC_ABSENT; + } private Object - responseCallList(Parcel p) - { + responseCallList(Parcel p) { int num; + int voiceSettings; ArrayList<DriverCall> response; DriverCall dc; @@ -2338,17 +2620,18 @@ public final class RIL extends BaseCommands implements CommandsInterface for (int i = 0 ; i < num ; i++) { dc = new DriverCall(); - + dc.state = DriverCall.stateFromCLCC(p.readInt()); dc.index = p.readInt(); dc.TOA = p.readInt(); dc.isMpty = (0 != p.readInt()); dc.isMT = (0 != p.readInt()); dc.als = p.readInt(); - dc.isVoice = (0 == p.readInt()) ? false : true; + voiceSettings = p.readInt(); + dc.isVoice = (0 == voiceSettings) ? false : true; dc.number = p.readString(); dc.numberPresentation = DriverCall.presentationFromCLIP(p.readInt()); - + // Make sure there's a leading + on addresses with a TOA // of 145 @@ -2356,6 +2639,16 @@ public final class RIL extends BaseCommands implements CommandsInterface dc.number, dc.TOA); response.add(dc); + + if ( RILConstants.CDMA_VOICE_PRIVACY == voiceSettings ) { + mVoicePrivacyOnRegistrants.notifyRegistrants(); + Log.d(LOG_TAG, "InCall VoicePrivacy is enabled: " + + Integer.toString(voiceSettings)); + } else { + mVoicePrivacyOffRegistrants.notifyRegistrants(); + Log.d(LOG_TAG, "InCall VoicePrivacy is disabled: " + + Integer.toString(voiceSettings)); + } } Collections.sort(response); @@ -2364,8 +2657,7 @@ public final class RIL extends BaseCommands implements CommandsInterface } private Object - responseContextList(Parcel p) - { + responseDataCallList(Parcel p) { int num; ArrayList<PDPContextState> response; @@ -2388,14 +2680,13 @@ public final class RIL extends BaseCommands implements CommandsInterface } private Object - responseNetworkInfos(Parcel p) - { + responseNetworkInfos(Parcel p) { String strings[] = (String [])responseStrings(p); ArrayList<NetworkInfo> ret; if (strings.length % 4 != 0) { throw new RuntimeException( - "RIL_REQUEST_QUERY_AVAILABLE_NETWORKS: invalid response. Got " + "RIL_REQUEST_QUERY_AVAILABLE_NETWORKS: invalid response. Got " + strings.length + " strings, expected multible of 4"); } @@ -2409,37 +2700,57 @@ public final class RIL extends BaseCommands implements CommandsInterface strings[i+2], strings[i+3])); } - + return ret; } + private Object + responseCellList(Parcel p) { + int num; + ArrayList<NeighboringCellInfo> response; + NeighboringCellInfo cell; + + num = p.readInt(); + response = new ArrayList<NeighboringCellInfo>(num); + + for (int i = 0 ; i < num ; i++) { + try { + int rssi = p.readInt(); + int cid = Integer.valueOf(p.readString(), 16); + cell = new NeighboringCellInfo(rssi, cid); + response.add(cell); + } catch ( Exception e) { + } + } + + return response; + } + private Object - responseCellList(Parcel p) - { - int num; - ArrayList<NeighboringCellInfo> response; - NeighboringCellInfo cell; + responseBR_SMS_CNF(Parcel p) { + // TODO + return null; + } - num = p.readInt(); - response = new ArrayList<NeighboringCellInfo>(num); + private Object + responseCDMA_BR_CNF(Parcel p) { + int numInts; + int response[]; - for (int i = 0 ; i < num ; i++) { - try { - int rssi = p.readInt(); - int cid = Integer.valueOf(p.readString(), 16); - cell = new NeighboringCellInfo(rssi, cid); - response.add(cell); - } catch ( Exception e) { - } + numInts = p.readInt(); + + response = new int[numInts]; + + response[0] = numInts; + for (int i = 1 ; i < numInts; i++) { + response[i] = p.readInt(); } return response; } - static String - requestToString(int request) - { + requestToString(int request) { /* cat libs/telephony/ril_commands.h \ | egrep "^ *{RIL_" \ @@ -2472,7 +2783,7 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_REQUEST_DTMF: return "DTMF"; case RIL_REQUEST_SEND_SMS: return "SEND_SMS"; case RIL_REQUEST_SEND_SMS_EXPECT_MORE: return "SEND_SMS_EXPECT_MORE"; - case RIL_REQUEST_SETUP_DEFAULT_PDP: return "SETUP_DEFAULT_PDP"; + case RIL_REQUEST_SETUP_DATA_CALL: return "SETUP_DATA_CALL"; case RIL_REQUEST_SIM_IO: return "SIM_IO"; case RIL_REQUEST_SEND_USSD: return "SEND_USSD"; case RIL_REQUEST_CANCEL_USSD: return "CANCEL_USSD"; @@ -2486,7 +2797,7 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_REQUEST_GET_IMEI: return "GET_IMEI"; case RIL_REQUEST_GET_IMEISV: return "GET_IMEISV"; case RIL_REQUEST_ANSWER: return "ANSWER"; - case RIL_REQUEST_DEACTIVATE_DEFAULT_PDP: return "DEACTIVATE_DEFAULT_PDP"; + case RIL_REQUEST_DEACTIVATE_DATA_CALL: return "DEACTIVATE_DATA_CALL"; case RIL_REQUEST_QUERY_FACILITY_LOCK: return "QUERY_FACILITY_LOCK"; case RIL_REQUEST_SET_FACILITY_LOCK: return "SET_FACILITY_LOCK"; case RIL_REQUEST_CHANGE_BARRING_PASSWORD: return "CHANGE_BARRING_PASSWORD"; @@ -2501,8 +2812,8 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_REQUEST_SET_MUTE: return "SET_MUTE"; case RIL_REQUEST_GET_MUTE: return "GET_MUTE"; case RIL_REQUEST_QUERY_CLIP: return "QUERY_CLIP"; - case RIL_REQUEST_LAST_PDP_FAIL_CAUSE: return "LAST_PDP_FAIL_CAUSE"; - case RIL_REQUEST_PDP_CONTEXT_LIST: return "PDP_CONTEXT_LIST"; + case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE: return "LAST_DATA_CALL_FAIL_CAUSE"; + case RIL_REQUEST_DATA_CALL_LIST: return "DATA_CALL_LIST"; case RIL_REQUEST_RESET_RADIO: return "RESET_RADIO"; case RIL_REQUEST_OEM_HOOK_RAW: return "OEM_HOOK_RAW"; case RIL_REQUEST_OEM_HOOK_STRINGS: return "OEM_HOOK_STRINGS"; @@ -2522,6 +2833,28 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: return "REQUEST_GET_PREFERRED_NETWORK_TYPE"; case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: return "REQUEST_GET_NEIGHBORING_CELL_IDS"; case RIL_REQUEST_SET_LOCATION_UPDATES: return "REQUEST_SET_LOCATION_UPDATES"; + case RIL_REQUEST_CDMA_SET_SUBSCRIPTION: return "RIL_REQUEST_CDMA_SET_SUBSCRIPTION"; + case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: return "RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE"; + case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE: return "RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE"; + case RIL_REQUEST_SET_TTY_MODE: return "RIL_REQUEST_SET_TTY_MODE"; + case RIL_REQUEST_QUERY_TTY_MODE: return "RIL_REQUEST_QUERY_TTY_MODE"; + case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: return "RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE"; + case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE: return "RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE"; + case RIL_REQUEST_CDMA_FLASH: return "RIL_REQUEST_CDMA_FLASH"; + case RIL_REQUEST_CDMA_BURST_DTMF: return "RIL_REQUEST_CDMA_BURST_DTMF"; + case RIL_REQUEST_CDMA_SEND_SMS: return "RIL_REQUEST_CDMA_SEND_SMS"; + case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE: return "RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE"; + case RIL_REQUEST_GET_BROADCAST_CONFIG: return "RIL_REQUEST_GET_BROADCAST_CONFIG"; + case RIL_REQUEST_SET_BROADCAST_CONFIG: return "RIL_REQUEST_SET_BROADCAST_CONFIG"; + case RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG: return "RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG"; + case RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG: return "RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG"; + case RIL_REQUEST_BROADCAST_ACTIVATION: return "RIL_REQUEST_BROADCAST_ACTIVATION"; + case RIL_REQUEST_CDMA_VALIDATE_AKEY: return "RIL_REQUEST_CDMA_VALIDATE_AKEY"; + case RIL_REQUEST_CDMA_BROADCAST_ACTIVATION: return "RIL_REQUEST_CDMA_BROADCAST_ACTIVATION"; + case RIL_REQUEST_CDMA_SUBSCRIPTION: return "RIL_REQUEST_CDMA_SUBSCRIPTION"; + case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM: return "RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM"; + case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM: return "RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM"; + case RIL_REQUEST_DEVICE_IDENTITY: return "RIL_REQUEST_DEVICE_IDENTITY"; default: return "<unknown request>"; } } @@ -2545,7 +2878,7 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST"; case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED"; case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH"; - case RIL_UNSOL_PDP_CONTEXT_LIST_CHANGED: return "UNSOL_PDP_CONTEXT_LIST_CHANGED"; + case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED"; case RIL_UNSOL_SUPP_SVC_NOTIFICATION: return "UNSOL_SUPP_SVC_NOTIFICATION"; case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END"; case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND"; @@ -2554,7 +2887,7 @@ public final class RIL extends BaseCommands implements CommandsInterface case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FULL"; case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH"; case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING"; - case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "RIL_UNSOL_RESTRICTED_STATE_CHANGED"; + case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "RIL_UNSOL_RESTRICTED_STATE_CHANGED"; default: return "<unknown reponse>"; } } @@ -2583,4 +2916,135 @@ public final class RIL extends BaseCommands implements CommandsInterface riljLogv("[UNSL]< " + responseToString(response) + " " + retToString(response, ret)); } + + // ***** Methods for CDMA support + public void + getDeviceIdentity(Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_DEVICE_IDENTITY, response); + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); + + send(rr); + } + + public void + getCDMASubscription(Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_SUBSCRIPTION, response); + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); + + send(rr); + } + + public void setPhoneType(int phoneType) { //Set by CDMAPhone and GSMPhone constructor + mPhoneType = phoneType; + } + + /** + * {@inheritDoc} + */ + public void queryCdmaRoamingPreference(Message response) { + RILRequest rr = RILRequest.obtain( + RILConstants.RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE, response); + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); + + send(rr); + } + + /** + * {@inheritDoc} + */ + public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) { + RILRequest rr = RILRequest.obtain( + RILConstants.RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE, response); + + rr.mp.writeInt(1); + rr.mp.writeInt(cdmaRoamingType); + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + + " : " + cdmaRoamingType); + + send(rr); + } + + /** + * {@inheritDoc} + */ + public void setCdmaSubscription(int cdmaSubscription , Message response) { + RILRequest rr = RILRequest.obtain( + RILConstants.RIL_REQUEST_CDMA_SET_SUBSCRIPTION, response); + + rr.mp.writeInt(1); + rr.mp.writeInt(cdmaSubscription); + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + + " : " + cdmaSubscription); + + send(rr); + } + + /** + * {@inheritDoc} + */ + public void queryTTYModeEnabled(Message response) { + RILRequest rr = RILRequest.obtain( + RILConstants.RIL_REQUEST_QUERY_TTY_MODE, response); + + send(rr); + } + + /** + * {@inheritDoc} + */ + public void setTTYModeEnabled(boolean enable, Message response) { + RILRequest rr = RILRequest.obtain( + RILConstants.RIL_REQUEST_SET_TTY_MODE, response); + + rr.mp.writeInt(1); + rr.mp.writeInt(enable ? 1 : 0); + + send(rr); + } + + /** + * {@inheritDoc} + */ + public void + sendCDMAFeatureCode(String FeatureCode, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_FLASH, response); + + rr.mp.writeInt(1); + rr.mp.writeString(FeatureCode); + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + + " : " + FeatureCode); + + send(rr); + } + + public void getCdmaBroadcastConfig(Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG, response); + + send(rr); + } + + public void setCdmaBroadcastConfig(int[] configValuesArray, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG, response); + + for(int i = 0; i < configValuesArray.length; i++) { + rr.mp.writeInt(configValuesArray[i]); + } + + send(rr); + } + + public void activateCdmaBroadcastSms(int activate, Message response) { + RILRequest rr = RILRequest.obtain(RIL_REQUEST_CDMA_BROADCAST_ACTIVATION, response); + + rr.mp.writeInt(1); + rr.mp.writeInt(activate); + + send(rr); + } } diff --git a/telephony/java/com/android/internal/telephony/gsm/RILConstants.java b/telephony/java/com/android/internal/telephony/RILConstants.java index 4463b20..ba3b754 100644 --- a/telephony/java/com/android/internal/telephony/gsm/RILConstants.java +++ b/telephony/java/com/android/internal/telephony/RILConstants.java @@ -14,29 +14,62 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; /** * {@hide} */ -interface RILConstants -{ +public interface RILConstants { // From the top of ril.cpp int RIL_ERRNO_INVALID_RESPONSE = -1; // from RIL_Errno int SUCCESS = 0; - int RADIO_NOT_AVAILABLE = 1; /* If radio did not start or is resetting */ + int RADIO_NOT_AVAILABLE = 1; /* If radio did not start or is resetting */ int GENERIC_FAILURE = 2; - int PASSWORD_INCORRECT = 3; /* for PIN/PIN2 methods only! */ - int SIM_PIN2 = 4; /* Operation requires SIM PIN2 to be entered */ - int SIM_PUK2 = 5; /* Operation requires SIM PIN2 to be entered */ + int PASSWORD_INCORRECT = 3; /* for PIN/PIN2 methods only! */ + int SIM_PIN2 = 4; /* Operation requires SIM PIN2 to be entered */ + int SIM_PUK2 = 5; /* Operation requires SIM PIN2 to be entered */ int REQUEST_NOT_SUPPORTED = 6; int REQUEST_CANCELLED = 7; - int OP_NOT_ALLOWED_DURING_VOICE_CALL = 8; /* data operation is not allowed during voice call in class C */ - int OP_NOT_ALLOWED_BEFORE_REG_NW = 9; /* request is not allowed before device registers to network */ - int SMS_SEND_FAIL_RETRY = 10; /* send sms fail and need retry */ + int OP_NOT_ALLOWED_DURING_VOICE_CALL = 8; /* data operation is not allowed during voice call in + class C */ + int OP_NOT_ALLOWED_BEFORE_REG_NW = 9; /* request is not allowed before device registers to + network */ + int SMS_SEND_FAIL_RETRY = 10; /* send sms fail and need retry */ + + /* NETWORK_MODE_* See ril.h RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE */ + int NETWORK_MODE_WCDMA_PREF = 0; /* GSM/WCDMA (WCDMA preferred) */ + int NETWORK_MODE_GSM_ONLY = 1; /* GSM only */ + int NETWORK_MODE_WCDMA_ONLY = 2; /* WCDMA only */ + int NETWORK_MODE_GSM_UMTS = 3; /* GSM/WCDMA (auto mode, according to PRL) + AVAILABLE Application Settings menu*/ + int NETWORK_MODE_CDMA = 4; /* CDMA and EvDo (auto mode, according to PRL) + AVAILABLE Application Settings menu*/ + int NETWORK_MODE_CDMA_NO_EVDO = 5; /* CDMA only */ + int NETWORK_MODE_EVDO_NO_CDMA = 6; /* EvDo only */ + int NETWORK_MODE_GLOBAL = 7; /* GSM/WCDMA, CDMA, and EvDo (auto mode, according to PRL) + AVAILABLE Application Settings menu*/ + int PREFERRED_NETWORK_MODE = NETWORK_MODE_GLOBAL; + + /* CDMA subscription source. See ril.h RIL_REQUEST_CDMA_SET_SUBSCRIPTION */ + int SUBSCRIPTION_FROM_RUIM = 0; /* CDMA subscription from RUIM when available */ + int SUBSCRIPTION_FROM_NV = 1; /* CDMA subscription from NV */ + int PREFERRED_CDMA_SUBSCRIPTION = SUBSCRIPTION_FROM_NV; + + int CDMA_CELL_BROADCAST_SMS_DISABLED = 1; + int CDMA_CELL_BROADCAST_SMS_ENABLED = 0; + + int CDMA_PHONE = 0; + int GSM_PHONE = 1; + + int CDM_TTY_MODE_DISABLED = 0; + int CDM_TTY_MODE_ENABLED = 1; + + byte CDMA_VOICE_PRIVACY = 0x70; /* "p" value used in Ril_Call.isVoice if Privacy + is active */ + /* cat include/telephony/ril.h | \ egrep '^#define' | \ @@ -76,7 +109,7 @@ cat include/telephony/ril.h | \ * Block packet data access due to restriction. */ int RIL_RESTRICTED_STATE_PS_ALL = 0x10; - + int RIL_REQUEST_GET_SIM_STATUS = 1; int RIL_REQUEST_ENTER_SIM_PIN = 2; int RIL_REQUEST_ENTER_SIM_PUK = 3; @@ -103,7 +136,7 @@ cat include/telephony/ril.h | \ int RIL_REQUEST_DTMF = 24; int RIL_REQUEST_SEND_SMS = 25; int RIL_REQUEST_SEND_SMS_EXPECT_MORE = 26; - int RIL_REQUEST_SETUP_DEFAULT_PDP = 27; + int RIL_REQUEST_SETUP_DATA_CALL = 27; int RIL_REQUEST_SIM_IO = 28; int RIL_REQUEST_SEND_USSD = 29; int RIL_REQUEST_CANCEL_USSD = 30; @@ -117,7 +150,7 @@ cat include/telephony/ril.h | \ int RIL_REQUEST_GET_IMEI = 38; int RIL_REQUEST_GET_IMEISV = 39; int RIL_REQUEST_ANSWER = 40; - int RIL_REQUEST_DEACTIVATE_DEFAULT_PDP = 41; + int RIL_REQUEST_DEACTIVATE_DATA_CALL = 41; int RIL_REQUEST_QUERY_FACILITY_LOCK = 42; int RIL_REQUEST_SET_FACILITY_LOCK = 43; int RIL_REQUEST_CHANGE_BARRING_PASSWORD = 44; @@ -132,8 +165,8 @@ cat include/telephony/ril.h | \ int RIL_REQUEST_SET_MUTE = 53; int RIL_REQUEST_GET_MUTE = 54; int RIL_REQUEST_QUERY_CLIP = 55; - int RIL_REQUEST_LAST_PDP_FAIL_CAUSE = 56; - int RIL_REQUEST_PDP_CONTEXT_LIST = 57; + int RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE = 56; + int RIL_REQUEST_DATA_CALL_LIST = 57; int RIL_REQUEST_RESET_RADIO = 58; int RIL_REQUEST_OEM_HOOK_RAW = 59; int RIL_REQUEST_OEM_HOOK_STRINGS = 60; @@ -153,6 +186,28 @@ cat include/telephony/ril.h | \ int RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE = 74; int RIL_REQUEST_GET_NEIGHBORING_CELL_IDS = 75; int RIL_REQUEST_SET_LOCATION_UPDATES = 76; + int RIL_REQUEST_CDMA_SET_SUBSCRIPTION = 77; + int RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE = 78; + int RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE = 79; + int RIL_REQUEST_SET_TTY_MODE = 80; + int RIL_REQUEST_QUERY_TTY_MODE = 81; + int RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE = 82; + int RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE = 83; + int RIL_REQUEST_CDMA_FLASH = 84; + int RIL_REQUEST_CDMA_BURST_DTMF = 85; + int RIL_REQUEST_CDMA_VALIDATE_AKEY = 86; + int RIL_REQUEST_CDMA_SEND_SMS = 87; + int RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE = 88; + int RIL_REQUEST_GET_BROADCAST_CONFIG = 89; + int RIL_REQUEST_SET_BROADCAST_CONFIG = 90; + int RIL_REQUEST_BROADCAST_ACTIVATION = 91; + int RIL_REQUEST_CDMA_GET_BROADCAST_CONFIG = 92; + int RIL_REQUEST_CDMA_SET_BROADCAST_CONFIG = 93; + int RIL_REQUEST_CDMA_BROADCAST_ACTIVATION = 94; + int RIL_REQUEST_CDMA_SUBSCRIPTION = 99; + int RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM = 100; + int RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM = 101; + int RIL_REQUEST_DEVICE_IDENTITY = 102; int RIL_UNSOL_RESPONSE_BASE = 1000; int RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED = 1000; int RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED = 1001; @@ -164,7 +219,7 @@ cat include/telephony/ril.h | \ int RIL_UNSOL_ON_USSD_REQUEST = 1007; int RIL_UNSOL_NITZ_TIME_RECEIVED = 1008; int RIL_UNSOL_SIGNAL_STRENGTH = 1009; - int RIL_UNSOL_PDP_CONTEXT_LIST_CHANGED = 1010; + int RIL_UNSOL_DATA_CALL_LIST_CHANGED = 1010; int RIL_UNSOL_SUPP_SVC_NOTIFICATION = 1011; int RIL_UNSOL_STK_SESSION_END = 1012; int RIL_UNSOL_STK_PROACTIVE_COMMAND = 1013; @@ -173,5 +228,9 @@ cat include/telephony/ril.h | \ int RIL_UNSOL_SIM_SMS_STORAGE_FULL = 1016; int RIL_UNSOL_SIM_REFRESH = 1017; int RIL_UNSOL_CALL_RING = 1018; + int RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED = 1019; + int RIL_UNSOL_RESPONSE_CDMA_NEW_SMS = 1020; + int RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS = 1021; + int RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL = 1022; int RIL_UNSOL_RESTRICTED_STATE_CHANGED = 1023; } diff --git a/telephony/java/com/android/internal/telephony/gsm/SMSDispatcher.java b/telephony/java/com/android/internal/telephony/SMSDispatcher.java index 5585524..f2bd361 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SMSDispatcher.java +++ b/telephony/java/com/android/internal/telephony/SMSDispatcher.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; import android.app.Activity; import android.app.PendingIntent; @@ -32,19 +32,21 @@ import android.net.Uri; import android.os.AsyncResult; import android.os.Handler; import android.os.Message; -import android.os.PowerManager; import android.provider.Telephony; -import android.provider.Settings; import android.provider.Telephony.Sms.Intents; -import android.telephony.gsm.SmsMessage; -import android.telephony.gsm.SmsManager; -import com.android.internal.telephony.WapPushOverSms; +import android.provider.Settings; +import android.telephony.SmsMessage; import android.telephony.ServiceState; import android.util.Config; -import com.android.internal.util.HexDump; import android.util.Log; import android.view.WindowManager; +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.SmsMessageBase; +import com.android.internal.telephony.SmsResponse; +import com.android.internal.telephony.WapPushOverSms; +import com.android.internal.util.HexDump; + import java.io.ByteArrayOutputStream; import java.util.ArrayList; import java.util.HashMap; @@ -52,58 +54,61 @@ import java.util.Random; import com.android.internal.R; -final class SMSDispatcher extends Handler { - private static final String TAG = "GSM"; +import static android.telephony.SmsManager.RESULT_ERROR_GENERIC_FAILURE; +import static android.telephony.SmsManager.RESULT_ERROR_NO_SERVICE; +import static android.telephony.SmsManager.RESULT_ERROR_NULL_PDU; +import static android.telephony.SmsManager.RESULT_ERROR_RADIO_OFF; + + +public abstract class SMSDispatcher extends Handler { + private static final String TAG = "SMS"; - /** Default checking period for SMS sent without uesr permit */ + /** Default checking period for SMS sent without user permit */ private static final int DEFAULT_SMS_CHECK_PERIOD = 3600000; - /** Default number of SMS sent in checking period without uesr permit */ + /** Default number of SMS sent in checking period without user permit */ private static final int DEFAULT_SMS_MAX_COUNT = 100; /** Default timeout for SMS sent query */ private static final int DEFAULT_SMS_TIMOUEOUT = 6000; - private static final String[] RAW_PROJECTION = new String[] { + protected static final String[] RAW_PROJECTION = new String[] { "pdu", "sequence", }; static final int MAIL_SEND_SMS = 1; - static final int EVENT_NEW_SMS = 1; + static final protected int EVENT_NEW_SMS = 1; - static final int EVENT_SEND_SMS_COMPLETE = 2; + static final protected int EVENT_SEND_SMS_COMPLETE = 2; /** Retry sending a previously failed SMS message */ - static final int EVENT_SEND_RETRY = 3; + static final protected int EVENT_SEND_RETRY = 3; /** Status report received */ - static final int EVENT_NEW_SMS_STATUS_REPORT = 5; + static final protected int EVENT_NEW_SMS_STATUS_REPORT = 5; - /** SIM storage is full */ - static final int EVENT_SIM_FULL = 6; + /** SIM/RUIM storage is full */ + static final protected int EVENT_ICC_FULL = 6; /** SMS confirm required */ - static final int EVENT_POST_ALERT = 7; + static final protected int EVENT_POST_ALERT = 7; /** Send the user confirmed SMS */ - static final int EVENT_SEND_CONFIRMED_SMS = 8; + static final protected int EVENT_SEND_CONFIRMED_SMS = 8; /** Alert is timeout */ - static final int EVENT_ALERT_TIMEOUT = 9; + static final protected int EVENT_ALERT_TIMEOUT = 9; - private final GSMPhone mPhone; + protected Phone mPhone; + protected Context mContext; + protected ContentResolver mResolver; + protected CommandsInterface mCm; - private final WapPushOverSms mWapPush; + protected final WapPushOverSms mWapPush; - private final Context mContext; - - private final ContentResolver mResolver; - - private final CommandsInterface mCm; - - private final Uri mRawUri = Uri.withAppendedPath(Telephony.Sms.CONTENT_URI, "raw"); + protected final Uri mRawUri = Uri.withAppendedPath(Telephony.Sms.CONTENT_URI, "raw"); /** Maximum number of times to retry sending a failed SMS. */ private static final int MAX_SEND_RETRIES = 3; @@ -117,20 +122,15 @@ final class SMSDispatcher extends Handler { * CONCATENATED_16_BIT_REFERENCE message set. Should be * incremented for each set of concatenated messages. */ - private static int sConcatenatedRef; + protected static int sConcatenatedRef; private SmsCounter mCounter; private SmsTracker mSTracker; - /** Wake lock to ensure device stays awake while dispatching the SMS intent. */ - private PowerManager.WakeLock mWakeLock; - - /** - * Hold the wake lock for 5 seconds, which should be enough time for - * any receiver(s) to grab its own wake lock. - */ - private final int WAKE_LOCK_TIMEOUT = 5000; + private static SmsMessage mSmsMessage; + private static SmsMessageBase mSmsMessageBase; + private SmsMessageBase.SubmitPduBase mSubmitPduBase; /** * Implement the per-application based SMS control, which only allows @@ -177,6 +177,7 @@ final class SMSDispatcher extends Handler { while (sent.size() > 0 && (ct - sent.get(0)) > mCheckPeriod ) { sent.remove(0); } + if ( (sent.size() + smsWaiting) <= mMaxAllowed) { for (int i = 0; i < smsWaiting; i++ ) { @@ -188,7 +189,7 @@ final class SMSDispatcher extends Handler { } } - SMSDispatcher(GSMPhone phone) { + protected SMSDispatcher(PhoneBase phone) { mPhone = phone; mWapPush = new WapPushOverSms(phone); mContext = phone.getContext(); @@ -196,8 +197,6 @@ final class SMSDispatcher extends Handler { mCm = phone.mCM; mSTracker = null; - createWakelock(); - int check_period = Settings.Gservices.getInt(mResolver, Settings.Gservices.SMS_OUTGOING_CEHCK_INTERVAL_MS, DEFAULT_SMS_CHECK_PERIOD); @@ -208,19 +207,30 @@ final class SMSDispatcher extends Handler { mCm.setOnNewSMS(this, EVENT_NEW_SMS, null); mCm.setOnSmsStatus(this, EVENT_NEW_SMS_STATUS_REPORT, null); - mCm.setOnSimSmsFull(this, EVENT_SIM_FULL, null); + mCm.setOnIccSmsFull(this, EVENT_ICC_FULL, null); // Don't always start message ref at 0. sConcatenatedRef = new Random().nextInt(256); } + public void dispose() { + mCm.unSetOnNewSMS(this); + mCm.unSetOnSmsStatus(this); + mCm.unSetOnIccSmsFull(this); + } + + protected void finalize() { + Log.d(TAG, "SMSDispatcher finalized"); + } + + /* TODO: Need to figure out how to keep track of status report routing in a * persistent manner. If the phone process restarts (reboot or crash), * we will lose this list and any status reports that come in after * will be dropped. */ /** Sent messages awaiting a delivery status report. */ - private final ArrayList<SmsTracker> deliveryPendingList = new ArrayList<SmsTracker>(); + protected final ArrayList<SmsTracker> deliveryPendingList = new ArrayList<SmsTracker>(); /** * Handles events coming from the phone stack. Overridden from handler. @@ -242,11 +252,8 @@ final class SMSDispatcher extends Handler { ar = (AsyncResult) msg.obj; - // FIXME unit test leaves cm == null. this should change - if (mCm != null) { // FIXME only acknowledge on store - mCm.acknowledgeLastIncomingSMS(true, null); - } + acknowledgeLastIncomingSms(true, null); if (ar.exception != null) { Log.e(TAG, "Exception processing incoming SMS. Exception:" + ar.exception); @@ -254,12 +261,12 @@ final class SMSDispatcher extends Handler { } sms = (SmsMessage) ar.result; - dispatchMessage(sms); + dispatchMessage(sms.mWrappedSmsMessage); break; case EVENT_SEND_SMS_COMPLETE: - // An outbound SMS has been sucessfully transferred, or failed. + // An outbound SMS has been successfully transferred, or failed. handleSendComplete((AsyncResult) msg.obj); break; @@ -271,8 +278,8 @@ final class SMSDispatcher extends Handler { handleStatusReport((AsyncResult)msg.obj); break; - case EVENT_SIM_FULL: - handleSimFull(); + case EVENT_ICC_FULL: + handleIccFull(); break; case EVENT_POST_ALERT: @@ -298,27 +305,14 @@ final class SMSDispatcher extends Handler { } } - private void createWakelock() { - PowerManager pm = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE); - mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "SMSDispatcher"); - mWakeLock.setReferenceCounted(true); - } - - private void sendBroadcast(Intent intent, String permission) { - // Hold a wake lock for WAKE_LOCK_TIMEOUT seconds, enough to give any - // receivers time to take their own wake locks. - mWakeLock.acquire(WAKE_LOCK_TIMEOUT); - mContext.sendBroadcast(intent, permission); - } - /** * Called when SIM_FULL message is received from the RIL. Notifies interested * parties that SIM storage for SMS messages is full. */ - private void handleSimFull() { + private void handleIccFull(){ // broadcast SIM_FULL intent Intent intent = new Intent(Intents.SIM_FULL_ACTION); - sendBroadcast(intent, "android.permission.RECEIVE_SMS"); + mPhone.getContext().sendBroadcast(intent, "android.permission.RECEIVE_SMS"); } /** @@ -328,34 +322,7 @@ final class SMSDispatcher extends Handler { * @param ar AsyncResult passed into the message handler. ar.result should * be a String representing the status report PDU, as ASCII hex. */ - private void handleStatusReport(AsyncResult ar) { - String pduString = (String) ar.result; - SmsMessage sms = SmsMessage.newFromCDS(pduString); - - if (sms != null) { - int messageRef = sms.messageRef; - for (int i = 0, count = deliveryPendingList.size(); i < count; i++) { - SmsTracker tracker = deliveryPendingList.get(i); - if (tracker.mMessageRef == messageRef) { - // Found it. Remove from list and broadcast. - deliveryPendingList.remove(i); - PendingIntent intent = tracker.mDeliveryIntent; - Intent fillIn = new Intent(); - fillIn.putExtra("pdu", SimUtils.hexStringToBytes(pduString)); - try { - intent.send(mContext, Activity.RESULT_OK, fillIn); - } catch (CanceledException ex) {} - - // Only expect to see one tracker matching this messageref - break; - } - } - } - - if (mCm != null) { - mCm.acknowledgeLastIncomingSMS(true, null); - } - } + protected abstract void handleStatusReport(AsyncResult ar); /** * Called when SMS send completes. Broadcasts a sentIntent on success. @@ -366,7 +333,7 @@ final class SMSDispatcher extends Handler { * an SmsResponse instance if send was successful. ar.userObj * should be an SmsTracker instance. */ - private void handleSendComplete(AsyncResult ar) { + protected void handleSendComplete(AsyncResult ar) { SmsTracker tracker = (SmsTracker) ar.userObj; PendingIntent sentIntent = tracker.mSentIntent; @@ -414,7 +381,7 @@ final class SMSDispatcher extends Handler { } else if (tracker.mSentIntent != null) { // Done retrying; return an error to the app. try { - tracker.mSentIntent.send(SmsManager.RESULT_ERROR_GENERIC_FAILURE); + tracker.mSentIntent.send(RESULT_ERROR_GENERIC_FAILURE); } catch (CanceledException ex) {} } } @@ -429,13 +396,13 @@ final class SMSDispatcher extends Handler { * POWER_OFF * @param tracker An SmsTracker for the current message. */ - private void handleNotInService(int ss, SmsTracker tracker) { + protected void handleNotInService(int ss, SmsTracker tracker) { if (tracker.mSentIntent != null) { try { if (ss == ServiceState.STATE_POWER_OFF) { - tracker.mSentIntent.send(SmsManager.RESULT_ERROR_RADIO_OFF); + tracker.mSentIntent.send(RESULT_ERROR_RADIO_OFF); } else { - tracker.mSentIntent.send(SmsManager.RESULT_ERROR_NO_SERVICE); + tracker.mSentIntent.send(RESULT_ERROR_NO_SERVICE); } } catch (CanceledException ex) {} } @@ -446,130 +413,14 @@ final class SMSDispatcher extends Handler { * * @param sms the incoming message from the phone */ - /* package */ void dispatchMessage(SmsMessage sms) { - - // If sms is null, means there was a parsing error. - // TODO: Should NAK this. - if (sms == null) { - return; - } - - boolean handled = false; - - // Special case the message waiting indicator messages - if (sms.isMWISetMessage()) { - mPhone.updateMessageWaitingIndicator(true); - - if (sms.isMwiDontStore()) { - handled = true; - } - - if (Config.LOGD) { - Log.d(TAG, - "Received voice mail indicator set SMS shouldStore=" - + !handled); - } - } else if (sms.isMWIClearMessage()) { - mPhone.updateMessageWaitingIndicator(false); - - if (sms.isMwiDontStore()) { - handled = true; - } + protected abstract void dispatchMessage(SmsMessageBase sms); - if (Config.LOGD) { - Log.d(TAG, - "Received voice mail indicator clear SMS shouldStore=" - + !handled); - } - } - - if (handled) { - return; - } - - // Parse the headers to see if this is partial, or port addressed - int referenceNumber = -1; - int count = 0; - int sequence = 0; - int destPort = -1; - - SmsHeader header = sms.getUserDataHeader(); - if (header != null) { - for (SmsHeader.Element element : header.getElements()) { - try { - switch (element.getID()) { - case SmsHeader.CONCATENATED_8_BIT_REFERENCE: { - byte[] data = element.getData(); - - referenceNumber = data[0] & 0xff; - count = data[1] & 0xff; - sequence = data[2] & 0xff; - - // Per TS 23.040, 9.2.3.24.1: If the count is zero, sequence - // is zero, or sequence > count, ignore the entire element - if (count == 0 || sequence == 0 || sequence > count) { - referenceNumber = -1; - } - break; - } - - case SmsHeader.CONCATENATED_16_BIT_REFERENCE: { - byte[] data = element.getData(); - - referenceNumber = (data[0] & 0xff) * 256 + (data[1] & 0xff); - count = data[2] & 0xff; - sequence = data[3] & 0xff; - - // Per TS 23.040, 9.2.3.24.8: If the count is zero, sequence - // is zero, or sequence > count, ignore the entire element - if (count == 0 || sequence == 0 || sequence > count) { - referenceNumber = -1; - } - break; - } - - case SmsHeader.APPLICATION_PORT_ADDRESSING_16_BIT: { - byte[] data = element.getData(); - - destPort = (data[0] & 0xff) << 8; - destPort |= (data[1] & 0xff); - - break; - } - } - } catch (ArrayIndexOutOfBoundsException e) { - Log.e(TAG, "Bad element in header", e); - return; // TODO: NACK the message or something, don't just discard. - } - } - } - - if (referenceNumber == -1) { - // notify everyone of the message if it isn't partial - byte[][] pdus = new byte[1][]; - pdus[0] = sms.getPdu(); - - if (destPort != -1) { - if (destPort == SmsHeader.PORT_WAP_PUSH) { - mWapPush.dispatchWapPdu(sms.getUserData()); - } - // The message was sent to a port, so concoct a URI for it - dispatchPortAddressedPdus(pdus, destPort); - } else { - // It's a normal message, dispatch it - dispatchPdus(pdus); - } - } else { - // Process the message part - processMessagePart(sms, referenceNumber, sequence, count, destPort); - } - } /** * If this is the last part send the parts out to the application, otherwise * the part is stored for later processing. */ - private void processMessagePart(SmsMessage sms, int referenceNumber, + protected void processMessagePart(SmsMessageBase sms, int referenceNumber, int sequence, int count, int destinationPort) { // Lookup all other related parts StringBuilder where = new StringBuilder("reference_number ="); @@ -655,10 +506,11 @@ final class SMSDispatcher extends Handler { * * @param pdus The raw PDUs making up the message */ - private void dispatchPdus(byte[][] pdus) { + protected void dispatchPdus(byte[][] pdus) { Intent intent = new Intent(Intents.SMS_RECEIVED_ACTION); intent.putExtra("pdus", pdus); - sendBroadcast(intent, "android.permission.RECEIVE_SMS"); + mPhone.getContext().sendBroadcast( + intent, "android.permission.RECEIVE_SMS"); } /** @@ -667,11 +519,12 @@ final class SMSDispatcher extends Handler { * @param pdus The raw PDUs making up the message * @param port The destination port of the messages */ - private void dispatchPortAddressedPdus(byte[][] pdus, int port) { + protected void dispatchPortAddressedPdus(byte[][] pdus, int port) { Uri uri = Uri.parse("sms://localhost:" + port); Intent intent = new Intent(Intents.DATA_SMS_RECEIVED_ACTION, uri); intent.putExtra("pdus", pdus); - sendBroadcast(intent, "android.permission.RECEIVE_SMS"); + mPhone.getContext().sendBroadcast( + intent, "android.permission.RECEIVE_SMS"); } @@ -700,114 +553,9 @@ final class SMSDispatcher extends Handler { * to the recipient. The raw pdu of the status report is in the * extended data ("pdu"). */ - void sendMultipartText(String destinationAddress, String scAddress, ArrayList<String> parts, - ArrayList<PendingIntent> sentIntents, ArrayList<PendingIntent> deliveryIntents) { - - PendingIntent sentIntent = null; - - - int ss = mPhone.getServiceState().getState(); - - if (ss == ServiceState.STATE_IN_SERVICE) { - // Only check SMS sending limit while in service - if (sentIntents != null && sentIntents.size() > 0) { - sentIntent = sentIntents.get(0); - } - String appName = getAppNameByIntent(sentIntent); - if ( !mCounter.check(appName, parts.size())) { - HashMap<String, Object> map = new HashMap<String, Object>(); - map.put("destination", destinationAddress); - map.put("scaddress", scAddress); - map.put("parts", parts); - map.put("sentIntents", sentIntents); - map.put("deliveryIntents", deliveryIntents); - - SmsTracker multipartParameter = new SmsTracker(map, null, null); - - sendMessage(obtainMessage(EVENT_POST_ALERT, multipartParameter)); - return; - } - } - - sendMultipartTextWithPermit(destinationAddress, - scAddress, parts, sentIntents, deliveryIntents); - } - - /** - * Send a multi-part text based SMS which already passed SMS control check. - * - * It is the working function for sendMultipartText(). - * - * @param destinationAddress the address to send the message to - * @param scAddress is the service center address or null to use - * the current default SMSC - * @param parts an <code>ArrayList</code> of strings that, in order, - * comprise the original message - * @param sentIntents if not null, an <code>ArrayList</code> of - * <code>PendingIntent</code>s (one for each message part) that is - * broadcast when the corresponding message part has been sent. - * The result code will be <code>Activity.RESULT_OK<code> for success, - * or one of these errors: - * <code>RESULT_ERROR_GENERIC_FAILURE</code> - * <code>RESULT_ERROR_RADIO_OFF</code> - * <code>RESULT_ERROR_NULL_PDU</code>. - * @param deliveryIntents if not null, an <code>ArrayList</code> of - * <code>PendingIntent</code>s (one for each message part) that is - * broadcast when the corresponding message part has been delivered - * to the recipient. The raw pdu of the status report is in the - * extended data ("pdu"). - */ - private void sendMultipartTextWithPermit(String destinationAddress, - String scAddress, ArrayList<String> parts, - ArrayList<PendingIntent> sentIntents, - ArrayList<PendingIntent> deliveryIntents) { - - PendingIntent sentIntent = null; - PendingIntent deliveryIntent = null; - - // check if in service - int ss = mPhone.getServiceState().getState(); - if (ss != ServiceState.STATE_IN_SERVICE) { - for (int i = 0, count = parts.size(); i < count; i++) { - if (sentIntents != null && sentIntents.size() > i) { - sentIntent = sentIntents.get(i); - } - SmsTracker tracker = new SmsTracker(null, sentIntent, null); - handleNotInService(ss, tracker); - } - return; - } - - int ref = ++sConcatenatedRef & 0xff; - - for (int i = 0, count = parts.size(); i < count; i++) { - // build SmsHeader - byte[] data = new byte[3]; - data[0] = (byte) ref; // reference #, unique per message - data[1] = (byte) count; // total part count - data[2] = (byte) (i + 1); // 1-based sequence - SmsHeader header = new SmsHeader(); - header.add(new SmsHeader.Element(SmsHeader.CONCATENATED_8_BIT_REFERENCE, data)); - - if (sentIntents != null && sentIntents.size() > i) { - sentIntent = sentIntents.get(i); - } - if (deliveryIntents != null && deliveryIntents.size() > i) { - deliveryIntent = deliveryIntents.get(i); - } - - SmsMessage.SubmitPdu pdus = SmsMessage.getSubmitPdu(scAddress, destinationAddress, - parts.get(i), deliveryIntent != null, header.toByteArray()); - - HashMap<String, Object> map = new HashMap<String, Object>(); - map.put("smsc", pdus.encodedScAddress); - map.put("pdu", pdus.encodedMessage); - - SmsTracker tracker = new SmsTracker(map, sentIntent, - deliveryIntent); - sendSms(tracker); - } - } + protected abstract void sendMultipartText(String destinationAddress, String scAddress, + ArrayList<String> parts, ArrayList<PendingIntent> sentIntents, + ArrayList<PendingIntent> deliveryIntents); /** * Send a SMS @@ -829,12 +577,12 @@ final class SMSDispatcher extends Handler { * broadcast when the message is delivered to the recipient. The * raw pdu of the status report is in the extended data ("pdu"). */ - void sendRawPdu(byte[] smsc, byte[] pdu, PendingIntent sentIntent, + protected void sendRawPdu(byte[] smsc, byte[] pdu, PendingIntent sentIntent, PendingIntent deliveryIntent) { if (pdu == null) { if (sentIntent != null) { try { - sentIntent.send(SmsManager.RESULT_ERROR_NULL_PDU); + sentIntent.send(RESULT_ERROR_NULL_PDU); } catch (CanceledException ex) {} } return; @@ -865,7 +613,7 @@ final class SMSDispatcher extends Handler { * * An SmsTracker for the current message. */ - private void handleReachSentLimit(SmsTracker tracker) { + protected void handleReachSentLimit(SmsTracker tracker) { Resources r = Resources.getSystem(); @@ -886,7 +634,7 @@ final class SMSDispatcher extends Handler { DEFAULT_SMS_TIMOUEOUT); } - private String getAppNameByIntent(PendingIntent intent) { + protected String getAppNameByIntent(PendingIntent intent) { Resources r = Resources.getSystem(); return (intent != null) ? intent.getTargetPackage() : r.getString(R.string.sms_control_default_app_name); @@ -897,41 +645,53 @@ final class SMSDispatcher extends Handler { * * @param tracker holds the SMS message to send */ - private void sendSms(SmsTracker tracker) { - HashMap map = tracker.mData; - - byte smsc[] = (byte[]) map.get("smsc"); - byte pdu[] = (byte[]) map.get("pdu"); - - Message reply = obtainMessage(EVENT_SEND_SMS_COMPLETE, tracker); - mCm.sendSMS(SimUtils.bytesToHexString(smsc), - SimUtils.bytesToHexString(pdu), reply); - } + protected abstract void sendSms(SmsTracker tracker); /** * Send the multi-part SMS based on multipart Sms tracker * * @param tracker holds the multipart Sms tracker ready to be sent */ - private void sendMultipartSms (SmsTracker tracker) { - ArrayList<String> parts; - ArrayList<PendingIntent> sentIntents; - ArrayList<PendingIntent> deliveryIntents; - - HashMap map = tracker.mData; - - String destinationAddress = (String) map.get("destination"); - String scAddress = (String) map.get("scaddress"); - - parts = (ArrayList<String>) map.get("parts"); - sentIntents = (ArrayList<PendingIntent>) map.get("sentIntents"); - deliveryIntents = (ArrayList<PendingIntent>) map.get("deliveryIntents"); - - sendMultipartTextWithPermit(destinationAddress, - scAddress, parts, sentIntents, deliveryIntents); + protected abstract void sendMultipartSms (SmsTracker tracker); + + /** + * Activate or deactivate cell broadcast SMS. + * + * @param activate + * 0 = activate, 1 = deactivate + * @param response + * Callback message is empty on completion + */ + protected abstract void activateCellBroadcastSms(int activate, Message response); + + /** + * Query the current configuration of cell broadcast SMS. + * + * @param response + * Callback message contains the configuration from the modem on completion + * @see #setCellBroadcastConfig + */ + protected abstract void getCellBroadcastSmsConfig(Message response); + + /** + * Configure cell broadcast SMS. + * + * @param configValuesArray + * The first element defines the number of triples that follow. + * A triple is made up of the service category, the language identifier + * and a boolean that specifies whether the category is set active. + * @param response + * Callback message is empty on completion + */ + protected abstract void setCellBroadcastConfig(int[] configValuesArray, Message response); + + /** + * Send an acknowledge message. + * @param success indicates that last message was successfully received. + * @param response callback message sent when operation completes. + */ + protected abstract void acknowledgeLastIncomingSms(boolean success, Message response); - } - /** * Check if a SmsTracker holds multi-part Sms * @@ -942,19 +702,20 @@ final class SMSDispatcher extends Handler { HashMap map = tracker.mData; return ( map.get("parts") != null); } - + /** * Keeps track of an SMS that has been sent to the RIL, until it it has * successfully been sent, or we're done trying. * */ - static class SmsTracker { - HashMap mData; - int mRetryCount; - int mMessageRef; + static protected class SmsTracker { + // fields need to be public for derived SmsDispatchers + public HashMap mData; + public int mRetryCount; + public int mMessageRef; - PendingIntent mSentIntent; - PendingIntent mDeliveryIntent; + public PendingIntent mSentIntent; + public PendingIntent mDeliveryIntent; SmsTracker(HashMap data, PendingIntent sentIntent, PendingIntent deliveryIntent) { @@ -963,17 +724,21 @@ final class SMSDispatcher extends Handler { mDeliveryIntent = deliveryIntent; mRetryCount = 0; } - + } + + protected SmsTracker SmsTrackerFactory(HashMap data, PendingIntent sentIntent, + PendingIntent deliveryIntent) { + return new SmsTracker(data, sentIntent, deliveryIntent); } private DialogInterface.OnClickListener mListener = - new DialogInterface.OnClickListener() { + new DialogInterface.OnClickListener() { - public void onClick(DialogInterface dialog, int which) { - if (which == DialogInterface.BUTTON_POSITIVE) { - Log.d(TAG, "click YES to send out sms"); - sendMessage(obtainMessage(EVENT_SEND_CONFIRMED_SMS)); - } + public void onClick(DialogInterface dialog, int which) { + if (which == DialogInterface.BUTTON_POSITIVE) { + Log.d(TAG, "click YES to send out sms"); + sendMessage(obtainMessage(EVENT_SEND_CONFIRMED_SMS)); } - }; + } + }; } diff --git a/telephony/java/com/android/internal/telephony/ServiceStateTracker.java b/telephony/java/com/android/internal/telephony/ServiceStateTracker.java new file mode 100644 index 0000000..a4bf0dd --- /dev/null +++ b/telephony/java/com/android/internal/telephony/ServiceStateTracker.java @@ -0,0 +1,244 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.os.Registrant; +import android.os.RegistrantList; +import android.telephony.ServiceState; + +/** + * {@hide} + */ +public abstract class ServiceStateTracker extends Handler { + /** + * The access technology currently in use: + * 0 = unknown + * 1 = GPRS only + * 2 = EDGE + * 3 = UMTS + */ + protected static final int DATA_ACCESS_UNKNOWN = 0; + protected static final int DATA_ACCESS_GPRS = 1; + protected static final int DATA_ACCESS_EDGE = 2; + protected static final int DATA_ACCESS_UMTS = 3; + protected static final int DATA_ACCESS_CDMA_IS95A = 4; + protected static final int DATA_ACCESS_CDMA_IS95B = 5; + protected static final int DATA_ACCESS_CDMA_1xRTT = 6; + protected static final int DATA_ACCESS_CDMA_EvDo_0 = 7; + protected static final int DATA_ACCESS_CDMA_EvDo_A = 8; + //***** Instance Variables + + protected CommandsInterface cm; + + public ServiceState ss; + protected ServiceState newSS; + + // Used as a unique identifier to track requests associated with a poll + // and ignore stale responses.The value is a count-down of expected responses + // in this pollingContext + protected int[] pollingContext; + protected boolean mDesiredPowerState; + + protected boolean dontPollSignalStrength = false; // Default is to poll strength + // If we're getting unsolicited signal strength updates from the radio, + // set value to true and don't bother polling any more + + protected RegistrantList networkAttachedRegistrants = new RegistrantList(); + protected RegistrantList roamingOnRegistrants = new RegistrantList(); + protected RegistrantList roamingOffRegistrants = new RegistrantList(); + + //***** Constants + + protected static final boolean DBG = true; + + // signal strength poll rate + protected static final int POLL_PERIOD_MILLIS = 20 * 1000; + + // waiting period before recheck gprs and voice registration + public static final int DEFAULT_GPRS_CHECK_PERIOD_MILLIS = 60 * 1000; + + public static final int MAX_NUM_DATA_STATE_READS = 15; + public static final int DATA_STATE_POLL_SLEEP_MS = 100; + + //*****GSM events + protected static final int EVENT_RADIO_STATE_CHANGED = 1; + protected static final int EVENT_NETWORK_STATE_CHANGED = 2; + protected static final int EVENT_GET_SIGNAL_STRENGTH = 3; + protected static final int EVENT_POLL_STATE_REGISTRATION = 4; + protected static final int EVENT_POLL_STATE_GPRS = 5; + protected static final int EVENT_POLL_STATE_OPERATOR = 6; + protected static final int EVENT_POLL_SIGNAL_STRENGTH = 10; + protected static final int EVENT_NITZ_TIME = 11; + protected static final int EVENT_SIGNAL_STRENGTH_UPDATE = 12; + protected static final int EVENT_RADIO_AVAILABLE = 13; + protected static final int EVENT_POLL_STATE_NETWORK_SELECTION_MODE = 14; + protected static final int EVENT_GET_LOC_DONE = 15; + protected static final int EVENT_SIM_RECORDS_LOADED = 16; + protected static final int EVENT_SIM_READY = 17; + protected static final int EVENT_LOCATION_UPDATES_ENABLED = 18; + protected static final int EVENT_GET_PREFERRED_NETWORK_TYPE = 19; + protected static final int EVENT_SET_PREFERRED_NETWORK_TYPE = 20; + protected static final int EVENT_RESET_PREFERRED_NETWORK_TYPE = 21; + protected static final int EVENT_CHECK_REPORT_GPRS = 22; + protected static final int EVENT_RESTRICTED_STATE_CHANGED = 23; + + //*****CDMA events: + protected static final int EVENT_POLL_STATE_REGISTRATION_CDMA = 24; + protected static final int EVENT_POLL_STATE_OPERATOR_CDMA = 25; + protected static final int EVENT_RUIM_READY = 26; + protected static final int EVENT_RUIM_RECORDS_LOADED = 27; + protected static final int EVENT_POLL_STATE_NETWORK_SELECTION_MODE_CDMA = 28; + protected static final int EVENT_POLL_SIGNAL_STRENGTH_CDMA = 29; + protected static final int EVENT_GET_SIGNAL_STRENGTH_CDMA = 30; + protected static final int EVENT_NETWORK_STATE_CHANGED_CDMA = 31; + protected static final int EVENT_GET_LOC_DONE_CDMA = 32; + protected static final int EVENT_SIGNAL_STRENGTH_UPDATE_CDMA = 33; + protected static final int EVENT_NV_LOADED = 34; + + // Event Log Tags + protected static final int EVENT_LOG_CGREG_FAIL = 50107; + protected static final int EVENT_DATA_STATE_RADIO_OFF = 50108; + + //***** Time Zones + protected static final String TIMEZONE_PROPERTY = "persist.sys.timezone"; + + // List of ISO codes for countries that can have an offset of GMT+0 + // when not in daylight savings time. This ignores some small places + // such as the Canary Islands (Spain) and Danmarkshavn (Denmark). + // The list must be sorted by code. + protected static final String[] GMT_COUNTRY_CODES = { + "bf", // Burkina Faso + "ci", // Cote d'Ivoire + "eh", // Western Sahara + "fo", // Faroe Islands, Denmark + "gh", // Ghana + "gm", // Gambia + "gn", // Guinea + "gw", // Guinea Bissau + "ie", // Ireland + "lr", // Liberia + "is", // Iceland + "ma", // Morocco + "ml", // Mali + "mr", // Mauritania + "pt", // Portugal + "sl", // Sierra Leone + "sn", // Senegal + "st", // Sao Tome and Principe + "tg", // Togo + "uk", // U.K + }; + + + //***** Constructors + public ServiceStateTracker() { + + } + + + /** + * Registration point for combined roaming on + * combined roaming is true when roaming is true and ONS differs SPN + * + * @param h handler to notify + * @param what what code of message when delivered + * @param obj placed in Message.obj + */ + public void registerForRoamingOn(Handler h, int what, Object obj) { + Registrant r = new Registrant(h, what, obj); + roamingOnRegistrants.add(r); + + if (ss.getRoaming()) { + r.notifyRegistrant(); + } + } + + public void unregisterForRoamingOn(Handler h) { + roamingOnRegistrants.remove(h); + } + + /** + * Registration point for combined roaming off + * combined roaming is true when roaming is true and ONS differs SPN + * + * @param h handler to notify + * @param what what code of message when delivered + * @param obj placed in Message.obj + */ + public void registerForRoamingOff(Handler h, int what, Object obj) { + Registrant r = new Registrant(h, what, obj); + roamingOffRegistrants.add(r); + + if (!ss.getRoaming()) { + r.notifyRegistrant(); + } + } + + public void unregisterForRoamingOff(Handler h) { + roamingOffRegistrants.remove(h); + } + + /** + * Reregister network through toggle perferred network type + * This is a work aorund to deregister and register network since there is + * no ril api to set COPS=2 (deregister) only. + * + * @param onComplete is dispatched when this is complete. it will be + * an AsyncResult, and onComplete.obj.exception will be non-null + * on failure. + */ + public void reRegisterNetwork(Message onComplete) { + cm.getPreferredNetworkType( + obtainMessage(EVENT_GET_PREFERRED_NETWORK_TYPE, onComplete)); + } + + + //***** Called from Phone + public void + setRadioPower(boolean power) { + mDesiredPowerState = power; + + setPowerStateToDesired(); + } + + + public void enableLocationUpdates() { + cm.setLocationUpdates(true, obtainMessage(EVENT_LOCATION_UPDATES_ENABLED)); + } + + public void disableLocationUpdates() { + cm.setLocationUpdates(false, null); + } + + //***** Overridden from Handler + public abstract void handleMessage(Message msg); + + //***** Protected abstract Methods + protected abstract void handlePollStateResult(int what, AsyncResult ar); + protected abstract void updateSpnDisplay(); + protected abstract void setPowerStateToDesired(); + + /** Cancel a pending (if any) pollState() operation */ + protected void cancelPollState() { + // This will effectively cancel the rest of the poll requests + pollingContext = new int[1]; + } +} + diff --git a/telephony/java/com/android/internal/telephony/SmsAddress.java b/telephony/java/com/android/internal/telephony/SmsAddress.java new file mode 100644 index 0000000..b3892cb --- /dev/null +++ b/telephony/java/com/android/internal/telephony/SmsAddress.java @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +public abstract class SmsAddress { + // From TS 23.040 9.1.2.5 and TS 24.008 table 10.5.118 + // and C.S0005-D table 2.7.1.3.2.4-2 + public static final int TON_UNKNOWN = 0; + public static final int TON_INTERNATIONAL = 1; + public static final int TON_NATIONAL = 2; + public static final int TON_NETWORK = 3; + public static final int TON_SUBSCRIBER = 4; + public static final int TON_ALPHANUMERIC = 5; + public static final int TON_ABBREVIATED = 6; + + public int ton; + public String address; + public byte[] origBytes; + + /** + * Returns the address of the SMS message in String form or null if unavailable + */ + public String getAddressString() { + return address; + } + + /** + * Returns true if this is an alphanumeric address + */ + public boolean isAlphanumeric() { + return ton == TON_ALPHANUMERIC; + } + + /** + * Returns true if this is a network address + */ + public boolean isNetworkSpecific() { + return ton == TON_NETWORK; + } + + public boolean couldBeEmailGateway() { + // Some carriers seems to send email gateway messages in this form: + // from: an UNKNOWN TON, 3 or 4 digits long, beginning with a 5 + // PID: 0x00, Data coding scheme 0x03 + // So we just attempt to treat any message from an address length <= 4 + // as an email gateway + + return address.length() <= 4; + } + +} diff --git a/telephony/java/com/android/internal/telephony/gsm/SmsHeader.java b/telephony/java/com/android/internal/telephony/SmsHeader.java index 22366ec..64b884e 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SmsHeader.java +++ b/telephony/java/com/android/internal/telephony/SmsHeader.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; import com.android.internal.util.HexDump; @@ -24,8 +24,7 @@ import java.util.ArrayList; * This class represents a SMS user data header. * */ -public class SmsHeader -{ +public class SmsHeader { /** See TS 23.040 9.2.3.24 for description of this element ID. */ public static final int CONCATENATED_8_BIT_REFERENCE = 0x00; /** See TS 23.040 9.2.3.24 for description of this element ID. */ @@ -42,6 +41,7 @@ public class SmsHeader private byte[] m_data; private ArrayList<Element> m_elements = new ArrayList<Element>(); + public int nbrOfHeaders; /** * Creates an SmsHeader object from raw user data header bytes. @@ -49,36 +49,33 @@ public class SmsHeader * @param data is user data header bytes * @return an SmsHeader object */ - public static SmsHeader parse(byte[] data) - { + public static SmsHeader parse(byte[] data) { SmsHeader header = new SmsHeader(); header.m_data = data; int index = 0; - while (index < data.length) - { + header.nbrOfHeaders = 0; + while (index < data.length) { int id = data[index++] & 0xff; int length = data[index++] & 0xff; byte[] elementData = new byte[length]; System.arraycopy(data, index, elementData, 0, length); header.add(new Element(id, elementData)); index += length; + header.nbrOfHeaders++; } return header; } - public SmsHeader() - { - } + public SmsHeader() { } /** * Returns the list of SmsHeader Elements that make up the header. * * @return the list of SmsHeader Elements. */ - public ArrayList<Element> getElements() - { + public ArrayList<Element> getElements() { return m_elements; } @@ -87,14 +84,12 @@ public class SmsHeader * * @param element to add. */ - public void add(Element element) - { + public void add(Element element) { m_elements.add(element); } @Override - public String toString() - { + public String toString() { StringBuilder builder = new StringBuilder(); builder.append("UDH LENGTH: " + m_data.length + " octets"); @@ -104,40 +99,56 @@ public class SmsHeader for (Element e : getElements()) { builder.append(" 0x" + HexDump.toHexString((byte)e.getID()) + " - "); - switch (e.getID()) - { - case CONCATENATED_8_BIT_REFERENCE: - { + switch (e.getID()) { + case CONCATENATED_8_BIT_REFERENCE: { builder.append("Concatenated Short Message 8bit ref\n"); byte[] data = e.getData(); builder.append(" " + data.length + " (0x"); - builder.append(HexDump.toHexString((byte)data.length)+") Bytes - Information Element\n"); + builder.append(HexDump.toHexString((byte)data.length) + + ") Bytes - Information Element\n"); builder.append(" " + data[0] + " : SM reference number\n"); builder.append(" " + data[1] + " : number of messages\n"); builder.append(" " + data[2] + " : this SM sequence number\n"); break; } - case CONCATENATED_16_BIT_REFERENCE: - { + case CONCATENATED_16_BIT_REFERENCE: { builder.append("Concatenated Short Message 16bit ref\n"); byte[] data = e.getData(); builder.append(" " + data.length + " (0x"); - builder.append(HexDump.toHexString((byte)data.length)+") Bytes - Information Element\n"); - builder.append(" " + (data[0] & 0xff) * 256 + (data[1] & 0xff) + - " : SM reference number\n"); + builder.append(HexDump.toHexString((byte)data.length) + + ") Bytes - Information Element\n"); + builder.append(" " + (data[0] & 0xff) * 256 + (data[1] & 0xff) + + " : SM reference number\n"); builder.append(" " + data[2] + " : number of messages\n"); builder.append(" " + data[3] + " : this SM sequence number\n"); break; } - case APPLICATION_PORT_ADDRESSING_16_BIT: + case APPLICATION_PORT_ADDRESSING_8_BIT: { + builder.append("Application port addressing 8bit\n"); + byte[] data = e.getData(); + + builder.append(" " + data.length + " (0x"); + builder.append(HexDump.toHexString( + (byte)data.length) + ") Bytes - Information Element\n"); + + int source = (data[0] & 0xff); + builder.append(" " + source + " : DESTINATION port\n"); + + int dest = (data[1] & 0xff); + builder.append(" " + dest + " : SOURCE port\n"); + break; + } + + case APPLICATION_PORT_ADDRESSING_16_BIT: { builder.append("Application port addressing 16bit\n"); byte[] data = e.getData(); builder.append(" " + data.length + " (0x"); - builder.append(HexDump.toHexString((byte)data.length)+") Bytes - Information Element\n"); + builder.append(HexDump.toHexString((byte)data.length) + + ") Bytes - Information Element\n"); int source = (data[0] & 0xff) << 8; source |= (data[1] & 0xff); @@ -149,8 +160,7 @@ public class SmsHeader break; } - default: - { + default: { builder.append("Unknown element\n"); break; } @@ -202,13 +212,11 @@ public class SmsHeader * See TS 23.040 9.2.3.24. * */ - public static class Element - { + public static class Element { private byte[] m_data; private int m_id; - public Element(int id, byte[] data) - { + public Element(int id, byte[] data) { m_id = id; m_data = data; } @@ -218,8 +226,7 @@ public class SmsHeader * * @return the IE identifier. */ - public int getID() - { + public int getID() { return m_id; } @@ -228,8 +235,7 @@ public class SmsHeader * * @return element data. */ - public byte[] getData() - { + public byte[] getData() { return m_data; } } diff --git a/telephony/java/com/android/internal/telephony/SmsMessageBase.java b/telephony/java/com/android/internal/telephony/SmsMessageBase.java new file mode 100644 index 0000000..7c32451 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/SmsMessageBase.java @@ -0,0 +1,388 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony; + +import android.util.Log; +import com.android.internal.telephony.SmsHeader; +import java.util.Arrays; + +import static android.telephony.SmsMessage.ENCODING_7BIT; +import static android.telephony.SmsMessage.ENCODING_16BIT; +import static android.telephony.SmsMessage.MAX_USER_DATA_BYTES; +import static android.telephony.SmsMessage.MAX_USER_DATA_BYTES_WITH_HEADER; +import static android.telephony.SmsMessage.MAX_USER_DATA_SEPTETS; +import static android.telephony.SmsMessage.MAX_USER_DATA_SEPTETS_WITH_HEADER; +import static android.telephony.SmsMessage.MessageClass; +import static com.android.internal.telephony.SmsAddress.TON_ABBREVIATED; +import static com.android.internal.telephony.SmsAddress.TON_ALPHANUMERIC; +import static com.android.internal.telephony.SmsAddress.TON_INTERNATIONAL; +import static com.android.internal.telephony.SmsAddress.TON_NATIONAL; +import static com.android.internal.telephony.SmsAddress.TON_NETWORK; +import static com.android.internal.telephony.SmsAddress.TON_SUBSCRIBER; +import static com.android.internal.telephony.SmsAddress.TON_UNKNOWN; + +/** + * Base class declaring the specific methods and members for SmsMessage. + * {@hide} + */ +public abstract class SmsMessageBase { + private static final String LOG_TAG = "SMS"; + + /** {@hide} The address of the SMSC. May be null */ + protected String scAddress; + + /** {@hide} The address of the sender */ + protected SmsAddress originatingAddress; + + /** {@hide} The message body as a string. May be null if the message isn't text */ + protected String messageBody; + + /** {@hide} */ + protected String pseudoSubject; + + /** {@hide} Non-null if this is an email gateway message */ + protected String emailFrom; + + /** {@hide} Non-null if this is an email gateway message */ + protected String emailBody; + + /** {@hide} */ + protected boolean isEmail; + + /** {@hide} */ + protected long scTimeMillis; + + /** {@hide} The raw PDU of the message */ + protected byte[] mPdu; + + /** {@hide} The raw bytes for the user data section of the message */ + protected byte[] userData; + + /** {@hide} */ + protected SmsHeader userDataHeader; + + // "Message Waiting Indication Group" + // 23.038 Section 4 + /** {@hide} */ + protected boolean isMwi; + + /** {@hide} */ + protected boolean mwiSense; + + /** {@hide} */ + protected boolean mwiDontStore; + + /** + * Indicates status for messages stored on the ICC. + */ + protected int statusOnIcc = -1; + + /** + * Record index of message in the EF. + */ + protected int indexOnIcc = -1; + + /** TP-Message-Reference - Message Reference of sent message. @hide */ + public int messageRef; + + public static abstract class SubmitPduBase { + public byte[] encodedScAddress; // Null if not applicable. + public byte[] encodedMessage; + + public String toString() { + return "SubmitPdu: encodedScAddress = " + + Arrays.toString(encodedScAddress) + + ", encodedMessage = " + + Arrays.toString(encodedMessage); + } + } + + /** + * Returns the address of the SMS service center that relayed this message + * or null if there is none. + */ + public String getServiceCenterAddress() { + return scAddress; + } + + /** + * Returns the originating address (sender) of this SMS message in String + * form or null if unavailable + */ + public String getOriginatingAddress() { + if (originatingAddress == null) { + return null; + } + + return originatingAddress.getAddressString(); + } + + /** + * Returns the originating address, or email from address if this message + * was from an email gateway. Returns null if originating address + * unavailable. + */ + public String getDisplayOriginatingAddress() { + if (isEmail) { + return emailFrom; + } else { + return getOriginatingAddress(); + } + } + + /** + * Returns the message body as a String, if it exists and is text based. + * @return message body is there is one, otherwise null + */ + public String getMessageBody() { + return messageBody; + } + + /** + * Returns the class of this message. + */ + public abstract MessageClass getMessageClass(); + + /** + * Returns the message body, or email message body if this message was from + * an email gateway. Returns null if message body unavailable. + */ + public String getDisplayMessageBody() { + if (isEmail) { + return emailBody; + } else { + return getMessageBody(); + } + } + + /** + * Unofficial convention of a subject line enclosed in parens empty string + * if not present + */ + public String getPseudoSubject() { + return pseudoSubject == null ? "" : pseudoSubject; + } + + /** + * Returns the service centre timestamp in currentTimeMillis() format + */ + public long getTimestampMillis() { + return scTimeMillis; + } + + /** + * Returns true if message is an email. + * + * @return true if this message came through an email gateway and email + * sender / subject / parsed body are available + */ + public boolean isEmail() { + return isEmail; + } + + /** + * @return if isEmail() is true, body of the email sent through the gateway. + * null otherwise + */ + public String getEmailBody() { + return emailBody; + } + + /** + * @return if isEmail() is true, email from address of email sent through + * the gateway. null otherwise + */ + public String getEmailFrom() { + return emailFrom; + } + + /** + * Get protocol identifier. + */ + public abstract int getProtocolIdentifier(); + + /** + * See TS 23.040 9.2.3.9 returns true if this is a "replace short message" + * SMS + */ + public abstract boolean isReplace(); + + /** + * Returns true for CPHS MWI toggle message. + * + * @return true if this is a CPHS MWI toggle message See CPHS 4.2 section + * B.4.2 + */ + public abstract boolean isCphsMwiMessage(); + + /** + * returns true if this message is a CPHS voicemail / message waiting + * indicator (MWI) clear message + */ + public abstract boolean isMWIClearMessage(); + + /** + * returns true if this message is a CPHS voicemail / message waiting + * indicator (MWI) set message + */ + public abstract boolean isMWISetMessage(); + + /** + * returns true if this message is a "Message Waiting Indication Group: + * Discard Message" notification and should not be stored. + */ + public abstract boolean isMwiDontStore(); + + /** + * returns the user data section minus the user data header if one was + * present. + */ + public byte[] getUserData() { + return userData; + } + + /** + * Returns an object representing the user data header + * + * @return an object representing the user data header + * + * {@hide} + */ + public SmsHeader getUserDataHeader() { + return userDataHeader; + } + + /** + * Returns the raw PDU for the message. + * + * @return the raw PDU for the message. + */ + public byte[] getPdu() { + return mPdu; + } + + /** + * For an SMS-STATUS-REPORT message, this returns the status field from + * the status report. This field indicates the status of a previously + * submitted SMS, if requested. See TS 23.040, 9.2.3.15 TP-Status for a + * description of values. + * + * @return 0 indicates the previously sent message was received. + * See TS 23.040, 9.9.2.3.15 for a description of other possible + * values. + */ + public abstract int getStatus(); + + /** + * Return true iff the message is a SMS-STATUS-REPORT message. + */ + public abstract boolean isStatusReportMessage(); + + /** + * Returns true iff the <code>TP-Reply-Path</code> bit is set in + * this message. + */ + public abstract boolean isReplyPathPresent(); + + /** + * Returns the status of the message on the ICC (read, unread, sent, unsent). + * + * @return the status of the message on the ICC. These are: + * SmsManager.STATUS_ON_ICC_FREE + * SmsManager.STATUS_ON_ICC_READ + * SmsManager.STATUS_ON_ICC_UNREAD + * SmsManager.STATUS_ON_ICC_SEND + * SmsManager.STATUS_ON_ICC_UNSENT + */ + public int getStatusOnIcc() { + return statusOnIcc; + } + + /** + * Returns the record index of the message on the ICC (1-based index). + * @return the record index of the message on the ICC, or -1 if this + * SmsMessage was not created from a ICC SMS EF record. + */ + public int getIndexOnIcc() { + return indexOnIcc; + } + + protected void parseMessageBody() { + if (originatingAddress.couldBeEmailGateway()) { + extractEmailAddressFromMessageBody(); + } + } + + /** + * Try to parse this message as an email gateway message -> Neither + * of the standard ways are currently supported: There are two ways + * specified in TS 23.040 Section 3.8 (not supported via this mechanism) - + * SMS message "may have its TP-PID set for internet electronic mail - MT + * SMS format: [<from-address><space>]<message> - "Depending on the + * nature of the gateway, the destination/origination address is either + * derived from the content of the SMS TP-OA or TP-DA field, or the + * TP-OA/TP-DA field contains a generic gateway address and the to/from + * address is added at the beginning as shown above." - multiple addreses + * separated by commas, no spaces - subject field delimited by '()' or '##' + * and '#' Section 9.2.3.24.11 + */ + protected void extractEmailAddressFromMessageBody() { + + /* + * a little guesswork here. I haven't found doc for this. + * the format could be either + * + * 1. [x@y][ ]/[subject][ ]/[body] + * -or- + * 2. [x@y][ ]/[body] + */ + int slash = 0, slash2 = 0, atSymbol = 0; + + try { + slash = messageBody.indexOf(" /"); + if (slash == -1) { + return; + } + + atSymbol = messageBody.indexOf('@'); + if (atSymbol == -1 || atSymbol > slash) { + return; + } + + emailFrom = messageBody.substring(0, slash); + + slash2 = messageBody.indexOf(" /", slash + 2); + + if (slash2 == -1) { + pseudoSubject = null; + emailBody = messageBody.substring(slash + 2); + } else { + pseudoSubject = messageBody.substring(slash + 2, slash2); + emailBody = messageBody.substring(slash2 + 2); + } + + isEmail = true; + } catch (Exception ex) { + Log.w(LOG_TAG, + "extractEmailAddressFromMessageBody: exception slash=" + + slash + ", atSymbol=" + atSymbol + ", slash2=" + + slash2, ex); + } + } + +} + diff --git a/telephony/java/com/android/internal/telephony/gsm/SmsRawData.aidl b/telephony/java/com/android/internal/telephony/SmsRawData.aidl index 6f1a46d..b0b3e4f 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SmsRawData.aidl +++ b/telephony/java/com/android/internal/telephony/SmsRawData.aidl @@ -14,6 +14,6 @@ ** limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; parcelable SmsRawData; diff --git a/telephony/java/com/android/internal/telephony/gsm/SmsRawData.java b/telephony/java/com/android/internal/telephony/SmsRawData.java index a029d5c..891d942 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SmsRawData.java +++ b/telephony/java/com/android/internal/telephony/SmsRawData.java @@ -15,10 +15,10 @@ */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; -import android.os.Parcelable; import android.os.Parcel; +import android.os.Parcelable; /** * A parcelable holder class of byte[] for ISms aidl implementation @@ -50,7 +50,7 @@ public class SmsRawData implements Parcelable { public byte[] getBytes() { return data; } - + public int describeContents() { return 0; } diff --git a/telephony/java/com/android/internal/telephony/gsm/SmsResponse.java b/telephony/java/com/android/internal/telephony/SmsResponse.java index c005b5f..3c4df56 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SmsResponse.java +++ b/telephony/java/com/android/internal/telephony/SmsResponse.java @@ -14,20 +14,20 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; /** * Object returned by the RIL upon successful completion of sendSMS. * Contains message reference and ackPdu. * */ -class SmsResponse { +public class SmsResponse { /** Message reference of the just-sent SMS. */ int messageRef; /** ackPdu for the just-sent SMS. */ String ackPdu; - SmsResponse(int messageRef, String ackPdu) { + public SmsResponse(int messageRef, String ackPdu) { this.messageRef = messageRef; this.ackPdu = ackPdu; } diff --git a/telephony/java/com/android/internal/telephony/gsm/TelephonyEventLog.java b/telephony/java/com/android/internal/telephony/TelephonyEventLog.java index 1e583f0..1ef3c6c 100644 --- a/telephony/java/com/android/internal/telephony/gsm/TelephonyEventLog.java +++ b/telephony/java/com/android/internal/telephony/TelephonyEventLog.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.internal.telephony.gsm; +package com.android.internal.telephony; /* This class contains the details related to Telephony Event Logging */ public final class TelephonyEventLog { diff --git a/telephony/java/com/android/internal/telephony/TelephonyIntents.java b/telephony/java/com/android/internal/telephony/TelephonyIntents.java index 9219e7a..c342233 100644 --- a/telephony/java/com/android/internal/telephony/TelephonyIntents.java +++ b/telephony/java/com/android/internal/telephony/TelephonyIntents.java @@ -35,6 +35,24 @@ public class TelephonyIntents { */ public static final String ACTION_SERVICE_STATE_CHANGED = "android.intent.action.SERVICE_STATE"; + /** + * <p>Broadcast Action: The radio technology has changed. The intent will have the following + * extra values:</p> + * <ul> + * <li><em>phoneName</em> - A string version of the new phone name.</li> + * </ul> + * + * <p class="note"> + * You can <em>not</em> receive this through components declared + * in manifests, only by explicitly registering for it with + * {@link android.content.Context#registerReceiver(android.content.BroadcastReceiver, + * android.content.IntentFilter) Context.registerReceiver()}. + * + * <p class="note"> + * Requires no permission. + */ + public static final String ACTION_RADIO_TECHNOLOGY_CHANGED + = "android.intent.action.RADIO_TECHNOLOGY"; /** * Broadcast Action: The phone's signal strength has changed. The intent will have the @@ -47,7 +65,7 @@ public class TelephonyIntents { * <ul><li>0 means "-113 dBm or less".</li><li>31 means "-51 dBm or greater".</li></ul> * </li> * </ul> - * + * * <p class="note"> * You can <em>not</em> receive this through components declared * in manifests, only by exlicitly registering for it with diff --git a/telephony/java/com/android/internal/telephony/TelephonyProperties.java b/telephony/java/com/android/internal/telephony/TelephonyProperties.java index 6aa90f1..396b42d 100644 --- a/telephony/java/com/android/internal/telephony/TelephonyProperties.java +++ b/telephony/java/com/android/internal/telephony/TelephonyProperties.java @@ -26,8 +26,11 @@ public interface TelephonyProperties { //****** Baseband and Radio Interface version - /** - * Baseband version + //TODO T: property strings do not have to be gsm specific + // change gsm.*operator.*" properties to "operator.*" properties + + /** + * Baseband version * Availability: property is available any time radio is on */ static final String PROPERTY_BASEBAND_VERSION = "gsm.version.baseband"; @@ -47,6 +50,12 @@ public interface TelephonyProperties */ static final String PROPERTY_OPERATOR_NUMERIC = "gsm.operator.numeric"; + /** 'true' if the device is on a manually selected network + * + * Availability: when registered to a network + */ + static final String PROPERTY_OPERATOR_ISMANUAL = "operator.ismanual"; + /** 'true' if the device is considered roaming on this network for GSM * purposes. * Availability: when registered to a network @@ -60,7 +69,7 @@ public interface TelephonyProperties static final String PROPERTY_OPERATOR_ISO_COUNTRY = "gsm.operator.iso-country"; //****** SIM Card - /** + /** * One of <code>"UNKNOWN"</code> <code>"ABSENT"</code> <code>"PIN_REQUIRED"</code> * <code>"PUK_REQUIRED"</code> <code>"NETWORK_LOCKED"</code> or <code>"READY"</code> */ @@ -70,15 +79,15 @@ public interface TelephonyProperties * provider of the SIM. 5 or 6 decimal digits. * Availablity: SIM state must be "READY" */ - static String PROPERTY_SIM_OPERATOR_NUMERIC = "gsm.sim.operator.numeric"; + static String PROPERTY_ICC_OPERATOR_NUMERIC = "gsm.sim.operator.numeric"; - /** PROPERTY_SIM_OPERATOR_ALPHA is also known as the SPN, or Service Provider Name. + /** PROPERTY_ICC_OPERATOR_ALPHA is also known as the SPN, or Service Provider Name. * Availablity: SIM state must be "READY" */ - static String PROPERTY_SIM_OPERATOR_ALPHA = "gsm.sim.operator.alpha"; + static String PROPERTY_ICC_OPERATOR_ALPHA = "gsm.sim.operator.alpha"; /** ISO country code equivalent for the SIM provider's country code*/ - static String PROPERTY_SIM_OPERATOR_ISO_COUNTRY = "gsm.sim.operator.iso-country"; + static String PROPERTY_ICC_OPERATOR_ISO_COUNTRY = "gsm.sim.operator.iso-country"; /** * Indicates the available radio technology. Values include: <code>"unknown"</code>, diff --git a/telephony/java/com/android/internal/telephony/WapPushOverSms.java b/telephony/java/com/android/internal/telephony/WapPushOverSms.java index 2b70162..98899c9 100644 --- a/telephony/java/com/android/internal/telephony/WapPushOverSms.java +++ b/telephony/java/com/android/internal/telephony/WapPushOverSms.java @@ -22,7 +22,6 @@ import android.os.PowerManager; import android.provider.Telephony.Sms.Intents; import android.util.Config; import android.util.Log; -import com.android.internal.telephony.gsm.SimUtils; /** @@ -44,6 +43,7 @@ public class WapPushOverSms { private final int WAKE_LOCK_TIMEOUT = 5000; public WapPushOverSms(Phone phone) { + mContext = phone.getContext(); createWakelock(); } @@ -56,7 +56,7 @@ public class WapPushOverSms { */ public void dispatchWapPdu(byte[] pdu) { - if (Config.LOGD) Log.d(LOG_TAG, "Rx: " + SimUtils.bytesToHexString(pdu)); + if (Config.LOGD) Log.d(LOG_TAG, "Rx: " + IccUtils.bytesToHexString(pdu)); int index = 0; int transactionId = pdu[index++] & 0xFF; @@ -225,3 +225,4 @@ public class WapPushOverSms { mContext.sendBroadcast(intent, permission); } } + diff --git a/telephony/java/com/android/internal/telephony/cdma/CDMAPhone.java b/telephony/java/com/android/internal/telephony/cdma/CDMAPhone.java new file mode 100644 index 0000000..ef2f548 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/CDMAPhone.java @@ -0,0 +1,916 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import android.content.Context; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.os.Registrant; +import android.os.RegistrantList; +import android.os.SystemProperties; +import android.provider.Settings; +import android.telephony.CellLocation; +import android.telephony.PhoneNumberUtils; +import android.telephony.ServiceState; +import android.text.TextUtils; +import android.util.Log; + +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_BASEBAND_VERSION; + +import com.android.internal.telephony.CallStateException; +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.Connection; +import com.android.internal.telephony.DataConnection; +import com.android.internal.telephony.IccCard; +import com.android.internal.telephony.IccFileHandler; +import com.android.internal.telephony.IccPhoneBookInterfaceManager; +import com.android.internal.telephony.IccSmsInterfaceManager; +import com.android.internal.telephony.MmiCode; +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneBase; +import com.android.internal.telephony.PhoneNotifier; +import com.android.internal.telephony.PhoneProxy; +import com.android.internal.telephony.PhoneSubInfo; +import com.android.internal.telephony.RILConstants; + +import java.util.ArrayList; +import java.util.List; + +/** + * {@hide} + */ +public class CDMAPhone extends PhoneBase { + static final String LOG_TAG = "CDMA"; + private static final boolean LOCAL_DEBUG = true; + + //***** Instance Variables + CdmaCallTracker mCT; + CdmaSMSDispatcher mSMS; + CdmaServiceStateTracker mSST; + CdmaDataConnectionTracker mDataConnection; + RuimFileHandler mRuimFileHandler; + RuimRecords mRuimRecords; + RuimCard mRuimCard; + MyHandler h; + ArrayList <FeatureCode> mPendingMMIs = new ArrayList<FeatureCode>(); + RuimPhoneBookInterfaceManager mRuimPhoneBookInterfaceManager; + RuimSmsInterfaceManager mRuimSmsInterfaceManager; + PhoneSubInfo mSubInfo; + + protected RegistrantList mNvLoadedRegistrants = new RegistrantList(); + private String mEsn; + private String mMeid; + + Registrant mPostDialHandler; + + + //***** Constructors + public CDMAPhone(Context context, CommandsInterface ci, PhoneNotifier notifier) { + this(context,ci,notifier, false); + } + + public CDMAPhone(Context context, CommandsInterface ci, PhoneNotifier notifier, + boolean unitTestMode) { + super(notifier, context, unitTestMode); + + h = new MyHandler(); + mCM = ci; + + mCM.setPhoneType(RILConstants.CDMA_PHONE); + mCT = new CdmaCallTracker(this); + mSST = new CdmaServiceStateTracker (this); + mSMS = new CdmaSMSDispatcher(this); + mIccFileHandler = new RuimFileHandler(this); + mRuimRecords = new RuimRecords(this); + mDataConnection = new CdmaDataConnectionTracker (this); + mRuimCard = new RuimCard(this); + mRuimPhoneBookInterfaceManager = new RuimPhoneBookInterfaceManager(this); + mRuimSmsInterfaceManager = new RuimSmsInterfaceManager(this); + mSubInfo = new PhoneSubInfo(this); + + mCM.registerForAvailable(h, EVENT_RADIO_AVAILABLE, null); + mRuimRecords.registerForRecordsLoaded(h, EVENT_RUIM_RECORDS_LOADED, null); + mCM.registerForOffOrNotAvailable(h, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null); + mCM.registerForOn(h, EVENT_RADIO_ON, null); + mCM.setOnSuppServiceNotification(h, EVENT_SSN, null); + mCM.setOnCallRing(h, EVENT_CALL_RING, null); + mSST.registerForNetworkAttach(h, EVENT_REGISTERED_TO_NETWORK, null); + mCM.registerForNVReady(h, EVENT_NV_READY, null); + + //Change the system setting + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.CURRENT_ACTIVE_PHONE, RILConstants.CDMA_PHONE); + } + + public void dispose() { + synchronized(PhoneProxy.lockForRadioTechnologyChange) { + + //Unregister from all former registered events + mRuimRecords.unregisterForRecordsLoaded(h); //EVENT_RUIM_RECORDS_LOADED + mCM.unregisterForAvailable(h); //EVENT_RADIO_AVAILABLE + mCM.unregisterForOffOrNotAvailable(h); //EVENT_RADIO_OFF_OR_NOT_AVAILABLE + mCM.unregisterForOn(h); //EVENT_RADIO_ON + mCM.unregisterForNVReady(h); //EVENT_NV_READY + mSST.unregisterForNetworkAttach(h); //EVENT_REGISTERED_TO_NETWORK + mCM.unSetOnSuppServiceNotification(h); + mCM.unSetOnCallRing(h); + + //Force all referenced classes to unregister their former registered events + mCT.dispose(); + mDataConnection.dispose(); + mSST.dispose(); + mSMS.dispose(); + mIccFileHandler.dispose(); // instance of RuimFileHandler + mRuimRecords.dispose(); + mRuimCard.dispose(); + mRuimPhoneBookInterfaceManager.dispose(); + mRuimSmsInterfaceManager.dispose(); + mSubInfo.dispose(); + } + } + + public void removeReferences() { + this.mRuimPhoneBookInterfaceManager = null; + this.mRuimSmsInterfaceManager = null; + this.mSMS = null; + this.mSubInfo = null; + this.mRuimRecords = null; + this.mIccFileHandler = null; + this.mRuimCard = null; + this.mDataConnection = null; + this.mCT = null; + this.mSST = null; + } + + protected void finalize() { + if(LOCAL_DEBUG) Log.d(LOG_TAG, "CDMAPhone finalized"); + } + + + //***** Overridden from Phone + public ServiceState getServiceState() { + return mSST.ss; + } + + public Phone.State + getState() { + return mCT.state; + } + + public String + getPhoneName() { + return "CDMA"; + } + + public boolean canTransfer() { + Log.e(LOG_TAG, "canTransfer: not possible in CDMA"); + return false; + } + + public CdmaCall + getRingingCall() { + return mCT.ringingCall; + } + + public void setMute(boolean muted) { + mCT.setMute(muted); + } + + public boolean getMute() { + return mCT.getMute(); + } + + public void conference() throws CallStateException { + // three way calls in CDMA will be handled by feature codes + Log.e(LOG_TAG, "conference: not possible in CDMA"); + } + + public void enableEnhancedVoicePrivacy(boolean enable, Message onComplete) { + this.mCM.setPreferredVoicePrivacy(enable, onComplete); + } + + public void getEnhancedVoicePrivacy(Message onComplete) { + this.mCM.getPreferredVoicePrivacy(onComplete); + } + + public void clearDisconnected() { + mCT.clearDisconnected(); + } + + public DataActivityState getDataActivityState() { + DataActivityState ret = DataActivityState.NONE; + + if (mSST.getCurrentCdmaDataConnectionState() != ServiceState.RADIO_TECHNOLOGY_UNKNOWN) { + + switch (mDataConnection.getActivity()) { + case DATAIN: + ret = DataActivityState.DATAIN; + break; + + case DATAOUT: + ret = DataActivityState.DATAOUT; + break; + + case DATAINANDOUT: + ret = DataActivityState.DATAINANDOUT; + break; + } + } + return ret; + } + + /*package*/ void + notifySignalStrength() { + mNotifier.notifySignalStrength(this); + } + + public Connection + dial (String dialString) throws CallStateException { + // Need to make sure dialString gets parsed properly + String newDialString = PhoneNumberUtils.stripSeparators(dialString); + + FeatureCode fc = FeatureCode.newFromDialString(newDialString, this); + if (LOCAL_DEBUG) Log.d(LOG_TAG, + "dialing w/ fc '" + fc + "'..."); + // check for feature code + if (fc == null) { + // check if call in progress + if (!mCT.foregroundCall.isIdle()) { + FeatureCode digits = new FeatureCode(this); + // use dial number as poundString + digits.poundString = newDialString; + mPendingMMIs.add(fc); + mMmiRegistrants.notifyRegistrants(new AsyncResult(null, fc, null)); + digits.processCode(); + return null; + } else { + return mCT.dial(newDialString); + } + } else { + mPendingMMIs.add(fc); + mMmiRegistrants.notifyRegistrants(new AsyncResult(null, fc, null)); + fc.processCode(); + + // FIXME should this return null or something else? + return null; + } + } + + public int getSignalStrengthASU() { + return mSST.rssi == 99 ? -1 : mSST.rssi; + } + + public boolean + getMessageWaitingIndicator() { + Log.e(LOG_TAG, "method getMessageWaitingIndicator is NOT supported in CDMA!"); + return false; + } + + public List<? extends MmiCode> + getPendingMmiCodes() { + Log.e(LOG_TAG, "method getPendingMmiCodes is NOT supported in CDMA!"); + return null; + } + + public void registerForSuppServiceNotification( + Handler h, int what, Object obj) { + Log.e(LOG_TAG, "method registerForSuppServiceNotification is NOT supported in CDMA!"); + } + + public CdmaCall getBackgroundCall() { + return mCT.backgroundCall; + } + + public String getGateway(String apnType) { + return mDataConnection.getGateway(); + } + + public boolean handleInCallMmiCommands(String dialString) { + Log.e(LOG_TAG, "method handleInCallMmiCommands is NOT supported in CDMA!"); + return false; + } + + public int enableApnType(String type) { + // This request is mainly used to enable MMS APN + // In CDMA there is no need to enable/disable a different APN for MMS + Log.d(LOG_TAG, "Request to enableApnType("+type+")"); + if (TextUtils.equals(type, Phone.APN_TYPE_MMS)) { + return Phone.APN_ALREADY_ACTIVE; + } else { + return Phone.APN_REQUEST_FAILED; + } + } + + public int disableApnType(String type) { + // This request is mainly used to disable MMS APN + // In CDMA there is no need to enable/disable a different APN for MMS + Log.d(LOG_TAG, "Request to disableApnType("+type+")"); + if (TextUtils.equals(type, Phone.APN_TYPE_MMS)) { + return Phone.APN_REQUEST_STARTED; + } else { + return Phone.APN_REQUEST_FAILED; + } + } + + public String getActiveApn() { + Log.d(LOG_TAG, "Request to getActiveApn()"); + return null; + } + + public void + setNetworkSelectionModeAutomatic(Message response) { + Log.e(LOG_TAG, "method setNetworkSelectionModeAutomatic is NOT supported in CDMA!"); + } + + public void unregisterForSuppServiceNotification(Handler h) { + Log.e(LOG_TAG, "method unregisterForSuppServiceNotification is NOT supported in CDMA!"); + } + + public void + acceptCall() throws CallStateException { + mCT.acceptCall(); + } + + public void + rejectCall() throws CallStateException { + mCT.rejectCall(); + } + + public void + switchHoldingAndActive() throws CallStateException { + mCT.switchWaitingOrHoldingAndActive(); + } + + public String getLine1Number() { + return mRuimRecords.getMdnNumber(); + } + + public void getCallWaiting(Message onComplete) { + mCM.queryCallWaiting(CommandsInterface.SERVICE_CLASS_VOICE, onComplete); + } + + public void + setRadioPower(boolean power) { + mSST.setRadioPower(power); + } + + public String getEsn() { + return mEsn; + } + + public String getMeid() { + return mMeid; + } + + //returns MEID in CDMA + public String getDeviceId() { + return getMeid(); + } + + public String getDeviceSvn() { + Log.d(LOG_TAG, "getDeviceSvn(): return 0"); + return "0"; + } + + public String getSubscriberId() { + Log.e(LOG_TAG, "method getSubscriberId for IMSI is NOT supported in CDMA!"); + return null; + } + + public boolean canConference() { + Log.e(LOG_TAG, "canConference: not possible in CDMA"); + return false; + } + + public String getInterfaceName(String apnType) { + return mDataConnection.getInterfaceName(); + } + + public CellLocation getCellLocation() { + return mSST.cellLoc; + } + + public boolean disableDataConnectivity() { + return mDataConnection.setDataEnabled(false); + } + + public CdmaCall getForegroundCall() { + return mCT.foregroundCall; + } + + public void + selectNetworkManually(com.android.internal.telephony.gsm.NetworkInfo network, + Message response) { + Log.e(LOG_TAG, "selectNetworkManually: not possible in CDMA"); + } + + public void setOnPostDialCharacter(Handler h, int what, Object obj) { + Log.e(LOG_TAG, "setOnPostDialCharacter: not possible in CDMA"); + } + + public boolean handlePinMmi(String dialString) { + Log.e(LOG_TAG, "method handlePinMmi is NOT supported in CDMA!"); + return false; + } + + public boolean isDataConnectivityPossible() { + boolean noData = mDataConnection.getDataEnabled() && + getDataConnectionState() == DataState.DISCONNECTED; + return !noData && getIccCard().getState() == IccCard.State.READY && + getServiceState().getState() == ServiceState.STATE_IN_SERVICE && + (mDataConnection.getDataOnRoamingEnabled() || !getServiceState().getRoaming()); + } + + public void setLine1Number(String alphaTag, String number, Message onComplete) { + Log.e(LOG_TAG, "setLine1Number: not possible in CDMA"); + } + + public String[] getDnsServers(String apnType) { + return mDataConnection.getDnsServers(); + } + + public IccCard getIccCard() { + return mRuimCard; + } + + public String getIccSerialNumber() { + return mRuimRecords.iccid; + } + + public void setCallWaiting(boolean enable, Message onComplete) { + Log.e(LOG_TAG, "method setCallWaiting is NOT supported in CDMA!"); + } + + public void updateServiceLocation(Message response) { + mSST.getLacAndCid(response); + } + + public void setDataRoamingEnabled(boolean enable) { + mDataConnection.setDataOnRoamingEnabled(enable); + } + + public String getIpAddress(String apnType) { + return mDataConnection.getIpAddress(); + } + + public void + getNeighboringCids(Message response) { + // WINK:TODO: implement after Cupcake merge + mCM.getNeighboringCids(response); // workaround. + } + + public DataState getDataConnectionState() { + DataState ret = DataState.DISCONNECTED; + + if ((SystemProperties.get("adb.connected", "").length() > 0) + && (SystemProperties.get("android.net.use-adb-networking", "") + .length() > 0)) { + // We're connected to an ADB host and we have USB networking + // turned on. No matter what the radio state is, + // we report data connected + + ret = DataState.CONNECTED; + } else if (mSST.getCurrentCdmaDataConnectionState() + == ServiceState.RADIO_TECHNOLOGY_UNKNOWN) { + // If we're out of service, open TCP sockets may still work + // but no data will flow + ret = DataState.DISCONNECTED; + } else { + switch (mDataConnection.getState()) { + case FAILED: + case IDLE: + ret = DataState.DISCONNECTED; + break; + + case CONNECTED: + case DISCONNECTING: + if ( mCT.state != Phone.State.IDLE + && !mSST.isConcurrentVoiceAndData()) { + ret = DataState.SUSPENDED; + } else { + ret = DataState.CONNECTED; + } + break; + + case INITING: + case CONNECTING: + case SCANNING: + ret = DataState.CONNECTING; + break; + } + } + + return ret; + } + + public void sendUssdResponse(String ussdMessge) { + Log.e(LOG_TAG, "sendUssdResponse: not possible in CDMA"); + } + + public void sendDtmf(char c) { + if (!PhoneNumberUtils.is12Key(c)) { + Log.e(LOG_TAG, + "sendDtmf called with invalid character '" + c + "'"); + } else { + if (mCT.state == Phone.State.OFFHOOK) { + mCM.sendDtmf(c, null); + } + } + } + + public void startDtmf(char c) { + if (!PhoneNumberUtils.is12Key(c)) { + Log.e(LOG_TAG, + "startDtmf called with invalid character '" + c + "'"); + } else { + mCM.startDtmf(c, null); + } + } + + public void stopDtmf() { + mCM.stopDtmf(null); + } + + public void getAvailableNetworks(Message response) { + Log.e(LOG_TAG, "getAvailableNetworks: not possible in CDMA"); + } + + public String[] getActiveApnTypes() { + String[] result; + Log.d(LOG_TAG, "Request to getActiveApn()"); + result = new String[1]; + result[0] = Phone.APN_TYPE_DEFAULT; + return result; + } + + public void setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode, Message onComplete) { + Log.e(LOG_TAG, "getAvailableNetworks: not possible in CDMA"); + } + + public void enableLocationUpdates() { + mSST.enableLocationUpdates(); + } + + /** + * @deprecated + */ + public void getPdpContextList(Message response) { + getDataCallList(response); + } + + public void getDataCallList(Message response) { + mCM.getDataCallList(response); + } + + public boolean getDataRoamingEnabled() { + return mDataConnection.getDataOnRoamingEnabled(); + } + + public List<DataConnection> getCurrentDataConnectionList () { + return mDataConnection.getAllDataConnections(); + } + + public void setVoiceMailNumber(String alphaTag, + String voiceMailNumber, + Message onComplete) { + //mSIMRecords.setVoiceMailNumber(alphaTag, voiceMailNumber, onComplete); + //TODO: Where do we have to store this value has to be clarified with QC + } + + public String getVoiceMailNumber() { + //TODO: Where can we get this value has to be clarified with QC + //return mSIMRecords.getVoiceMailNumber(); +// throw new RuntimeException(); + return "12345"; + } + + public String getVoiceMailAlphaTag() { + // TODO: Where can we get this value has to be clarified with QC. + String ret = "";//TODO: Remove = "", if we know where to get this value. + + //ret = mSIMRecords.getVoiceMailAlphaTag(); + + if (ret == null || ret.length() == 0) { + return mContext.getText( + com.android.internal.R.string.defaultVoiceMailAlphaTag).toString(); + } + + return ret; + } + + public boolean enableDataConnectivity() { + return mDataConnection.setDataEnabled(true); + } + + public void disableLocationUpdates() { + mSST.disableLocationUpdates(); + } + + public boolean getIccRecordsLoaded() { + return mRuimRecords.getRecordsLoaded(); + } + + public void getCallForwardingOption(int commandInterfaceCFReason, Message onComplete) { + Log.e(LOG_TAG, "getCallForwardingOption: not possible in CDMA"); + } + + public void setCallForwardingOption(int commandInterfaceCFAction, + int commandInterfaceCFReason, + String dialingNumber, + int timerSeconds, + Message onComplete) { + Log.e(LOG_TAG, "setCallForwardingOption: not possible in CDMA"); + } + + public void + getOutgoingCallerIdDisplay(Message onComplete) { + Log.e(LOG_TAG, "getOutgoingCallerIdDisplay: not possible in CDMA"); + } + + public boolean + getCallForwardingIndicator() { + Log.e(LOG_TAG, "getCallForwardingIndicator: not possible in CDMA"); + return false; + } + + public void explicitCallTransfer() { + Log.e(LOG_TAG, "explicitCallTransfer: not possible in CDMA"); + } + + public String getLine1AlphaTag() { + Log.e(LOG_TAG, "getLine1AlphaTag: not possible in CDMA"); + return null; + } + + /** + * Notify any interested party of a Phone state change. + */ + /*package*/ void notifyPhoneStateChanged() { + mNotifier.notifyPhoneState(this); + } + + /** + * Notifies registrants (ie, activities in the Phone app) about + * changes to call state (including Phone and Connection changes). + */ + /*package*/ void notifyCallStateChanged() { + /* we'd love it if this was package-scoped*/ + super.notifyCallStateChangedP(); + } + + void notifyServiceStateChanged(ServiceState ss) { + super.notifyServiceStateChangedP(ss); + } + + void notifyLocationChanged() { + mNotifier.notifyCellLocation(this); + } + + /*package*/ void notifyNewRingingConnection(Connection c) { + /* we'd love it if this was package-scoped*/ + super.notifyNewRingingConnectionP(c); + } + + /** + * Notifiy registrants of a RING event. + */ + void notifyIncomingRing() { + AsyncResult ar = new AsyncResult(null, this, null); + mIncomingRingRegistrants.notifyRegistrants(ar); + } + + /*package*/ void notifyDisconnect(Connection cn) { + mDisconnectRegistrants.notifyResult(cn); + } + + void notifyUnknownConnection() { + mUnknownConnectionRegistrants.notifyResult(this); + } + + /*package*/ void + updateMessageWaitingIndicator(boolean mwi) { + // this also calls notifyMessageWaitingIndicator() + mRuimRecords.setVoiceMessageWaiting(1, mwi ? -1 : 0); + } + + + /** + * Removes the given FC from the pending list and notifies + * registrants that it is complete. + * @param fc FC that is done + */ + /*package*/ void onMMIDone(FeatureCode fc) { + /* Only notify complete if it's on the pending list. + * Otherwise, it's already been handled (eg, previously canceled). + * The exception is cancellation of an incoming USSD-REQUEST, which is + * not on the list. + */ + if (mPendingMMIs.remove(fc)) { + mMmiCompleteRegistrants.notifyRegistrants( + new AsyncResult(null, fc, null)); + } + } + + //***** Inner Classes + class MyHandler extends Handler { + MyHandler() { + } + + MyHandler(Looper l) { + super(l); + } + + public void handleMessage(Message msg) { + AsyncResult ar; + Message onComplete; + + switch(msg.what) { + case EVENT_RADIO_AVAILABLE: { + mCM.getBasebandVersion(obtainMessage(EVENT_GET_BASEBAND_VERSION_DONE)); + + mCM.getDeviceIdentity(obtainMessage(EVENT_GET_DEVICE_IDENTITY_DONE)); + } + break; + + case EVENT_GET_BASEBAND_VERSION_DONE:{ + ar = (AsyncResult)msg.obj; + + if (ar.exception != null) { + break; + } + + if (LOCAL_DEBUG) Log.d(LOG_TAG, "Baseband version: " + ar.result); + setSystemProperty(PROPERTY_BASEBAND_VERSION, (String)ar.result); + } + break; + + case EVENT_GET_DEVICE_IDENTITY_DONE:{ + ar = (AsyncResult)msg.obj; + + if (ar.exception != null) { + break; + } + String[] respId = (String[])ar.result; + mEsn = respId[2]; + mMeid = respId[3]; + } + break; + + case EVENT_RUIM_RECORDS_LOADED:{ + Log.d(LOG_TAG, "Event EVENT_RUIM_RECORDS_LOADED Received"); + } + break; + + case EVENT_RADIO_OFF_OR_NOT_AVAILABLE:{ + Log.d(LOG_TAG, "Event EVENT_RADIO_OFF_OR_NOT_AVAILABLE Received"); + } + break; + + case EVENT_RADIO_ON:{ + Log.d(LOG_TAG, "Event EVENT_RADIO_ON Received"); + } + break; + + case EVENT_SSN:{ + Log.d(LOG_TAG, "Event EVENT_SSN Received"); + } + break; + + case EVENT_CALL_RING:{ + Log.d(LOG_TAG, "Event EVENT_CALL_RING Received"); + } + break; + + case EVENT_REGISTERED_TO_NETWORK:{ + Log.d(LOG_TAG, "Event EVENT_REGISTERED_TO_NETWORK Received"); + } + break; + + case EVENT_NV_READY:{ + Log.d(LOG_TAG, "Event EVENT_NV_READY Received"); + //Inform the Service State Tracker + mNvLoadedRegistrants.notifyRegistrants(); + } + break; + + default:{ + throw new RuntimeException("unexpected event not handled"); + } + } + } + } + + /** + * Retrieves the PhoneSubInfo of the CDMAPhone + */ + public PhoneSubInfo getPhoneSubInfo(){ + return mSubInfo; + } + + /** + * Retrieves the IccSmsInterfaceManager of the CDMAPhone + */ + public IccSmsInterfaceManager getIccSmsInterfaceManager(){ + return mRuimSmsInterfaceManager; + } + + /** + * Retrieves the IccPhoneBookInterfaceManager of the CDMAPhone + */ + public IccPhoneBookInterfaceManager getIccPhoneBookInterfaceManager(){ + return mRuimPhoneBookInterfaceManager; + } + + public void registerForNvLoaded(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + mNvLoadedRegistrants.add(r); + } + + public void unregisterForNvLoaded(Handler h) { + mNvLoadedRegistrants.remove(h); + } + + // override for allowing access from other classes of this package + /** + * {@inheritDoc} + */ + public final void setSystemProperty(String property, String value) { + super.setSystemProperty(property, value); + } + + /** + * {@inheritDoc} + */ + public Handler getHandler(){ + return h; + } + + /** + * {@inheritDoc} + */ + public IccFileHandler getIccFileHandler(){ + return this.mIccFileHandler; + } + + /** + * Set the TTY mode of the CDMAPhone + */ + public void setTTYModeEnabled(boolean enable, Message onComplete) { + this.mCM.setTTYModeEnabled(enable, onComplete); +} + + /** + * Queries the TTY mode of the CDMAPhone + */ + public void queryTTYModeEnabled(Message onComplete) { + this.mCM.queryTTYModeEnabled(onComplete); + } + + /** + * Activate or deactivate cell broadcast SMS. + * + * @param activate + * 0 = activate, 1 = deactivate + * @param response + * Callback message is empty on completion + */ + public void activateCellBroadcastSms(int activate, Message response) { + mSMS.activateCellBroadcastSms(activate, response); + } + + /** + * Query the current configuration of cdma cell broadcast SMS. + * + * @param response + * Callback message is empty on completion + */ + public void getCellBroadcastSmsConfig(Message response){ + mSMS.getCellBroadcastSmsConfig(response); + } + + /** + * Configure cdma cell broadcast SMS. + * + * @param response + * Callback message is empty on completion + */ + public void setCellBroadcastSmsConfig(int[] configValuesArray, Message response){ + mSMS.setCellBroadcastConfig(configValuesArray, response); + } +} diff --git a/telephony/java/com/android/internal/telephony/cdma/CallFailCause.java b/telephony/java/com/android/internal/telephony/cdma/CallFailCause.java new file mode 100644 index 0000000..ea557b2 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/CallFailCause.java @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +/** + * Call fail causes from TS 24.008 . + * These are mostly the cause codes we need to distinguish for the UI. + * See 22.001 Annex F.4 for mapping of cause codes to local tones. + * + * {@hide} + * + */ +public interface CallFailCause { + static final int NORMAL_CLEARING = 16; + // Busy Tone + static final int USER_BUSY = 17; + +// // No Tone +// static final int NUMBER_CHANGED = 22; +// static final int STATUS_ENQUIRY = 30; + static final int NORMAL_UNSPECIFIED = 31; +// +// // Congestion Tone +// static final int NO_CIRCUIT_AVAIL = 34; +// static final int TEMPORARY_FAILURE = 41; +// static final int SWITCHING_CONGESTION = 42; +// static final int CHANNEL_NOT_AVAIL = 44; +// static final int QOS_NOT_AVAIL = 49; +// static final int BEARER_NOT_AVAIL = 58; +// +// // others +// static final int ACM_LIMIT_EXCEEDED = 68; +// static final int CALL_BARRED = 240; +// static final int FDN_BLOCKED = 241; + static final int ERROR_UNSPECIFIED = 0xffff; +} diff --git a/telephony/java/com/android/internal/telephony/cdma/CdmaCall.java b/telephony/java/com/android/internal/telephony/cdma/CdmaCall.java new file mode 100644 index 0000000..34514d9 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/CdmaCall.java @@ -0,0 +1,209 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import java.util.ArrayList; +import java.util.List; + +import com.android.internal.telephony.Call; +import com.android.internal.telephony.CallStateException; +import com.android.internal.telephony.Connection; +import com.android.internal.telephony.DriverCall; +import com.android.internal.telephony.Phone; + +/** + * {@hide} + */ +public final class CdmaCall extends Call { + /*************************** Instance Variables **************************/ + + /*package*/ ArrayList<Connection> connections = new ArrayList<Connection>(); + /*package*/ State state = State.IDLE; + /*package*/ CdmaCallTracker owner; + + /***************************** Class Methods *****************************/ + + static State + stateFromDCState (DriverCall.State dcState) { + switch (dcState) { + case ACTIVE: return State.ACTIVE; + case HOLDING: return State.HOLDING; + case DIALING: return State.DIALING; + case ALERTING: return State.ALERTING; + case INCOMING: return State.INCOMING; + case WAITING: return State.WAITING; + default: throw new RuntimeException ("illegal call state:" + dcState); + } + } + + + /****************************** Constructors *****************************/ + /*package*/ + CdmaCall (CdmaCallTracker owner) { + this.owner = owner; + } + + public void dispose() { + } + + /************************** Overridden from Call *************************/ + public List<Connection> + getConnections() { + // FIXME should return Collections.unmodifiableList(); + return connections; + } + + public State + getState() { + return state; + } + + public Phone + getPhone() { + //TODO, see GsmCall + return null; + } + + public boolean isMultiparty() { + return connections.size() > 1; + } + + /** Please note: if this is the foreground call and a + * background call exists, the background call will be resumed + * because an AT+CHLD=1 will be sent + */ + public void + hangup() throws CallStateException { + owner.hangup(this); + } + + public String + toString() { + return state.toString(); + } + + //***** Called from CdmaConnection + + /*package*/ void + attach(Connection conn, DriverCall dc) { + connections.add(conn); + + state = stateFromDCState (dc.state); + } + + /*package*/ void + attachFake(Connection conn, State state) { + connections.add(conn); + + this.state = state; + } + + /** + * Called by CdmaConnection when it has disconnected + */ + void + connectionDisconnected(CdmaConnection conn) { + if (state != State.DISCONNECTED) { + /* If only disconnected connections remain, we are disconnected*/ + + boolean hasOnlyDisconnectedConnections = true; + + for (int i = 0, s = connections.size() ; i < s; i ++) { + if (connections.get(i).getState() + != State.DISCONNECTED + ) { + hasOnlyDisconnectedConnections = false; + break; + } + } + + if (hasOnlyDisconnectedConnections) { + state = State.DISCONNECTED; + } + } + } + + + /*package*/ void + detach(CdmaConnection conn) { + connections.remove(conn); + + if (connections.size() == 0) { + state = State.IDLE; + } + } + + /*package*/ boolean + update (CdmaConnection conn, DriverCall dc) { + State newState; + boolean changed = false; + + newState = stateFromDCState(dc.state); + + if (newState != state) { + state = newState; + changed = true; + } + + return changed; + } + + /** + * @return true if there's no space in this call for additional + * connections to be added via "conference" + */ + /*package*/ boolean + isFull() { + return connections.size() == CdmaCallTracker.MAX_CONNECTIONS_PER_CALL; + } + + //***** Called from CdmaCallTracker + + + /** + * Called when this Call is being hung up locally (eg, user pressed "end") + * Note that at this point, the hangup request has been dispatched to the radio + * but no response has yet been received so update() has not yet been called + */ + void + onHangupLocal() { + for (int i = 0, s = connections.size() + ; i < s; i++ + ) { + CdmaConnection cn = (CdmaConnection)connections.get(i); + + cn.onHangupLocal(); + } + } + + /** + * Called when it's time to clean up disconnected Connection objects + */ + void clearDisconnected() { + for (int i = connections.size() - 1 ; i >= 0 ; i--) { + CdmaConnection cn = (CdmaConnection)connections.get(i); + + if (cn.getState() == State.DISCONNECTED) { + connections.remove(i); + } + } + + if (connections.size() == 0) { + state = State.IDLE; + } + } +} diff --git a/telephony/java/com/android/internal/telephony/cdma/CdmaCallTracker.java b/telephony/java/com/android/internal/telephony/cdma/CdmaCallTracker.java new file mode 100644 index 0000000..a1d362f --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/CdmaCallTracker.java @@ -0,0 +1,860 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.os.Registrant; +import android.os.RegistrantList; +import android.telephony.PhoneNumberUtils; +import android.telephony.ServiceState; +import android.util.Log; + +import com.android.internal.telephony.CallStateException; +import com.android.internal.telephony.CallTracker; +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.Connection; +import com.android.internal.telephony.DriverCall; +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneProxy; + +import java.util.ArrayList; +import java.util.List; + +/** + * {@hide} + */ +public final class CdmaCallTracker extends CallTracker { + static final String LOG_TAG = "CDMA"; + + private static final boolean REPEAT_POLLING = false; + + private static final boolean DBG_POLL = false; + + //***** Constants + + static final int MAX_CONNECTIONS = 1; // only 1 connection allowed in CDMA + static final int MAX_CONNECTIONS_PER_CALL = 1; // only 1 connection allowed per call + + //***** Instance Variables + + CdmaConnection connections[] = new CdmaConnection[MAX_CONNECTIONS]; + RegistrantList voiceCallEndedRegistrants = new RegistrantList(); + RegistrantList voiceCallStartedRegistrants = new RegistrantList(); + + + // connections dropped durin last poll + ArrayList<CdmaConnection> droppedDuringPoll + = new ArrayList<CdmaConnection>(MAX_CONNECTIONS); + + CdmaCall ringingCall = new CdmaCall(this); + // A call that is ringing or (call) waiting + CdmaCall foregroundCall = new CdmaCall(this); + CdmaCall backgroundCall = new CdmaCall(this); + + CdmaConnection pendingMO; + boolean hangupPendingMO; + + CDMAPhone phone; + + boolean desiredMute = false; // false = mute off + + Phone.State state = Phone.State.IDLE; + + +// boolean needsPoll; + + + + //***** Events + + //***** Constructors + CdmaCallTracker(CDMAPhone phone) { + this.phone = phone; + cm = phone.mCM; + cm.registerForCallStateChanged(this, EVENT_CALL_STATE_CHANGE, null); + cm.registerForOn(this, EVENT_RADIO_AVAILABLE, null); + cm.registerForNotAvailable(this, EVENT_RADIO_NOT_AVAILABLE, null); + } + + public void dispose() { + cm.unregisterForCallStateChanged(this); + cm.unregisterForOn(this); + cm.unregisterForNotAvailable(this); + + for(CdmaConnection c : connections) { + try { + if(c != null) hangup(c); + } catch (CallStateException ex) { + Log.e(LOG_TAG, "unexpected error on hangup during dispose"); + } + } + + try { + if(pendingMO != null) hangup(pendingMO); + } catch (CallStateException ex) { + Log.e(LOG_TAG, "unexpected error on hangup during dispose"); + } + + clearDisconnected(); + + } + + protected void finalize() { + Log.d(LOG_TAG, "CdmaCallTracker finalized"); + } + + //***** Instance Methods + + //***** Public Methods + public void registerForVoiceCallStarted(Handler h, int what, Object obj) { + Registrant r = new Registrant(h, what, obj); + voiceCallStartedRegistrants.add(r); + } + public void unregisterForVoiceCallStarted(Handler h) { + voiceCallStartedRegistrants.remove(h); + } + + public void registerForVoiceCallEnded(Handler h, int what, Object obj) { + Registrant r = new Registrant(h, what, obj); + voiceCallEndedRegistrants.add(r); + } + + public void unregisterForVoiceCallEnded(Handler h) { + voiceCallEndedRegistrants.remove(h); + } + + private void + fakeHoldForegroundBeforeDial() { + List<Connection> connCopy; + + // We need to make a copy here, since fakeHoldBeforeDial() + // modifies the lists, and we don't want to reverse the order + connCopy = (List<Connection>) foregroundCall.connections.clone(); + + for (int i = 0, s = connCopy.size() ; i < s ; i++) { + CdmaConnection conn = (CdmaConnection)connCopy.get(i); + + conn.fakeHoldBeforeDial(); + } + } + + /** + * clirMode is one of the CLIR_ constants + */ + Connection + dial (String dialString, int clirMode) throws CallStateException { + // note that this triggers call state changed notif + clearDisconnected(); + + if (!canDial()) { + throw new CallStateException("cannot dial in current state"); + } + + // The new call must be assigned to the foreground call. + // That call must be idle, so place anything that's + // there on hold + if (foregroundCall.getState() == CdmaCall.State.ACTIVE) { + // this will probably be done by the radio anyway + // but the dial might fail before this happens + // and we need to make sure the foreground call is clear + // for the newly dialed connection + switchWaitingOrHoldingAndActive(); + + // Fake local state so that + // a) foregroundCall is empty for the newly dialed connection + // b) hasNonHangupStateChanged remains false in the + // next poll, so that we don't clear a failed dialing call + fakeHoldForegroundBeforeDial(); + } + + if (foregroundCall.getState() != CdmaCall.State.IDLE) { + //we should have failed in !canDial() above before we get here + throw new CallStateException("cannot dial in current state"); + } + + pendingMO = new CdmaConnection(phone.getContext(), dialString, this, foregroundCall); + hangupPendingMO = false; + + if (pendingMO.address == null || pendingMO.address.length() == 0 + || pendingMO.address.indexOf(PhoneNumberUtils.WILD) >= 0 + ) { + // Phone number is invalid + pendingMO.cause = Connection.DisconnectCause.INVALID_NUMBER; + + // handlePollCalls() will notice this call not present + // and will mark it as dropped. + pollCallsWhenSafe(); + } else { + // Always unmute when initiating a new call + setMute(false); + + cm.dial(pendingMO.address, clirMode, obtainCompleteMessage()); + } + + updatePhoneState(); + phone.notifyCallStateChanged(); + + return pendingMO; + } + + + Connection + dial (String dialString) throws CallStateException { + return dial(dialString, CommandsInterface.CLIR_DEFAULT); + } + + void + acceptCall () throws CallStateException { + // FIXME if SWITCH fails, should retry with ANSWER + // in case the active/holding call disappeared and this + // is no longer call waiting + + if (ringingCall.getState() == CdmaCall.State.INCOMING) { + Log.i("phone", "acceptCall: incoming..."); + // Always unmute when answering a new call + setMute(false); + cm.acceptCall(obtainCompleteMessage()); + } else if (ringingCall.getState() == CdmaCall.State.WAITING) { + setMute(false); + switchWaitingOrHoldingAndActive(); + } else { + throw new CallStateException("phone not ringing"); + } + } + + void + rejectCall () throws CallStateException { + // AT+CHLD=0 means "release held or UDUB" + // so if the phone isn't ringing, this could hang up held + if (ringingCall.getState().isRinging()) { + cm.rejectCall(obtainCompleteMessage()); + } else { + throw new CallStateException("phone not ringing"); + } + } + + void + switchWaitingOrHoldingAndActive() throws CallStateException { + // Should we bother with this check? + if (ringingCall.getState() == CdmaCall.State.INCOMING) { + throw new CallStateException("cannot be in the incoming state"); + } else { + cm.sendCDMAFeatureCode("", obtainCompleteMessage(EVENT_SWITCH_RESULT)); + } + } + + void + conference() throws CallStateException { + // three way calls in CDMA will be handled by feature codes + Log.e(LOG_TAG, "conference: not possible in CDMA"); + } + + void + explicitCallTransfer() throws CallStateException { + cm.explicitCallTransfer(obtainCompleteMessage(EVENT_ECT_RESULT)); + } + + void + clearDisconnected() { + internalClearDisconnected(); + + updatePhoneState(); + phone.notifyCallStateChanged(); + } + + boolean + canConference() { + return foregroundCall.getState() == CdmaCall.State.ACTIVE + && backgroundCall.getState() == CdmaCall.State.HOLDING + && !backgroundCall.isFull() + && !foregroundCall.isFull(); + } + + boolean + canDial() { + boolean ret; + int serviceState = phone.getServiceState().getState(); + + ret = (serviceState != ServiceState.STATE_POWER_OFF) && + pendingMO == null + && !ringingCall.isRinging() + && (!foregroundCall.getState().isAlive() + || !backgroundCall.getState().isAlive()); + + return ret; + } + + boolean + canTransfer() { + Log.e(LOG_TAG, "canTransfer: not possible in CDMA"); + return false; + } + + //***** Private Instance Methods + + private void + internalClearDisconnected() { + ringingCall.clearDisconnected(); + foregroundCall.clearDisconnected(); + backgroundCall.clearDisconnected(); + } + + /** + * Obtain a message to use for signalling "invoke getCurrentCalls() when + * this operation and all other pending operations are complete + */ + private Message + obtainCompleteMessage() { + return obtainCompleteMessage(EVENT_OPERATION_COMPLETE); + } + + /** + * Obtain a message to use for signalling "invoke getCurrentCalls() when + * this operation and all other pending operations are complete + */ + private Message + obtainCompleteMessage(int what) { + pendingOperations++; + lastRelevantPoll = null; + needsPoll = true; + + if (DBG_POLL) log("obtainCompleteMessage: pendingOperations=" + + pendingOperations + ", needsPoll=" + needsPoll); + + return obtainMessage(what); + } + + private void + operationComplete() { + pendingOperations--; + + if (DBG_POLL) log("operationComplete: pendingOperations=" + + pendingOperations + ", needsPoll=" + needsPoll); + + if (pendingOperations == 0 && needsPoll) { + lastRelevantPoll = obtainMessage(EVENT_POLL_CALLS_RESULT); + cm.getCurrentCalls(lastRelevantPoll); + } else if (pendingOperations < 0) { + // this should never happen + Log.e(LOG_TAG,"CdmaCallTracker.pendingOperations < 0"); + pendingOperations = 0; + } + } + + + + private void + updatePhoneState() { + Phone.State oldState = state; + + if (ringingCall.isRinging()) { + state = Phone.State.RINGING; + } else if (pendingMO != null || + !(foregroundCall.isIdle() && backgroundCall.isIdle())) { + state = Phone.State.OFFHOOK; + } else { + state = Phone.State.IDLE; + } + + if (state == Phone.State.IDLE && oldState != state) { + voiceCallEndedRegistrants.notifyRegistrants( + new AsyncResult(null, null, null)); + } else if (oldState == Phone.State.IDLE && oldState != state) { + voiceCallStartedRegistrants.notifyRegistrants ( + new AsyncResult(null, null, null)); + } + + if (state != oldState) { + phone.notifyPhoneStateChanged(); + } + } + + // ***** Overwritten from CallTracker + + protected void + handlePollCalls(AsyncResult ar) { + List polledCalls; + + if (ar.exception == null) { + polledCalls = (List)ar.result; + } else if (isCommandExceptionRadioNotAvailable(ar.exception)) { + // just a dummy empty ArrayList to cause the loop + // to hang up all the calls + polledCalls = new ArrayList(); + } else { + // Radio probably wasn't ready--try again in a bit + // But don't keep polling if the channel is closed + pollCallsAfterDelay(); + return; + } + + Connection newRinging = null; //or waiting + boolean hasNonHangupStateChanged = false; // Any change besides + // a dropped connection + boolean needsPollDelay = false; + boolean unknownConnectionAppeared = false; + + for (int i = 0, curDC = 0, dcSize = polledCalls.size() + ; i < connections.length; i++) { + CdmaConnection conn = connections[i]; + DriverCall dc = null; + + // polledCall list is sparse + if (curDC < dcSize) { + dc = (DriverCall) polledCalls.get(curDC); + + if (dc.index == i+1) { + curDC++; + } else { + dc = null; + } + } + + if (DBG_POLL) log("poll: conn[i=" + i + "]=" + + conn+", dc=" + dc); + + if (conn == null && dc != null) { + // Connection appeared in CLCC response that we don't know about + if (pendingMO != null && pendingMO.compareTo(dc)) { + + if (DBG_POLL) log("poll: pendingMO=" + pendingMO); + + // It's our pending mobile originating call + connections[i] = pendingMO; + pendingMO.index = i; + pendingMO.update(dc); + pendingMO = null; + + // Someone has already asked to hangup this call + if (hangupPendingMO) { + hangupPendingMO = false; + try { + if (Phone.DEBUG_PHONE) log( + "poll: hangupPendingMO, hangup conn " + i); + hangup(connections[i]); + } catch (CallStateException ex) { + Log.e(LOG_TAG, "unexpected error on hangup"); + } + + // Do not continue processing this poll + // Wait for hangup and repoll + return; + } + } else { + connections[i] = new CdmaConnection(phone.getContext(), dc, this, i); + + // it's a ringing call + if (connections[i].getCall() == ringingCall) { + newRinging = connections[i]; + } else { + // Something strange happened: a call appeared + // which is neither a ringing call or one we created. + // Either we've crashed and re-attached to an existing + // call, or something else (eg, SIM) initiated the call. + + Log.i(LOG_TAG,"Phantom call appeared " + dc); + + // If it's a connected call, set the connect time so that + // it's non-zero. It may not be accurate, but at least + // it won't appear as a Missed Call. + if (dc.state != DriverCall.State.ALERTING + && dc.state != DriverCall.State.DIALING) { + connections[i].connectTime = System.currentTimeMillis(); + } + + unknownConnectionAppeared = true; + } + } + hasNonHangupStateChanged = true; + } else if (conn != null && dc == null) { + // Connection missing in CLCC response that we were + // tracking. + droppedDuringPoll.add(conn); + // Dropped connections are removed from the CallTracker + // list but kept in the Call list + connections[i] = null; + } else if (conn != null && dc != null && !conn.compareTo(dc)) { + // Connection in CLCC response does not match what + // we were tracking. Assume dropped call and new call + + droppedDuringPoll.add(conn); + connections[i] = new CdmaConnection (phone.getContext(), dc, this, i); + + if (connections[i].getCall() == ringingCall) { + newRinging = connections[i]; + } // else something strange happened + hasNonHangupStateChanged = true; + } else if (conn != null && dc != null) { /* implicit conn.compareTo(dc) */ + boolean changed; + changed = conn.update(dc); + hasNonHangupStateChanged = hasNonHangupStateChanged || changed; + } + + if (REPEAT_POLLING) { + if (dc != null) { + // FIXME with RIL, we should not need this anymore + if ((dc.state == DriverCall.State.DIALING + /*&& cm.getOption(cm.OPTION_POLL_DIALING)*/) + || (dc.state == DriverCall.State.ALERTING + /*&& cm.getOption(cm.OPTION_POLL_ALERTING)*/) + || (dc.state == DriverCall.State.INCOMING + /*&& cm.getOption(cm.OPTION_POLL_INCOMING)*/) + || (dc.state == DriverCall.State.WAITING + /*&& cm.getOption(cm.OPTION_POLL_WAITING)*/) + ) { + // Sometimes there's no unsolicited notification + // for state transitions + needsPollDelay = true; + } + } + } + } + + // This is the first poll after an ATD. + // We expect the pending call to appear in the list + // If it does not, we land here + if (pendingMO != null) { + Log.d(LOG_TAG,"Pending MO dropped before poll fg state:" + + foregroundCall.getState()); + + droppedDuringPoll.add(pendingMO); + pendingMO = null; + hangupPendingMO = false; + } + + if (newRinging != null) { + phone.notifyNewRingingConnection(newRinging); + } + + // clear the "local hangup" and "missed/rejected call" + // cases from the "dropped during poll" list + // These cases need no "last call fail" reason + for (int i = droppedDuringPoll.size() - 1; i >= 0 ; i--) { + CdmaConnection conn = droppedDuringPoll.get(i); + + if (conn.isIncoming() && conn.getConnectTime() == 0) { + // Missed or rejected call + Connection.DisconnectCause cause; + if (conn.cause == Connection.DisconnectCause.LOCAL) { + cause = Connection.DisconnectCause.INCOMING_REJECTED; + } else { + cause = Connection.DisconnectCause.INCOMING_MISSED; + } + + if (Phone.DEBUG_PHONE) { + log("missed/rejected call, conn.cause=" + conn.cause); + log("setting cause to " + cause); + } + droppedDuringPoll.remove(i); + conn.onDisconnect(cause); + } else if (conn.cause == Connection.DisconnectCause.LOCAL) { + // Local hangup + droppedDuringPoll.remove(i); + conn.onDisconnect(Connection.DisconnectCause.LOCAL); + } else if (conn.cause == Connection.DisconnectCause.INVALID_NUMBER) { + droppedDuringPoll.remove(i); + conn.onDisconnect(Connection.DisconnectCause.INVALID_NUMBER); + } + } + + // Any non-local disconnects: determine cause + if (droppedDuringPoll.size() > 0) { + cm.getLastCallFailCause( + obtainNoPollCompleteMessage(EVENT_GET_LAST_CALL_FAIL_CAUSE)); + } + + if (needsPollDelay) { + pollCallsAfterDelay(); + } + + // Cases when we can no longer keep disconnected Connection's + // with their previous calls + // 1) the phone has started to ring + // 2) A Call/Connection object has changed state... + // we may have switched or held or answered (but not hung up) + if (newRinging != null || hasNonHangupStateChanged) { + internalClearDisconnected(); + } + + updatePhoneState(); + + if (unknownConnectionAppeared) { + phone.notifyUnknownConnection(); + } + + if (hasNonHangupStateChanged || newRinging != null) { + phone.notifyCallStateChanged(); + } + + //dumpState(); + } + + //***** Called from CdmaConnection + /*package*/ void + hangup (CdmaConnection conn) throws CallStateException { + if (conn.owner != this) { + throw new CallStateException ("CdmaConnection " + conn + + "does not belong to CdmaCallTracker " + this); + } + + if (conn == pendingMO) { + // We're hanging up an outgoing call that doesn't have it's + // GSM index assigned yet + + if (Phone.DEBUG_PHONE) log("hangup: set hangupPendingMO to true"); + hangupPendingMO = true; + } else { + try { + cm.hangupConnection (conn.getCDMAIndex(), obtainCompleteMessage()); + } catch (CallStateException ex) { + // Ignore "connection not found" + // Call may have hung up already + Log.w(LOG_TAG,"CdmaCallTracker WARN: hangup() on absent connection " + + conn); + } + } + + conn.onHangupLocal(); + } + + /*package*/ void + separate (CdmaConnection conn) throws CallStateException { + if (conn.owner != this) { + throw new CallStateException ("CdmaConnection " + conn + + "does not belong to CdmaCallTracker " + this); + } + try { + cm.separateConnection (conn.getCDMAIndex(), + obtainCompleteMessage(EVENT_SEPARATE_RESULT)); + } catch (CallStateException ex) { + // Ignore "connection not found" + // Call may have hung up already + Log.w(LOG_TAG,"CdmaCallTracker WARN: separate() on absent connection " + + conn); + } + } + + //***** Called from CDMAPhone + + /*package*/ void + setMute(boolean mute) { + desiredMute = mute; + cm.setMute(desiredMute, null); + } + + /*package*/ boolean + getMute() { + return desiredMute; + } + + + //***** Called from CdmaCall + + /* package */ void + hangup (CdmaCall call) throws CallStateException { + if (call.getConnections().size() == 0) { + throw new CallStateException("no connections in call"); + } + + if (call == ringingCall) { + if (Phone.DEBUG_PHONE) log("(ringing) hangup waiting or background"); + cm.hangupWaitingOrBackground(obtainCompleteMessage()); + } else if (call == foregroundCall) { + if (call.isDialingOrAlerting()) { + if (Phone.DEBUG_PHONE) { + log("(foregnd) hangup dialing or alerting..."); + } + hangup((CdmaConnection)(call.getConnections().get(0))); + } else { + hangupForegroundResumeBackground(); + } + } else if (call == backgroundCall) { + if (ringingCall.isRinging()) { + if (Phone.DEBUG_PHONE) { + log("hangup all conns in background call"); + } + hangupAllConnections(call); + } else { + hangupWaitingOrBackground(); + } + } else { + throw new RuntimeException ("CdmaCall " + call + + "does not belong to CdmaCallTracker " + this); + } + + call.onHangupLocal(); + } + + /* package */ + void hangupWaitingOrBackground() { + if (Phone.DEBUG_PHONE) log("hangupWaitingOrBackground"); + cm.hangupWaitingOrBackground(obtainCompleteMessage()); + } + + /* package */ + void hangupForegroundResumeBackground() { + if (Phone.DEBUG_PHONE) log("hangupForegroundResumeBackground"); + cm.hangupForegroundResumeBackground(obtainCompleteMessage()); + } + + void hangupConnectionByIndex(CdmaCall call, int index) + throws CallStateException { + int count = call.connections.size(); + for (int i = 0; i < count; i++) { + CdmaConnection cn = (CdmaConnection)call.connections.get(i); + if (cn.getCDMAIndex() == index) { + cm.hangupConnection(index, obtainCompleteMessage()); + return; + } + } + + throw new CallStateException("no gsm index found"); + } + + void hangupAllConnections(CdmaCall call) throws CallStateException{ + try { + int count = call.connections.size(); + for (int i = 0; i < count; i++) { + CdmaConnection cn = (CdmaConnection)call.connections.get(i); + cm.hangupConnection(cn.getCDMAIndex(), obtainCompleteMessage()); + } + } catch (CallStateException ex) { + Log.e(LOG_TAG, "hangupConnectionByIndex caught " + ex); + } + } + + /* package */ + CdmaConnection getConnectionByIndex(CdmaCall call, int index) + throws CallStateException { + int count = call.connections.size(); + for (int i = 0; i < count; i++) { + CdmaConnection cn = (CdmaConnection)call.connections.get(i); + if (cn.getCDMAIndex() == index) { + return cn; + } + } + + return null; + } + + private Phone.SuppService getFailedService(int what) { + switch (what) { + case EVENT_SWITCH_RESULT: + return Phone.SuppService.SWITCH; + case EVENT_CONFERENCE_RESULT: + return Phone.SuppService.CONFERENCE; + case EVENT_SEPARATE_RESULT: + return Phone.SuppService.SEPARATE; + case EVENT_ECT_RESULT: + return Phone.SuppService.TRANSFER; + } + return Phone.SuppService.UNKNOWN; + } + + private void handleRadioNotAvailable() { + // handlePollCalls will clear out its + // call list when it gets the CommandException + // error result from this + pollCallsWhenSafe(); + } + + //****** Overridden from Handler + + public void + handleMessage (Message msg) { + AsyncResult ar; + + switch (msg.what) { + case EVENT_POLL_CALLS_RESULT:{ + Log.d(LOG_TAG, "Event EVENT_POLL_CALLS_RESULT Received"); + ar = (AsyncResult)msg.obj; + + if(msg == lastRelevantPoll) { + if(DBG_POLL) log( + "handle EVENT_POLL_CALL_RESULT: set needsPoll=F"); + needsPoll = false; + lastRelevantPoll = null; + handlePollCalls((AsyncResult)msg.obj); + } + } + break; + + case EVENT_OPERATION_COMPLETE: + ar = (AsyncResult)msg.obj; + operationComplete(); + break; + + case EVENT_SWITCH_RESULT: + ar = (AsyncResult)msg.obj; + operationComplete(); + break; + + case EVENT_GET_LAST_CALL_FAIL_CAUSE: + int causeCode; + ar = (AsyncResult)msg.obj; + + operationComplete(); + + if (ar.exception != null) { + // An exception occurred...just treat the disconnect + // cause as "normal" + causeCode = CallFailCause.NORMAL_CLEARING; + Log.i(LOG_TAG, + "Exception during getLastCallFailCause, assuming normal disconnect"); + } else { + causeCode = ((int[])ar.result)[0]; + } + + for (int i = 0, s = droppedDuringPoll.size() + ; i < s ; i++ + ) { + CdmaConnection conn = droppedDuringPoll.get(i); + + conn.onRemoteDisconnect(causeCode); + } + + updatePhoneState(); + + phone.notifyCallStateChanged(); + droppedDuringPoll.clear(); + break; + + case EVENT_CALL_STATE_CHANGE: + pollCallsWhenSafe(); + break; + + case EVENT_RADIO_AVAILABLE: + handleRadioAvailable(); + break; + + case EVENT_RADIO_NOT_AVAILABLE: + handleRadioNotAvailable(); + break; + + default:{ + throw new RuntimeException("unexpected event not handled"); + } + } + } + + protected void log(String msg) { + Log.d(LOG_TAG, "[CdmaCallTracker] " + msg); + } + +} diff --git a/telephony/java/com/android/internal/telephony/cdma/CdmaConnection.java b/telephony/java/com/android/internal/telephony/cdma/CdmaConnection.java new file mode 100644 index 0000000..cdad4a7 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/CdmaConnection.java @@ -0,0 +1,705 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import com.android.internal.telephony.*; +import android.content.Context; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.os.PowerManager; +import android.os.Registrant; +import android.os.SystemClock; +import android.util.Config; +import android.util.Log; +import android.telephony.PhoneNumberUtils; +import android.telephony.ServiceState; + + +/** + * {@hide} + */ +public class CdmaConnection extends Connection { + static final String LOG_TAG = "CDMA"; + + //***** Instance Variables + + CdmaCallTracker owner; + CdmaCall parent; + + + String address; // MAY BE NULL!!! + String dialString; // outgoing calls only + String postDialString; // outgoing calls only + boolean isIncoming; + boolean disconnected; + + int index; // index in CdmaCallTracker.connections[], -1 if unassigned + + /* + * These time/timespan values are based on System.currentTimeMillis(), + * i.e., "wall clock" time. + */ + long createTime; + long connectTime; + long disconnectTime; + + /* + * These time/timespan values are based on SystemClock.elapsedRealTime(), + * i.e., time since boot. They are appropriate for comparison and + * calculating deltas. + */ + long connectTimeReal; + long duration; + long holdingStartTime; // The time when the Connection last transitioned + // into HOLDING + + int nextPostDialChar; // index into postDialString + + DisconnectCause cause = DisconnectCause.NOT_DISCONNECTED; + PostDialState postDialState = PostDialState.NOT_STARTED; + int numberPresentation = Connection.PRESENTATION_ALLOWED; + + Handler h; + + private PowerManager.WakeLock mPartialWakeLock; + + //***** Event Constants + static final int EVENT_DTMF_DONE = 1; + static final int EVENT_PAUSE_DONE = 2; + static final int EVENT_NEXT_POST_DIAL = 3; + static final int EVENT_WAKE_LOCK_TIMEOUT = 4; + + //***** Constants + static final int PAUSE_DELAY_FIRST_MILLIS = 100; + static final int PAUSE_DELAY_MILLIS = 3 * 1000; + static final int WAKE_LOCK_TIMEOUT_MILLIS = 60*1000; + + //***** Inner Classes + + class MyHandler extends Handler { + MyHandler(Looper l) {super(l);} + + public void + handleMessage(Message msg) { + + switch (msg.what) { + case EVENT_NEXT_POST_DIAL: + case EVENT_DTMF_DONE: + case EVENT_PAUSE_DONE: + processNextPostDialChar(); + break; + case EVENT_WAKE_LOCK_TIMEOUT: + releaseWakeLock(); + break; + } + } + } + + //***** Constructors + + /** This is probably an MT call that we first saw in a CLCC response */ + /*package*/ + CdmaConnection (Context context, DriverCall dc, CdmaCallTracker ct, int index) { + createWakeLock(context); + acquireWakeLock(); + + owner = ct; + h = new MyHandler(owner.getLooper()); + + address = dc.number; + + isIncoming = dc.isMT; + createTime = System.currentTimeMillis(); + numberPresentation = dc.numberPresentation; + + this.index = index; + + parent = parentFromDCState (dc.state); + parent.attach(this, dc); + } + + /** This is an MO call, created when dialing */ + /*package*/ + CdmaConnection (Context context, String dialString, CdmaCallTracker ct, CdmaCall parent) { + createWakeLock(context); + acquireWakeLock(); + + owner = ct; + h = new MyHandler(owner.getLooper()); + + this.dialString = dialString; + + this.address = PhoneNumberUtils.extractNetworkPortion(dialString); + this.postDialString = PhoneNumberUtils.extractPostDialPortion(dialString); + + index = -1; + + isIncoming = false; + createTime = System.currentTimeMillis(); + + this.parent = parent; + parent.attachFake(this, CdmaCall.State.DIALING); + } + + public void dispose() { + } + + static boolean + equalsHandlesNulls (Object a, Object b) { + return (a == null) ? (b == null) : a.equals (b); + } + + /*package*/ boolean + compareTo(DriverCall c) { + // On mobile originated (MO) calls, the phone number may have changed + // due to a SIM Toolkit call control modification. + // + // We assume we know when MO calls are created (since we created them) + // and therefore don't need to compare the phone number anyway. + if (! (isIncoming || c.isMT)) return true; + + // ... but we can compare phone numbers on MT calls, and we have + // no control over when they begin, so we might as well + + String cAddress = PhoneNumberUtils.stringFromStringAndTOA(c.number, c.TOA); + return isIncoming == c.isMT && equalsHandlesNulls(address, cAddress); + } + + public String + toString() { + return (isIncoming ? "incoming" : "outgoing"); + } + + public String getAddress() { + return address; + } + + public CdmaCall getCall() { + return parent; + } + + public long getCreateTime() { + return createTime; + } + + public long getConnectTime() { + return connectTime; + } + + public long getDisconnectTime() { + return disconnectTime; + } + + public long getDurationMillis() { + if (connectTimeReal == 0) { + return 0; + } else if (duration == 0) { + return SystemClock.elapsedRealtime() - connectTimeReal; + } else { + return duration; + } + } + + public long getHoldDurationMillis() { + if (getState() != CdmaCall.State.HOLDING) { + // If not holding, return 0 + return 0; + } else { + return SystemClock.elapsedRealtime() - holdingStartTime; + } + } + + public DisconnectCause getDisconnectCause() { + return cause; + } + + public boolean isIncoming() { + return isIncoming; + } + + public CdmaCall.State getState() { + if (disconnected) { + return CdmaCall.State.DISCONNECTED; + } else { + return super.getState(); + } + } + + public void hangup() throws CallStateException { + if (!disconnected) { + owner.hangup(this); + } else { + throw new CallStateException ("disconnected"); + } + } + + public void separate() throws CallStateException { + if (!disconnected) { + owner.separate(this); + } else { + throw new CallStateException ("disconnected"); + } + } + + public PostDialState getPostDialState() { + return postDialState; + } + + public void proceedAfterWaitChar() { + if (postDialState != PostDialState.WAIT) { + Log.w(LOG_TAG, "CdmaConnection.proceedAfterWaitChar(): Expected " + + "getPostDialState() to be WAIT but was " + postDialState); + return; + } + + setPostDialState(PostDialState.STARTED); + + processNextPostDialChar(); + } + + public void proceedAfterWildChar(String str) { + if (postDialState != PostDialState.WILD) { + Log.w(LOG_TAG, "CdmaConnection.proceedAfterWaitChar(): Expected " + + "getPostDialState() to be WILD but was " + postDialState); + return; + } + + setPostDialState(PostDialState.STARTED); + + if (false) { + boolean playedTone = false; + int len = (str != null ? str.length() : 0); + + for (int i=0; i<len; i++) { + char c = str.charAt(i); + Message msg = null; + + if (i == len-1) { + msg = h.obtainMessage(EVENT_DTMF_DONE); + } + + if (PhoneNumberUtils.is12Key(c)) { + owner.cm.sendDtmf(c, msg); + playedTone = true; + } + } + + if (!playedTone) { + processNextPostDialChar(); + } + } else { + // make a new postDialString, with the wild char replacement string + // at the beginning, followed by the remaining postDialString. + + StringBuilder buf = new StringBuilder(str); + buf.append(postDialString.substring(nextPostDialChar)); + postDialString = buf.toString(); + nextPostDialChar = 0; + if (Phone.DEBUG_PHONE) { + log("proceedAfterWildChar: new postDialString is " + + postDialString); + } + + processNextPostDialChar(); + } + } + + public void cancelPostDial() { + setPostDialState(PostDialState.CANCELLED); + } + + /** + * Called when this Connection is being hung up locally (eg, user pressed "end") + * Note that at this point, the hangup request has been dispatched to the radio + * but no response has yet been received so update() has not yet been called + */ + void + onHangupLocal() { + cause = DisconnectCause.LOCAL; + } + + DisconnectCause + disconnectCauseFromCode(int causeCode) { + /** + * See 22.001 Annex F.4 for mapping of cause codes + * to local tones + */ + + switch (causeCode) { + case CallFailCause.USER_BUSY: + return DisconnectCause.BUSY; + case CallFailCause.ERROR_UNSPECIFIED: + case CallFailCause.NORMAL_CLEARING: + default: + CDMAPhone phone = owner.phone; + int serviceState = phone.getServiceState().getState(); + if (serviceState == ServiceState.STATE_POWER_OFF) { + return DisconnectCause.POWER_OFF; + } else if (serviceState == ServiceState.STATE_OUT_OF_SERVICE + || serviceState == ServiceState.STATE_EMERGENCY_ONLY ) { + return DisconnectCause.OUT_OF_SERVICE; + } else if (phone.mCM.getRadioState() != CommandsInterface.RadioState.NV_READY + && phone.getIccCard().getState() != RuimCard.State.READY) { + return DisconnectCause.ICC_ERROR; + } else { + return DisconnectCause.NORMAL; + } + } + } + + /*package*/ void + onRemoteDisconnect(int causeCode) { + onDisconnect(disconnectCauseFromCode(causeCode)); + } + + /** Called when the radio indicates the connection has been disconnected */ + /*package*/ void + onDisconnect(DisconnectCause cause) { + this.cause = cause; + + if (!disconnected) { + index = -1; + + disconnectTime = System.currentTimeMillis(); + duration = SystemClock.elapsedRealtime() - connectTimeReal; + disconnected = true; + + if (Config.LOGD) Log.d(LOG_TAG, + "[CDMAConn] onDisconnect: cause=" + cause); + + owner.phone.notifyDisconnect(this); + + if (parent != null) { + parent.connectionDisconnected(this); + } + } + releaseWakeLock(); + } + + // Returns true if state has changed, false if nothing changed + /*package*/ boolean + update (DriverCall dc) { + CdmaCall newParent; + boolean changed = false; + boolean wasConnectingInOrOut = isConnectingInOrOut(); + boolean wasHolding = (getState() == CdmaCall.State.HOLDING); + + newParent = parentFromDCState(dc.state); + + if (!equalsHandlesNulls(address, dc.number)) { + if (Phone.DEBUG_PHONE) log("update: phone # changed!"); + address = dc.number; + changed = true; + } + + if (newParent != parent) { + if (parent != null) { + parent.detach(this); + } + newParent.attach(this, dc); + parent = newParent; + changed = true; + } else { + boolean parentStateChange; + parentStateChange = parent.update (this, dc); + changed = changed || parentStateChange; + } + + /** Some state-transition events */ + + if (Phone.DEBUG_PHONE) log( + "update: parent=" + parent + + ", hasNewParent=" + (newParent != parent) + + ", wasConnectingInOrOut=" + wasConnectingInOrOut + + ", wasHolding=" + wasHolding + + ", isConnectingInOrOut=" + isConnectingInOrOut() + + ", changed=" + changed); + + + if (wasConnectingInOrOut && !isConnectingInOrOut()) { + onConnectedInOrOut(); + } + + if (changed && !wasHolding && (getState() == CdmaCall.State.HOLDING)) { + // We've transitioned into HOLDING + onStartedHolding(); + } + + return changed; + } + + /** + * Called when this Connection is in the foregroundCall + * when a dial is initiated. + * We know we're ACTIVE, and we know we're going to end up + * HOLDING in the backgroundCall + */ + void + fakeHoldBeforeDial() { + if (parent != null) { + parent.detach(this); + } + + parent = owner.backgroundCall; + parent.attachFake(this, CdmaCall.State.HOLDING); + + onStartedHolding(); + } + + /*package*/ int + getCDMAIndex() throws CallStateException { + if (index >= 0) { + return index + 1; + } else { + throw new CallStateException ("CDMA connection index not assigned"); + } + } + + /** + * An incoming or outgoing call has connected + */ + void + onConnectedInOrOut() { + connectTime = System.currentTimeMillis(); + connectTimeReal = SystemClock.elapsedRealtime(); + duration = 0; + + // bug #678474: incoming call interpreted as missed call, even though + // it sounds like the user has picked up the call. + if (Phone.DEBUG_PHONE) { + log("onConnectedInOrOut: connectTime=" + connectTime); + } + + if (!isIncoming) { + // outgoing calls only + processNextPostDialChar(); + } + releaseWakeLock(); + } + + private void + onStartedHolding() { + holdingStartTime = SystemClock.elapsedRealtime(); + } + /** + * Performs the appropriate action for a post-dial char, but does not + * notify application. returns false if the character is invalid and + * should be ignored + */ + private boolean + processPostDialChar(char c) { + if (PhoneNumberUtils.is12Key(c)) { + owner.cm.sendDtmf(c, h.obtainMessage(EVENT_DTMF_DONE)); + } else if (c == PhoneNumberUtils.PAUSE) { + // From TS 22.101: + + // "The first occurrence of the "DTMF Control Digits Separator" + // shall be used by the ME to distinguish between the addressing + // digits (i.e. the phone number) and the DTMF digits...." + + if (nextPostDialChar == 1) { + // The first occurrence. + // We don't need to pause here, but wait for just a bit anyway + h.sendMessageDelayed(h.obtainMessage(EVENT_PAUSE_DONE), + PAUSE_DELAY_FIRST_MILLIS); + } else { + // It continues... + // "Upon subsequent occurrences of the separator, the UE shall + // pause again for 3 seconds (\u00B1 20 %) before sending any + // further DTMF digits." + h.sendMessageDelayed(h.obtainMessage(EVENT_PAUSE_DONE), + PAUSE_DELAY_MILLIS); + } + } else if (c == PhoneNumberUtils.WAIT) { + setPostDialState(PostDialState.WAIT); + } else if (c == PhoneNumberUtils.WILD) { + setPostDialState(PostDialState.WILD); + } else { + return false; + } + + return true; + } + + public String + getRemainingPostDialString() { + if (postDialState == PostDialState.CANCELLED + || postDialState == PostDialState.COMPLETE + || postDialString == null + || postDialString.length() <= nextPostDialChar + ) { + return ""; + } + + return postDialString.substring(nextPostDialChar); + } + + @Override + protected void finalize() + { + /** + * It is understood that This finializer is not guaranteed + * to be called and the release lock call is here just in + * case there is some path that doesn't call onDisconnect + * and or onConnectedInOrOut. + */ + if (mPartialWakeLock.isHeld()) { + Log.e(LOG_TAG, "[CdmaConn] UNEXPECTED; mPartialWakeLock is held when finalizing."); + } + releaseWakeLock(); + } + + private void + processNextPostDialChar() { + char c = 0; + Registrant postDialHandler; + + if (postDialState == PostDialState.CANCELLED) { + //Log.v("CDMA", "##### processNextPostDialChar: postDialState == CANCELLED, bail"); + return; + } + + if (postDialString == null || + postDialString.length() <= nextPostDialChar) { + setPostDialState(PostDialState.COMPLETE); + + // notifyMessage.arg1 is 0 on complete + c = 0; + } else { + boolean isValid; + + setPostDialState(PostDialState.STARTED); + + c = postDialString.charAt(nextPostDialChar++); + + isValid = processPostDialChar(c); + + if (!isValid) { + // Will call processNextPostDialChar + h.obtainMessage(EVENT_NEXT_POST_DIAL).sendToTarget(); + // Don't notify application + Log.e("CDMA", "processNextPostDialChar: c=" + c + " isn't valid!"); + return; + } + } + + postDialHandler = owner.phone.mPostDialHandler; + + Message notifyMessage; + + if (postDialHandler != null && + (notifyMessage = postDialHandler.messageForRegistrant()) != null) { + // The AsyncResult.result is the Connection object + PostDialState state = postDialState; + AsyncResult ar = AsyncResult.forMessage(notifyMessage); + ar.result = this; + ar.userObj = state; + + // arg1 is the character that was/is being processed + notifyMessage.arg1 = c; + + notifyMessage.sendToTarget(); + } + } + + + /** "connecting" means "has never been ACTIVE" for both incoming + * and outgoing calls + */ + private boolean + isConnectingInOrOut() { + return parent == null || parent == owner.ringingCall + || parent.state == CdmaCall.State.DIALING + || parent.state == CdmaCall.State.ALERTING; + } + + private CdmaCall + parentFromDCState (DriverCall.State state) { + switch (state) { + case ACTIVE: + case DIALING: + case ALERTING: + return owner.foregroundCall; + //break; + + case HOLDING: + return owner.backgroundCall; + //break; + + case INCOMING: + case WAITING: + return owner.ringingCall; + //break; + + default: + throw new RuntimeException("illegal call state: " + state); + } + } + + /** + * Set post dial state and acquire wake lock while switching to "started" + * state, the wake lock will be released if state switches out of "started" + * state or after WAKE_LOCK_TIMEOUT_MILLIS. + * @param s new PostDialState + */ + private void setPostDialState(PostDialState s) { + if (postDialState != PostDialState.STARTED + && s == PostDialState.STARTED) { + acquireWakeLock(); + Message msg = h.obtainMessage(EVENT_WAKE_LOCK_TIMEOUT); + h.sendMessageDelayed(msg, WAKE_LOCK_TIMEOUT_MILLIS); + } else if (postDialState == PostDialState.STARTED + && s != PostDialState.STARTED) { + h.removeMessages(EVENT_WAKE_LOCK_TIMEOUT); + releaseWakeLock(); + } + postDialState = s; + } + + private void + createWakeLock(Context context) { + PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE); + mPartialWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, LOG_TAG); + } + + private void + acquireWakeLock() { + log("acquireWakeLock"); + mPartialWakeLock.acquire(); + } + + private void + releaseWakeLock() { + synchronized(mPartialWakeLock) { + if (mPartialWakeLock.isHeld()) { + log("releaseWakeLock"); + mPartialWakeLock.release(); + } + } + } + + private void log(String msg) { + Log.d(LOG_TAG, "[CDMAConn] " + msg); + } + + @Override + public int getNumberPresentation() { + return numberPresentation; + } +} diff --git a/telephony/java/com/android/internal/telephony/cdma/CdmaDataConnection.java b/telephony/java/com/android/internal/telephony/cdma/CdmaDataConnection.java new file mode 100644 index 0000000..2cbad78 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/CdmaDataConnection.java @@ -0,0 +1,318 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import android.os.*; +import android.util.EventLog; +import android.util.Log; + +import com.android.internal.telephony.CommandException; +import com.android.internal.telephony.DataConnection; +import com.android.internal.telephony.DataLink; +import com.android.internal.telephony.RILConstants; +import com.android.internal.telephony.TelephonyEventLog; + +/** + * {@hide} + * + */ +public class CdmaDataConnection extends DataConnection { + + private static final String LOG_TAG = "CDMA"; + private static final boolean DBG = true; + + /** Fail cause of last Data Call activate from RIL_LastDataCallActivateFailCause */ + private final static int PS_NET_DOWN_REASON_OPERATOR_DETERMINED_BARRING = 8; + private final static int PS_NET_DOWN_REASON_UNKNOWN_APN = 27; + private final static int PS_NET_DOWN_REASON_AUTH_FAILED = 29; + private final static int PS_NET_DOWN_REASON_OPTION_NOT_SUPPORTED = 32; + private final static int PS_NET_DOWN_REASON_OPTION_UNSUBSCRIBED = 33; + +/** It is likely that the number of error codes listed below will be removed + * in the foreseeable future. They have been added, but not agreed upon. + * + */ + private final static int PS_NET_DOWN_REASON_NOT_SPECIFIED = 0; + private final static int PS_NET_DOWN_REASON_CLOSE_IN_PROGRESS = 1; + private final static int PS_NET_DOWN_REASON_NW_INITIATED_TERMINATION = 2; + private final static int PS_NET_DOWN_REASON_APP_PREEMPTED = 3; + private final static int PS_NET_DOWN_REASON_LLC_SNDCP_FAILURE = 25; + private final static int PS_NET_DOWN_REASON_INSUFFICIENT_RESOURCES = 26; + private final static int PS_NET_DOWN_REASON_UNKNOWN_PDP = 28; + private final static int PS_NET_DOWN_REASON_GGSN_REJECT = 30; + private final static int PS_NET_DOWN_REASON_ACTIVATION_REJECT = 31; + private final static int PS_NET_DOWN_REASON_OPTION_TEMP_OOO = 34; + private final static int PS_NET_DOWN_REASON_NSAPI_ALREADY_USED = 35; + private final static int PS_NET_DOWN_REASON_REGULAR_DEACTIVATION = 36; + private final static int PS_NET_DOWN_REASON_QOS_NOT_ACCEPTED = 37; + private final static int PS_NET_DOWN_REASON_NETWORK_FAILURE = 38; + private final static int PS_NET_DOWN_REASON_UMTS_REATTACH_REQ = 39; + private final static int PS_NET_DOWN_REASON_TFT_SEMANTIC_ERROR = 41; + private final static int PS_NET_DOWN_REASON_TFT_SYNTAX_ERROR = 42; + private final static int PS_NET_DOWN_REASON_UNKNOWN_PDP_CONTEXT = 43; + private final static int PS_NET_DOWN_REASON_FILTER_SEMANTIC_ERROR = 44; + private final static int PS_NET_DOWN_REASON_FILTER_SYNTAX_ERROR = 45; + private final static int PS_NET_DOWN_REASON_PDP_WITHOUT_ACTIVE_TFT = 46; + private final static int PS_NET_DOWN_REASON_INVALID_TRANSACTION_ID = 81; + private final static int PS_NET_DOWN_REASON_MESSAGE_INCORRECT_SEMANTIC = 95; + private final static int PS_NET_DOWN_REASON_INVALID_MANDATORY_INFO = 96; + private final static int PS_NET_DOWN_REASON_MESSAGE_TYPE_UNSUPPORTED = 97; + private final static int PS_NET_DOWN_REASON_MSG_TYPE_NONCOMPATIBLE_STATE = 98; + private final static int PS_NET_DOWN_REASON_UNKNOWN_INFO_ELEMENT = 99; + private final static int PS_NET_DOWN_REASON_CONDITIONAL_IE_ERROR = 100; + private final static int PS_NET_DOWN_REASON_MSG_AND_PROTOCOL_STATE_UNCOMPATIBLE = 101; + private final static int PS_NET_DOWN_REASON_PROTOCOL_ERROR = 111; + private final static int PS_NET_DOWN_REASON_APN_TYPE_CONFLICT = 112; + private final static int PS_NET_DOWN_REASON_UNKNOWN_CAUSE_CODE = 113; + private final static int PS_NET_DOWN_REASON_INTERNAL_MIN = 200; + private final static int PS_NET_DOWN_REASON_INTERNAL_ERROR = 201; + private final static int PS_NET_DOWN_REASON_INTERNAL_CALL_ENDED = 202; + private final static int PS_NET_DOWN_REASON_INTERNAL_UNKNOWN_CAUSE_CODE = 203; + private final static int PS_NET_DOWN_REASON_INTERNAL_MAX = 204; + private final static int PS_NET_DOWN_REASON_CDMA_LOCK = 500; + private final static int PS_NET_DOWN_REASON_INTERCEPT = 501; + private final static int PS_NET_DOWN_REASON_REORDER = 502; + private final static int PS_NET_DOWN_REASON_REL_SO_REJ = 503; + private final static int PS_NET_DOWN_REASON_INCOM_CALL = 504; + private final static int PS_NET_DOWN_REASON_ALERT_STOP = 505; + private final static int PS_NET_DOWN_REASON_ACTIVATION = 506; + private final static int PS_NET_DOWN_REASON_MAX_ACCESS_PROBE = 507; + private final static int PS_NET_DOWN_REASON_CCS_NOT_SUPPORTED_BY_BS = 508; + private final static int PS_NET_DOWN_REASON_NO_RESPONSE_FROM_BS = 509; + private final static int PS_NET_DOWN_REASON_REJECTED_BY_BS = 510; + private final static int PS_NET_DOWN_REASON_INCOMPATIBLE = 511; + private final static int PS_NET_DOWN_REASON_ALREADY_IN_TC = 512; + private final static int PS_NET_DOWN_REASON_USER_CALL_ORIG_DURING_GPS = 513; + private final static int PS_NET_DOWN_REASON_USER_CALL_ORIG_DURING_SMS = 514; + private final static int PS_NET_DOWN_REASON_NO_CDMA_SRV = 515; + private final static int PS_NET_DOWN_REASON_CONF_FAILED = 1000; + private final static int PS_NET_DOWN_REASON_INCOM_REJ = 1001; + private final static int PS_NET_DOWN_REASON_NO_GW_SRV = 1002; + private final static int PS_NET_DOWN_REASON_CD_GEN_OR_BUSY = 1500; + private final static int PS_NET_DOWN_REASON_CD_BILL_OR_AUTH = 1501; + private final static int PS_NET_DOWN_REASON_CHG_HDR = 1502; + private final static int PS_NET_DOWN_REASON_EXIT_HDR = 1503; + private final static int PS_NET_DOWN_REASON_HDR_NO_SESSION = 1504; + private final static int PS_NET_DOWN_REASON_HDR_ORIG_DURING_GPS_FIX = 1505; + private final static int PS_NET_DOWN_REASON_HDR_CS_TIMEOUT = 1506; + private final static int PS_NET_DOWN_REASON_HDR_RELEASED_BY_CM = 1507; + private final static int PS_NET_DOWN_REASON_CLIENT_END = 2000; + private final static int PS_NET_DOWN_REASON_NO_SRV = 2001; + private final static int PS_NET_DOWN_REASON_FADE = 2002; + private final static int PS_NET_DOWN_REASON_REL_NORMAL = 2003; + private final static int PS_NET_DOWN_REASON_ACC_IN_PROG = 2004; + private final static int PS_NET_DOWN_REASON_ACC_FAIL = 2005; + private final static int PS_NET_DOWN_REASON_REDIR_OR_HANDOFF = 2006; + + // ***** Instance Variables + + // ***** Constructor + CdmaDataConnection(CDMAPhone phone) { + super(phone); + + if (DBG) log("CdmaDataConnection <constructor>"); + } + + /** + * Setup a data connection + * + * @param onCompleted + * notify success or not after down + */ + void connect(Message onCompleted) { + if (DBG) log("CdmaDataConnection Connecting..."); + + state = State.ACTIVATING; + onConnectCompleted = onCompleted; + createTime = -1; + lastFailTime = -1; + lastFailCause = FailCause.NONE; + receivedDisconnectReq = false; + phone.mCM.setupDataCall(Integer.toString(RILConstants.CDMA_PHONE), null, null, null, + null, obtainMessage(EVENT_SETUP_DATA_CONNECTION_DONE)); + } + + protected void disconnect(Message msg) { + onDisconnect = msg; + if (state == State.ACTIVE) { + if (phone.mCM.getRadioState().isOn()) { + phone.mCM.deactivateDataCall(cid, obtainMessage(EVENT_DEACTIVATE_DONE, msg)); + } + } else if (state == State.ACTIVATING) { + receivedDisconnectReq = true; + } else { + // state == INACTIVE. Nothing to do, so notify immediately. + notifyDisconnect(msg); + } + } + + + public String toString() { + return "State=" + state + " create=" + createTime + " lastFail=" + + lastFailTime + " lastFailCause=" + lastFailCause; + } + + + protected void notifyFail(FailCause cause, Message onCompleted) { + if (onCompleted == null) { + return; + } + state = State.INACTIVE; + lastFailCause = cause; + lastFailTime = System.currentTimeMillis(); + onConnectCompleted = null; + + if(DBG) { + log("Notify data connection fail at " + lastFailTime + + " due to " + lastFailCause); + } + + AsyncResult.forMessage(onCompleted, cause, new Exception()); + onCompleted.sendToTarget(); + } + + protected void notifySuccess(Message onCompleted) { + if (onCompleted == null) { + return; + } + + state = State.ACTIVE; + createTime = System.currentTimeMillis(); + onConnectCompleted = null; + onCompleted.arg1 = cid; + + if (DBG) log("Notify data connection success at " + createTime); + + AsyncResult.forMessage(onCompleted); + onCompleted.sendToTarget(); + } + + protected void notifyDisconnect(Message msg) { + if (DBG) log("Notify data connection disconnect"); + + if (msg != null) { + AsyncResult.forMessage(msg); + msg.sendToTarget(); + } + clearSettings(); + } + + protected void onLinkStateChanged(DataLink.LinkState linkState) { + switch (linkState) { + case LINK_UP: + notifySuccess(onConnectCompleted); + break; + + case LINK_DOWN: + case LINK_EXITED: + phone.mCM.getLastDataCallFailCause(obtainMessage(EVENT_GET_LAST_FAIL_DONE)); + break; + } + } + + protected FailCause getFailCauseFromRequest(int rilCause) { + FailCause cause; + + switch (rilCause) { + case PS_NET_DOWN_REASON_OPERATOR_DETERMINED_BARRING: + cause = FailCause.BARRED; + break; + case PS_NET_DOWN_REASON_AUTH_FAILED: + cause = FailCause.USER_AUTHENTICATION; + break; + case PS_NET_DOWN_REASON_OPTION_NOT_SUPPORTED: + cause = FailCause.SERVICE_OPTION_NOT_SUPPORTED; + break; + case PS_NET_DOWN_REASON_OPTION_UNSUBSCRIBED: + cause = FailCause.SERVICE_OPTION_NOT_SUBSCRIBED; + break; + default: + cause = FailCause.UNKNOWN; + } + return cause; + } + + protected void log(String s) { + Log.d(LOG_TAG, "[CdmaDataConnection] " + s); + } + + @Override + protected void onDeactivated(AsyncResult ar) { + notifyDisconnect((Message) ar.userObj); + if (DBG) log("CDMA Connection Deactivated"); + } + + @Override + protected void onSetupConnectionCompleted(AsyncResult ar) { + if (ar.exception != null) { + Log.e(LOG_TAG, "CdmaDataConnection Init failed " + ar.exception); + + if (receivedDisconnectReq) { + // Don't bother reporting the error if there's already a + // pending disconnect request, since DataConnectionTracker + // has already updated its state. + notifyDisconnect(onDisconnect); + } else { + if (ar.exception instanceof CommandException + && ((CommandException) (ar.exception)).getCommandError() + == CommandException.Error.RADIO_NOT_AVAILABLE) { + notifyFail(FailCause.RADIO_NOT_AVAILABLE, onConnectCompleted); + } else { + phone.mCM.getLastDataCallFailCause(obtainMessage(EVENT_GET_LAST_FAIL_DONE)); + } + } + } else { + if (receivedDisconnectReq) { + // Don't bother reporting success if there's already a + // pending disconnect request, since DataConnectionTracker + // has already updated its state. + disconnect(onDisconnect); + } else { + String[] response = ((String[]) ar.result); + cid = Integer.parseInt(response[0]); + + if (response.length > 2) { + interfaceName = response[1]; + ipAddress = response[2]; + String prefix = "net." + interfaceName + "."; + gatewayAddress = SystemProperties.get(prefix + "gw"); + dnsServers[0] = SystemProperties.get(prefix + "dns1"); + dnsServers[1] = SystemProperties.get(prefix + "dns2"); + if (DBG) { + log("interface=" + interfaceName + " ipAddress=" + ipAddress + + " gateway=" + gatewayAddress + " DNS1=" + dnsServers[0] + + " DNS2=" + dnsServers[1]); + } + + if (NULL_IP.equals(dnsServers[0]) && NULL_IP.equals(dnsServers[1]) + && !((CDMAPhone) phone).isDnsCheckDisabled()) { + // Work around a race condition where QMI does not fill in DNS: + // Deactivate PDP and let DataConnectionTracker retry. + EventLog.writeEvent(TelephonyEventLog.EVENT_LOG_BAD_DNS_ADDRESS, + dnsServers[0]); + phone.mCM.deactivateDataCall(cid, obtainMessage(EVENT_FORCE_RETRY)); + return; + } + } + + onLinkStateChanged(DataLink.LinkState.LINK_UP); + + if (DBG) log("CdmaDataConnection setup on cid = " + cid); + } + } + } +} diff --git a/telephony/java/com/android/internal/telephony/cdma/CdmaDataConnectionTracker.java b/telephony/java/com/android/internal/telephony/cdma/CdmaDataConnectionTracker.java new file mode 100644 index 0000000..84febf3 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/CdmaDataConnectionTracker.java @@ -0,0 +1,929 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import android.app.AlarmManager; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.SharedPreferences; +import android.net.NetworkInfo; +import android.net.wifi.WifiManager; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.INetStatService; +import android.os.Message; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.preference.PreferenceManager; +import android.provider.Checkin; +import android.provider.Settings; +import android.provider.Settings.SettingNotFoundException; +import android.telephony.ServiceState; +import android.telephony.TelephonyManager; +import android.util.EventLog; +import android.text.TextUtils; +import android.util.Log; + +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.DataConnection; +import com.android.internal.telephony.DataConnection.FailCause; +import com.android.internal.telephony.DataConnectionTracker; +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneProxy; +import com.android.internal.telephony.TelephonyEventLog; + +import java.util.ArrayList; + +/** + * WINK:TODO: In GsmDataConnectionTracker there are + * EventLog's used quite a few places maybe + * more need to be added in this file? + * + * {@hide} + */ +public final class CdmaDataConnectionTracker extends DataConnectionTracker { + private static final String LOG_TAG = "CDMA"; + private static final boolean DBG = true; + + //***** Instance Variables + + // Indicates baseband will not auto-attach + private boolean noAutoAttach = false; + long nextReconnectDelay = RECONNECT_DELAY_INITIAL_MILLIS; + private boolean mIsScreenOn = true; + + //useful for debugging + boolean failNextConnect = false; + + /** + * dataConnectionList holds all the Data connection + */ + private ArrayList<DataConnection> dataConnectionList; + + /** Currently active CdmaDataConnection */ + private CdmaDataConnection mActiveDataConnection; + + /** Defined cdma connection profiles */ + private static int EXTERNAL_NETWORK_DEFAULT_ID = 0; + private static int EXTERNAL_NETWORK_NUM_TYPES = 1; + + private boolean[] dataEnabled = new boolean[EXTERNAL_NETWORK_NUM_TYPES]; + + //***** Constants + + /** + * Pool size of CdmaDataConnection objects. + */ + private static final int DATA_CONNECTION_POOL_SIZE = 1; + + private static final int POLL_CONNECTION_MILLIS = 5 * 1000; + private static final String INTENT_RECONNECT_ALARM = "com.android.internal.telephony.cdma-reconnect"; + private static final String INTENT_RECONNECT_ALARM_EXTRA_REASON = "reason"; + + // Possibly promoate to base class, the only difference is + // the INTENT_RECONNECT_ALARM action is a different string. + // Do consider technology changes if it is promoted. + BroadcastReceiver mIntentReceiver = new BroadcastReceiver () + { + @Override + public void onReceive(Context context, Intent intent) + { + String action = intent.getAction(); + if (action.equals(Intent.ACTION_SCREEN_ON)) { + mIsScreenOn = true; + stopNetStatPoll(); + startNetStatPoll(); + } else if (action.equals(Intent.ACTION_SCREEN_OFF)) { + mIsScreenOn = false; + stopNetStatPoll(); + startNetStatPoll(); + } else if (action.equals((INTENT_RECONNECT_ALARM))) { + Log.d(LOG_TAG, "Data reconnect alarm. Previous state was " + state); + + String reason = intent.getStringExtra(INTENT_RECONNECT_ALARM_EXTRA_REASON); + if (state == State.FAILED) { + cleanUpConnection(false, reason); + } + trySetupData(reason); + } else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) { + final android.net.NetworkInfo networkInfo = (NetworkInfo) + intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO); + mIsWifiConnected = (networkInfo != null && networkInfo.isConnected()); + } else if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) { + final boolean enabled = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, + WifiManager.WIFI_STATE_UNKNOWN) == WifiManager.WIFI_STATE_ENABLED; + + if (!enabled) { + // when wifi got disabeled, the NETWORK_STATE_CHANGED_ACTION + // quit and wont report disconnected til next enalbing. + mIsWifiConnected = false; + } + } + } + }; + + + //***** Constructor + + CdmaDataConnectionTracker(CDMAPhone p) { + super(p); + + p.mCM.registerForAvailable (this, EVENT_RADIO_AVAILABLE, null); + p.mCM.registerForOffOrNotAvailable(this, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null); + p.mRuimRecords.registerForRecordsLoaded(this, EVENT_RECORDS_LOADED, null); + p.mCM.registerForNVReady(this, EVENT_NV_READY, null); + p.mCM.registerForDataStateChanged (this, EVENT_DATA_STATE_CHANGED, null); + p.mCT.registerForVoiceCallEnded (this, EVENT_VOICE_CALL_ENDED, null); + p.mCT.registerForVoiceCallStarted (this, EVENT_VOICE_CALL_STARTED, null); + p.mSST.registerForCdmaDataConnectionAttached(this, EVENT_TRY_SETUP_DATA, null); + p.mSST.registerForCdmaDataConnectionDetached(this, EVENT_CDMA_DATA_DETACHED, null); + p.mSST.registerForRoamingOn(this, EVENT_ROAMING_ON, null); + p.mSST.registerForRoamingOff(this, EVENT_ROAMING_OFF, null); + + this.netstat = INetStatService.Stub.asInterface(ServiceManager.getService("netstat")); + + IntentFilter filter = new IntentFilter(); + filter.addAction(INTENT_RECONNECT_ALARM); + filter.addAction(Intent.ACTION_SCREEN_ON); + filter.addAction(Intent.ACTION_SCREEN_OFF); + filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION); + filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); + + p.getContext().registerReceiver(mIntentReceiver, filter, null, p.h); + + mDataConnectionTracker = this; + + createAllDataConnectionList(); + + // This preference tells us 1) initial condition for "dataEnabled", + // and 2) whether the RIL will setup the baseband to auto-PS attach. + SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(phone.getContext()); + + dataEnabled[EXTERNAL_NETWORK_DEFAULT_ID] = + !sp.getBoolean(CDMAPhone.DATA_DISABLED_ON_BOOT_KEY, false); + noAutoAttach = !dataEnabled[EXTERNAL_NETWORK_DEFAULT_ID]; + } + + public void dispose() { + //Unregister from all events + phone.mCM.unregisterForAvailable(this); + phone.mCM.unregisterForOffOrNotAvailable(this); + ((CDMAPhone) phone).mRuimRecords.unregisterForRecordsLoaded(this); + phone.mCM.unregisterForNVReady(this); + phone.mCM.unregisterForDataStateChanged(this); + ((CDMAPhone) phone).mCT.unregisterForVoiceCallEnded(this); + ((CDMAPhone) phone).mCT.unregisterForVoiceCallStarted(this); + ((CDMAPhone) phone).mSST.unregisterForCdmaDataConnectionAttached(this); + ((CDMAPhone) phone).mSST.unregisterForCdmaDataConnectionDetached(this); + ((CDMAPhone) phone).mSST.unregisterForRoamingOn(this); + ((CDMAPhone) phone).mSST.unregisterForRoamingOff(this); + + phone.getContext().unregisterReceiver(this.mIntentReceiver); + destroyAllDataConnectionList(); + } + + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "CdmaDataConnectionTracker finalized"); + } + + void setState(State s) { + if (DBG) log ("setState: " + s); + if (state != s) { + if (s == State.INITING) { // request Data connection context + Checkin.updateStats(phone.getContext().getContentResolver(), + Checkin.Stats.Tag.PHONE_CDMA_DATA_ATTEMPTED, 1, 0.0); + } + + if (s == State.CONNECTED) { // pppd is up + Checkin.updateStats(phone.getContext().getContentResolver(), + Checkin.Stats.Tag.PHONE_CDMA_DATA_CONNECTED, 1, 0.0); + } + } + + state = s; + } + + public int enableApnType(String type) { + // This request is mainly used to enable MMS APN + // In CDMA there is no need to enable/disable a different APN for MMS + Log.d(LOG_TAG, "Request to enableApnType("+type+")"); + if (TextUtils.equals(type, Phone.APN_TYPE_MMS)) { + return Phone.APN_ALREADY_ACTIVE; + } else { + return Phone.APN_REQUEST_FAILED; + } + } + + public int disableApnType(String type) { + // This request is mainly used to disable MMS APN + // In CDMA there is no need to enable/disable a different APN for MMS + Log.d(LOG_TAG, "Request to disableApnType("+type+")"); + if (TextUtils.equals(type, Phone.APN_TYPE_MMS)) { + return Phone.APN_REQUEST_STARTED; + } else { + return Phone.APN_REQUEST_FAILED; + } + } + + private boolean isEnabled(int cdmaDataProfile) { + return dataEnabled[cdmaDataProfile]; + } + + private void setEnabled(int cdmaDataProfile, boolean enable) { + Log.d(LOG_TAG, "setEnabled(" + cdmaDataProfile + ", " + enable + ')'); + dataEnabled[cdmaDataProfile] = enable; + Log.d(LOG_TAG, "dataEnabled[DEFAULT_PROFILE]=" + dataEnabled[EXTERNAL_NETWORK_DEFAULT_ID]); + } + + /** + * Simply tear down data connections due to radio off + * and don't setup again. + */ + public void cleanConnectionBeforeRadioOff() { + cleanUpConnection(true, Phone.REASON_RADIO_TURNED_OFF); + } + + /** + * The data connection is expected to be setup while device + * 1. has ruim card or non-volatile data store + * 2. registered to data connection service + * 3. user doesn't explicitly disable data service + * 4. wifi is not on + * + * @return false while no data connection if all above requirements are met. + */ + public boolean isDataConnectionAsDesired() { + boolean roaming = phone.getServiceState().getRoaming(); + + if ( ((phone.mCM.getRadioState() == CommandsInterface.RadioState.NV_READY) || + ((CDMAPhone) phone).mRuimRecords.getRecordsLoaded()) && + ((CDMAPhone) phone).mSST.getCurrentCdmaDataConnectionState() == + ServiceState.STATE_IN_SERVICE && + (!roaming || getDataOnRoamingEnabled()) && + !mIsWifiConnected ) { + return (state == State.CONNECTED); + } + return true; + } + + /** + * Prevent mobile data connections from being established, + * or once again allow mobile data connections. If the state + * toggles, then either tear down or set up data, as + * appropriate to match the new state. + * <p>This operation only affects the default connection + * @param enable indicates whether to enable ({@code true}) or disable ({@code false}) data + * @return {@code true} if the operation succeeded + */ + public boolean setDataEnabled(boolean enable) { + + boolean isEnabled = isEnabled(EXTERNAL_NETWORK_DEFAULT_ID); + + Log.d(LOG_TAG, "setDataEnabled("+enable+") isEnabled=" + isEnabled); + if (!isEnabled && enable) { + setEnabled(EXTERNAL_NETWORK_DEFAULT_ID, true); + return trySetupData(Phone.REASON_DATA_ENABLED); + } else if (!enable) { + setEnabled(EXTERNAL_NETWORK_DEFAULT_ID, false); + return false; + } else // isEnabled && enable + + return true; + } + + /** + * Report the current state of data connectivity (enabled or disabled) + * @return {@code false} if data connectivity has been explicitly disabled, + * {@code true} otherwise. + */ + public boolean getDataEnabled() { + return dataEnabled[EXTERNAL_NETWORK_DEFAULT_ID]; + } + + /** + * Report on whether data connectivity is enabled + * @return {@code false} if data connectivity has been explicitly disabled, + * {@code true} otherwise. + */ + public boolean getAnyDataEnabled() { + for (int i=0; i < EXTERNAL_NETWORK_NUM_TYPES; i++) { + if (isEnabled(i)) return true; + } + return false; + } + + private boolean isDataAllowed() { + boolean roaming = phone.getServiceState().getRoaming(); + return getAnyDataEnabled() && (!roaming || getDataOnRoamingEnabled()); + } + + private boolean trySetupData(String reason) { + if (DBG) log("***trySetupData due to " + (reason == null ? "(unspecified)" : reason)); + + if (phone.getSimulatedRadioControl() != null) { + // Assume data is connected on the simulator + // FIXME this can be improved + setState(State.CONNECTED); + phone.notifyDataConnection(reason); + + Log.i(LOG_TAG, "(fix?) We're on the simulator; assuming data is connected"); + return true; + } + + int psState = ((CDMAPhone) phone).mSST.getCurrentCdmaDataConnectionState(); + boolean roaming = phone.getServiceState().getRoaming(); + + if ((state == State.IDLE || state == State.SCANNING) + && (psState == ServiceState.RADIO_TECHNOLOGY_1xRTT || + psState == ServiceState.RADIO_TECHNOLOGY_EVDO_0 || + psState == ServiceState.RADIO_TECHNOLOGY_EVDO_A) + && ((phone.mCM.getRadioState() == CommandsInterface.RadioState.NV_READY) || + ((CDMAPhone) phone).mRuimRecords.getRecordsLoaded()) + && (((CDMAPhone) phone).mSST.isConcurrentVoiceAndData() || + phone.getState() == Phone.State.IDLE ) + && isDataAllowed()) { + + return setupData(reason); + + } else { + if (DBG) { + log("trySetupData: Not ready for data: " + + " dataState=" + state + + " PS state=" + psState + + " radio state=" + phone.mCM.getRadioState() + + " ruim=" + ((CDMAPhone) phone).mRuimRecords.getRecordsLoaded() + + " concurrentVoice&Data=" + ((CDMAPhone) phone).mSST.isConcurrentVoiceAndData() + + " phoneState=" + phone.getState() + + " dataEnabled=" + getAnyDataEnabled() + + " roaming=" + roaming + + " dataOnRoamingEnable=" + getDataOnRoamingEnabled()); + } + return false; + } + } + + /** + * If tearDown is true, this only tears down a CONNECTED session. Presently, + * there is no mechanism for abandoning an INITING/CONNECTING session, + * but would likely involve cancelling pending async requests or + * setting a flag or new state to ignore them when they came in + * @param tearDown true if the underlying DataConnection should be + * disconnected. + * @param reason reason for the clean up. + */ + private void cleanUpConnection(boolean tearDown, String reason) { + if (DBG) log("Clean up connection due to " + reason); + + // Clear the reconnect alarm, if set. + if (mReconnectIntent != null) { + AlarmManager am = + (AlarmManager) phone.getContext().getSystemService(Context.ALARM_SERVICE); + am.cancel(mReconnectIntent); + mReconnectIntent = null; + } + + for (DataConnection connBase : dataConnectionList) { + CdmaDataConnection conn = (CdmaDataConnection) connBase; + + if(conn != null) { + if (tearDown) { + Message msg = obtainMessage(EVENT_DISCONNECT_DONE, reason); + conn.disconnect(msg); + } else { + conn.clearSettings(); + } + } + } + + stopNetStatPoll(); + + /* + * If we've been asked to tear down the connection, + * set the state to DISCONNECTING. However, there's + * a race that can occur if for some reason we were + * already in the IDLE state. In that case, the call + * to conn.disconnect() above will immediately post + * a message to the handler thread that the disconnect + * is done, and if the handler runs before the code + * below does, the handler will have set the state to + * IDLE before the code below runs. If we didn't check + * for that, future calls to trySetupData would fail, + * and we would never get out of the DISCONNECTING state. + */ + if (!tearDown) { + setState(State.IDLE); + phone.notifyDataConnection(reason); + } else if (state != State.IDLE) { + setState(State.DISCONNECTING); + } + } + + private CdmaDataConnection findFreeDataConnection() { + for (DataConnection connBase : dataConnectionList) { + CdmaDataConnection conn = (CdmaDataConnection) connBase; + if (conn.getState() == DataConnection.State.INACTIVE) { + return conn; + } + } + return null; + } + + private boolean setupData(String reason) { + + CdmaDataConnection conn = findFreeDataConnection(); + + if (conn == null) { + if (DBG) log("setupData: No free CdmaDataConnectionfound!"); + return false; + } + + mActiveDataConnection = conn; + + Message msg = obtainMessage(); + msg.what = EVENT_DATA_SETUP_COMPLETE; + msg.obj = reason; + conn.connect(msg); + + setState(State.INITING); + phone.notifyDataConnection(reason); + return true; + } + + private void notifyDefaultData(String reason) { + setState(State.CONNECTED); + phone.notifyDataConnection(reason); + startNetStatPoll(); + // reset reconnect timer + nextReconnectDelay = RECONNECT_DELAY_INITIAL_MILLIS; + } + + private void resetPollStats() { + txPkts = -1; + rxPkts = -1; + sentSinceLastRecv = 0; + netStatPollPeriod = POLL_NETSTAT_MILLIS; + mNoRecvPollCount = 0; + } + + protected void startNetStatPoll() { + if (state == State.CONNECTED && netStatPollEnabled == false) { + Log.d(LOG_TAG, "[DataConnection] Start poll NetStat"); + resetPollStats(); + netStatPollEnabled = true; + mPollNetStat.run(); + } + } + + protected void stopNetStatPoll() { + netStatPollEnabled = false; + removeCallbacks(mPollNetStat); + Log.d(LOG_TAG, "[DataConnection] Stop poll NetStat"); + } + + protected void restartRadio() { + Log.d(LOG_TAG, "************TURN OFF RADIO**************"); + cleanUpConnection(true, Phone.REASON_RADIO_TURNED_OFF); + phone.mCM.setRadioPower(false, null); + /* Note: no need to call setRadioPower(true). Assuming the desired + * radio power state is still ON (as tracked by ServiceStateTracker), + * ServiceStateTracker will call setRadioPower when it receives the + * RADIO_STATE_CHANGED notification for the power off. And if the + * desired power state has changed in the interim, we don't want to + * override it with an unconditional power on. + */ + } + + private Runnable mPollNetStat = new Runnable() { + + public void run() { + long sent, received; + long preTxPkts = -1, preRxPkts = -1; + + Activity newActivity; + + preTxPkts = txPkts; + preRxPkts = rxPkts; + + // check if netstat is still valid to avoid NullPointerException after NTC + if (netstat != null) { + try { + txPkts = netstat.getMobileTxPackets(); + rxPkts = netstat.getMobileRxPackets(); + } catch (RemoteException e) { + txPkts = 0; + rxPkts = 0; + } + + //Log.d(LOG_TAG, "rx " + String.valueOf(rxPkts) + " tx " + String.valueOf(txPkts)); + + if (netStatPollEnabled && (preTxPkts > 0 || preRxPkts > 0)) { + sent = txPkts - preTxPkts; + received = rxPkts - preRxPkts; + + if ( sent > 0 && received > 0 ) { + sentSinceLastRecv = 0; + newActivity = Activity.DATAINANDOUT; + } else if (sent > 0 && received == 0) { + if (phone.getState() == Phone.State.IDLE) { + sentSinceLastRecv += sent; + } else { + sentSinceLastRecv = 0; + } + newActivity = Activity.DATAOUT; + } else if (sent == 0 && received > 0) { + sentSinceLastRecv = 0; + newActivity = Activity.DATAIN; + } else if (sent == 0 && received == 0) { + newActivity = Activity.NONE; + } else { + sentSinceLastRecv = 0; + newActivity = Activity.NONE; + } + + if (activity != newActivity) { + activity = newActivity; + phone.notifyDataActivity(); + } + } + + if (sentSinceLastRecv >= NUMBER_SENT_PACKETS_OF_HANG) { + // we already have NUMBER_SENT_PACKETS sent without ack + if (mNoRecvPollCount < NO_RECV_POLL_LIMIT) { + mNoRecvPollCount++; + // Slow down the poll interval to let things happen + netStatPollPeriod = POLL_NETSTAT_SLOW_MILLIS; + } else { + if (DBG) log("Sent " + String.valueOf(sentSinceLastRecv) + + " pkts since last received"); + // We've exceeded the threshold. Restart the radio. + netStatPollEnabled = false; + stopNetStatPoll(); + restartRadio(); + } + } else { + mNoRecvPollCount = 0; + netStatPollPeriod = POLL_NETSTAT_MILLIS; + } + + if (netStatPollEnabled) { + mDataConnectionTracker.postDelayed(this, netStatPollPeriod); + } + } + } + }; + + /** + * Returns true if the last fail cause is something that + * seems like it deserves an error notification. + * Transient errors are ignored + */ + private boolean + shouldPostNotification(FailCause cause) { + return (cause != FailCause.UNKNOWN); + } + + /** + * Return true if data connection need to be setup after disconnected due to + * reason. + * + * @param reason the reason why data is disconnected + * @return true if try setup data connection is need for this reason + */ + private boolean retryAfterDisconnected(String reason) { + boolean retry = true; + + if ( Phone.REASON_RADIO_TURNED_OFF.equals(reason) || + Phone.REASON_DATA_DISABLED.equals(reason) ) { + retry = false; + } + return retry; + } + + private void reconnectAfterFail(FailCause lastFailCauseCode, String reason) { + if (state == State.FAILED) { + Log.d(LOG_TAG, "Data Connection activate failed. Scheduling next attempt for " + + (nextReconnectDelay / 1000) + "s"); + + AlarmManager am = + (AlarmManager) phone.getContext().getSystemService(Context.ALARM_SERVICE); + Intent intent = new Intent(INTENT_RECONNECT_ALARM); + intent.putExtra(INTENT_RECONNECT_ALARM_EXTRA_REASON, reason); + mReconnectIntent = PendingIntent.getBroadcast( + phone.getContext(), 0, intent, 0); + am.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, + SystemClock.elapsedRealtime() + nextReconnectDelay, + mReconnectIntent); + + // double it for next time + nextReconnectDelay *= 2; + if (nextReconnectDelay > RECONNECT_DELAY_MAX_MILLIS) { + nextReconnectDelay = RECONNECT_DELAY_MAX_MILLIS; + } + + if (!shouldPostNotification(lastFailCauseCode)) { + Log.d(LOG_TAG,"NOT Posting Data Connection Unavailable notification " + + "-- likely transient error"); + } else { + notifyNoData(lastFailCauseCode); + } + } + } + + private void notifyNoData(FailCause lastFailCauseCode) { + setState(State.FAILED); + } + + protected void onRecordsLoaded() { + if (state == State.FAILED) { + cleanUpConnection(false, null); + } + sendMessage(obtainMessage(EVENT_TRY_SETUP_DATA)); + } + + protected void onNVReady() { + if (state == State.FAILED) { + cleanUpConnection(false, null); + } + sendMessage(obtainMessage(EVENT_TRY_SETUP_DATA)); + } + + /** + * @override com.android.internal.telephony.DataConnectionTracker + */ + protected void onTrySetupData() { + trySetupData(null); + } + + /** + * @override com.android.internal.telephony.DataConnectionTracker + */ + protected void onRoamingOff() { + trySetupData(Phone.REASON_ROAMING_OFF); + } + + /** + * @override com.android.internal.telephony.DataConnectionTracker + */ + protected void onRoamingOn() { + if (getDataOnRoamingEnabled()) { + trySetupData(Phone.REASON_ROAMING_ON); + } else { + if (DBG) log("Tear down data connection on roaming."); + cleanUpConnection(true, Phone.REASON_ROAMING_ON); + } + } + + /** + * @override com.android.internal.telephony.DataConnectionTracker + */ + protected void onRadioAvailable() { + if (phone.getSimulatedRadioControl() != null) { + // Assume data is connected on the simulator + // FIXME this can be improved + setState(State.CONNECTED); + phone.notifyDataConnection(null); + + Log.i(LOG_TAG, "We're on the simulator; assuming data is connected"); + } + + if (state != State.IDLE) { + cleanUpConnection(true, null); + } + } + + /** + * @override com.android.internal.telephony.DataConnectionTracker + */ + protected void onRadioOffOrNotAvailable() { + // Make sure our reconnect delay starts at the initial value + // next time the radio comes on + nextReconnectDelay = RECONNECT_DELAY_INITIAL_MILLIS; + + if (phone.getSimulatedRadioControl() != null) { + // Assume data is connected on the simulator + // FIXME this can be improved + Log.i(LOG_TAG, "We're on the simulator; assuming radio off is meaningless"); + } else { + if (DBG) log("Radio is off and clean up all connection"); + cleanUpConnection(false, Phone.REASON_RADIO_TURNED_OFF); + } + } + + /** + * @override com.android.internal.telephony.DataConnectionTracker + */ + protected void onDataSetupComplete(AsyncResult ar) { + String reason = null; + if (ar.userObj instanceof String) { + reason = (String) ar.userObj; + } + + if (ar.exception == null) { + // everything is setup + notifyDefaultData(reason); + } else { + FailCause cause = (FailCause) (ar.result); + if(DBG) log("Data Connection setup failed " + cause); + + // No try for permanent failure + if (cause.isPermanentFail()) { + notifyNoData(cause); + } + + if (tryAgain(cause)) { + trySetupData(reason); + } else { + startDelayedRetry(cause, reason); + } + } + } + + /** + * @override com.android.internal.telephony.DataConnectionTracker + */ + protected void onDisconnectDone(AsyncResult ar) { + if(DBG) log("EVENT_DISCONNECT_DONE"); + String reason = null; + if (ar.userObj instanceof String) { + reason = (String) ar.userObj; + } + setState(State.IDLE); + phone.notifyDataConnection(reason); + if (retryAfterDisconnected(reason)) { + trySetupData(reason); + } + } + + /** + * @override com.android.internal.telephony.DataConnectionTracker + */ + protected void onVoiceCallStarted() { + if (state == State.CONNECTED && !((CDMAPhone) phone).mSST.isConcurrentVoiceAndData()) { + stopNetStatPoll(); + phone.notifyDataConnection(Phone.REASON_VOICE_CALL_STARTED); + } + } + + /** + * @override com.android.internal.telephony.DataConnectionTracker + */ + protected void onVoiceCallEnded() { + if (state == State.CONNECTED) { + if (!((CDMAPhone) phone).mSST.isConcurrentVoiceAndData()) { + startNetStatPoll(); + phone.notifyDataConnection(Phone.REASON_VOICE_CALL_ENDED); + } else { + // clean slate after call end. + resetPollStats(); + } + } else { + // in case data setup was attempted when we were on a voice call + trySetupData(Phone.REASON_VOICE_CALL_ENDED); + } + } + + private boolean tryAgain(FailCause cause) { + return (cause != FailCause.RADIO_NOT_AVAILABLE) + && (cause != FailCause.RADIO_OFF) + && (cause != FailCause.RADIO_ERROR_RETRY) + && (cause != FailCause.NO_SIGNAL) + && (cause != FailCause.SIM_LOCKED); + } + + private void createAllDataConnectionList() { + dataConnectionList = new ArrayList<DataConnection>(); + CdmaDataConnection dataConn; + + for (int i = 0; i < DATA_CONNECTION_POOL_SIZE; i++) { + dataConn = new CdmaDataConnection(((CDMAPhone) phone)); + dataConnectionList.add(dataConn); + } + } + + private void destroyAllDataConnectionList() { + if(dataConnectionList != null) { + CdmaDataConnection pdp; + dataConnectionList.removeAll(dataConnectionList); + } + } + + private void onCdmaDataAttached() { + if (state == State.CONNECTED) { + startNetStatPoll(); + phone.notifyDataConnection(Phone.REASON_CDMA_DATA_DETACHED); + } else { + if (state == State.FAILED) { + cleanUpConnection(false, Phone.REASON_CDMA_DATA_DETACHED); + nextReconnectDelay = RECONNECT_DELAY_INITIAL_MILLIS; + } + trySetupData(Phone.REASON_CDMA_DATA_DETACHED); + } + } + + protected void onDataStateChanged (AsyncResult ar) { + if (ar.exception != null) { + // This is probably "radio not available" or something + // of that sort. If so, the whole connection is going + // to come down soon anyway + return; + } + + if (state == State.CONNECTED) { + Log.i(LOG_TAG, "Data connection has changed."); + + int cid = -1; + EventLog.List val = new EventLog.List(cid, + TelephonyManager.getDefault().getNetworkType()); + EventLog.writeEvent(TelephonyEventLog.EVENT_LOG_PDP_NETWORK_DROP, val); + + cleanUpConnection(true, null); + } + Log.i(LOG_TAG, "Data connection has changed."); + } + + String getInterfaceName() { + if (mActiveDataConnection != null) { + return mActiveDataConnection.getInterface(); + } + return null; + } + + protected String getIpAddress() { + if (mActiveDataConnection != null) { + return mActiveDataConnection.getIpAddress(); + } + return null; + } + + String getGateway() { + if (mActiveDataConnection != null) { + return mActiveDataConnection.getGatewayAddress(); + } + return null; + } + + protected String[] getDnsServers() { + if (mActiveDataConnection != null) { + return mActiveDataConnection.getDnsServers(); + } + return null; + } + + public ArrayList<DataConnection> getAllDataConnections() { + return dataConnectionList; + } + + private void startDelayedRetry(FailCause cause, String reason) { + notifyNoData(cause); + reconnectAfterFail(cause, reason); + } + + public void handleMessage (Message msg) { + + switch (msg.what) { + case EVENT_RECORDS_LOADED: + onRecordsLoaded(); + break; + + case EVENT_NV_READY: + onNVReady(); + break; + + case EVENT_CDMA_DATA_DETACHED: + onCdmaDataAttached(); + break; + + case EVENT_DATA_STATE_CHANGED: + onDataStateChanged((AsyncResult) msg.obj); + break; + + default: + // handle the message in the super class DataConnectionTracker + super.handleMessage(msg); + break; + } + } + + protected void log(String s) { + Log.d(LOG_TAG, "[CdmaDataConnectionTracker] " + s); + } +} diff --git a/telephony/java/com/android/internal/telephony/cdma/CdmaSMSDispatcher.java b/telephony/java/com/android/internal/telephony/cdma/CdmaSMSDispatcher.java new file mode 100644 index 0000000..42c0583 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/CdmaSMSDispatcher.java @@ -0,0 +1,394 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + + +import android.app.PendingIntent; +import android.content.ContentValues; +import android.database.Cursor; +import android.database.SQLException; +import android.os.AsyncResult; +import android.os.Message; +import android.util.Config; +import android.util.Log; + +import com.android.internal.telephony.SmsHeader; +import com.android.internal.telephony.SmsMessageBase; +import com.android.internal.telephony.SMSDispatcher; +//import com.android.internal.telephony.SMSDispatcher.SmsTracker; +import com.android.internal.telephony.cdma.SmsMessage; +import com.android.internal.telephony.cdma.sms.SmsEnvelope; +import com.android.internal.util.HexDump; + +import java.io.ByteArrayOutputStream; +import java.util.ArrayList; +import java.util.HashMap; + + +final class CdmaSMSDispatcher extends SMSDispatcher { + private static final String TAG = "CDMA"; + + CdmaSMSDispatcher(CDMAPhone phone) { + super(phone); + } + + /** + * Called when a status report is received. This should correspond to + * a previously successful SEND. + * Is a special GSM function, should never be called in CDMA!! + * + * @param ar AsyncResult passed into the message handler. ar.result should + * be a String representing the status report PDU, as ASCII hex. + */ + protected void handleStatusReport(AsyncResult ar) { + Log.d(TAG, "handleStatusReport is a special GSM function, should never be called in CDMA!"); + } + + /** + * Dispatches an incoming SMS messages. + * + * @param smsb the incoming message from the phone + */ + protected void dispatchMessage(SmsMessageBase smsb) { + + // If sms is null, means there was a parsing error. + // TODO: Should NAK this. + if (smsb == null) { + return; + } + SmsMessage sms = (SmsMessage) smsb; + int teleService; + boolean handled = false; + + // Decode BD stream and set sms variables. + sms.parseSms(); + teleService = sms.getTeleService(); + + // Teleservices W(E)MT and VMN are handled together: + if ((SmsEnvelope.TELESERVICE_WMT == teleService) + ||(SmsEnvelope.TELESERVICE_WEMT == teleService) + ||(SmsEnvelope.TELESERVICE_VMN == teleService)){ + // From here on we need decoded BD. + // Special case the message waiting indicator messages + if (sms.isMWISetMessage()) { + ((CDMAPhone) mPhone).updateMessageWaitingIndicator(true); + + if (sms.isMwiDontStore()) { + handled = true; + } + + if (Config.LOGD) { + Log.d(TAG, + "Received voice mail indicator set SMS shouldStore=" + !handled); + } + } else if (sms.isMWIClearMessage()) { + ((CDMAPhone) mPhone).updateMessageWaitingIndicator(false); + + if (sms.isMwiDontStore()) { + handled = true; + } + + if (Config.LOGD) { + Log.d(TAG, + "Received voice mail indicator clear SMS shouldStore=" + !handled); + } + } + } + + if (null == sms.getUserData()){ + handled = true; + if (Config.LOGD) { + Log.d(TAG, "Received SMS without user data"); + } + } + + if (handled) return; + + if (SmsEnvelope.TELESERVICE_WAP == teleService){ + processCdmaWapPdu(sms.getUserData(), sms.messageRef, sms.getOriginatingAddress()); + return; + } + + // Parse the headers to see if this is partial, or port addressed + int referenceNumber = -1; + int count = 0; + int sequence = 0; + int destPort = -1; + // From here on we need BD distributed to SMS member variables. + + SmsHeader header = sms.getUserDataHeader(); + if (header != null) { + for (SmsHeader.Element element : header.getElements()) { + try { + switch (element.getID()) { + case SmsHeader.CONCATENATED_8_BIT_REFERENCE: { + byte[] data = element.getData(); + + referenceNumber = data[0] & 0xff; + count = data[1] & 0xff; + sequence = data[2] & 0xff; + + // Per TS 23.040, 9.2.3.24.1: If the count is zero, sequence + // is zero, or sequence > count, ignore the entire element + if (count == 0 || sequence == 0 || sequence > count) { + referenceNumber = -1; + } + break; + } + + case SmsHeader.CONCATENATED_16_BIT_REFERENCE: { + byte[] data = element.getData(); + + referenceNumber = (data[0] & 0xff) * 256 + (data[1] & 0xff); + count = data[2] & 0xff; + sequence = data[3] & 0xff; + + // Per TS 23.040, 9.2.3.24.8: If the count is zero, sequence + // is zero, or sequence > count, ignore the entire element + if (count == 0 || sequence == 0 || sequence > count) { + referenceNumber = -1; + } + break; + } + + case SmsHeader.APPLICATION_PORT_ADDRESSING_16_BIT: { + byte[] data = element.getData(); + + destPort = (data[0] & 0xff) << 8; + destPort |= (data[1] & 0xff); + + break; + } + } + } catch (ArrayIndexOutOfBoundsException e) { + Log.e(TAG, "Bad element in header", e); + return; // TODO: NACK the message or something, don't just discard. + } + } + } + + if (referenceNumber == -1) { + // notify everyone of the message if it isn't partial + byte[][] pdus = new byte[1][]; + pdus[0] = sms.getPdu(); + + if (destPort != -1) {// GSM-style WAP indication + if (destPort == SmsHeader.PORT_WAP_PUSH) { + mWapPush.dispatchWapPdu(sms.getUserData()); + } + // The message was sent to a port, so concoct a URI for it + dispatchPortAddressedPdus(pdus, destPort); + } else { + // It's a normal message, dispatch it + dispatchPdus(pdus); + } + } else { + // Process the message part + processMessagePart(sms, referenceNumber, sequence, count, destPort); + } + } + + /** + * Processes inbound messages that are in the WAP-WDP PDU format. See + * wap-259-wdp-20010614-a section 6.5 for details on the WAP-WDP PDU format. + * WDP segments are gathered until a datagram completes and gets dispatched. + * + * @param pdu The WAP-WDP PDU segment + */ + protected void processCdmaWapPdu(byte[] pdu, int referenceNumber, String address) { + int segment; + int totalSegments; + int index = 0; + int msgType; + + int sourcePort; + int destinationPort; + + msgType = pdu[index++]; + if (msgType != 0){ + Log.w(TAG, "Received a WAP SMS which is not WDP. Discard."); + return; + } + totalSegments = pdu[index++]; // >=1 + segment = pdu[index++]; // >=0 + + //process WDP segment + sourcePort = (0xFF & pdu[index++]) << 8; + sourcePort |= 0xFF & pdu[index++]; + destinationPort = (0xFF & pdu[index++]) << 8; + destinationPort |= 0xFF & pdu[index++]; + + // Lookup all other related parts + StringBuilder where = new StringBuilder("reference_number ="); + where.append(referenceNumber); + where.append(" AND address = ?"); + String[] whereArgs = new String[] {address}; + + Log.i(TAG, "Received WAP PDU. Type = " + msgType + ", originator = " + address + + ", src-port = " + sourcePort + ", dst-port = " + destinationPort + + ", ID = " + referenceNumber + ", segment# = " + segment + "/" + totalSegments); + + byte[][] pdus = null; + Cursor cursor = null; + try { + cursor = mResolver.query(mRawUri, RAW_PROJECTION, where.toString(), whereArgs, null); + int cursorCount = cursor.getCount(); + if (cursorCount != totalSegments - 1) { + // We don't have all the parts yet, store this one away + ContentValues values = new ContentValues(); + values.put("date", new Long(0)); + values.put("pdu", HexDump.toHexString(pdu, index, pdu.length - index)); + values.put("address", address); + values.put("reference_number", referenceNumber); + values.put("count", totalSegments); + values.put("sequence", segment); + values.put("destination_port", destinationPort); + + mResolver.insert(mRawUri, values); + + return; + } + + // All the parts are in place, deal with them + int pduColumn = cursor.getColumnIndex("pdu"); + int sequenceColumn = cursor.getColumnIndex("sequence"); + + pdus = new byte[totalSegments][]; + for (int i = 0; i < cursorCount; i++) { + cursor.moveToNext(); + int cursorSequence = (int)cursor.getLong(sequenceColumn); + pdus[cursorSequence] = HexDump.hexStringToByteArray( + cursor.getString(pduColumn)); + } + // The last part will be added later + + // Remove the parts from the database + mResolver.delete(mRawUri, where.toString(), whereArgs); + } catch (SQLException e) { + Log.e(TAG, "Can't access multipart SMS database", e); + return; // TODO: NACK the message or something, don't just discard. + } finally { + if (cursor != null) cursor.close(); + } + + // Build up the data stream + ByteArrayOutputStream output = new ByteArrayOutputStream(); + for (int i = 0; i < totalSegments-1; i++) { + // reassemble the (WSP-)pdu + output.write(pdus[i], 0, pdus[i].length); + } + + // This one isn't in the DB, so add it + output.write(pdu, index, pdu.length - index); + + byte[] datagram = output.toByteArray(); + // Dispatch the PDU to applications + switch (destinationPort) { + case SmsHeader.PORT_WAP_PUSH: + // Handle the PUSH + mWapPush.dispatchWapPdu(datagram); + break; + + default:{ + pdus = new byte[1][]; + pdus[0] = datagram; + // The messages were sent to any other WAP port + dispatchPortAddressedPdus(pdus, destinationPort); + break; + } + } + } + + /** {@inheritDoc} */ + protected void sendMultipartText(String destinationAddress, String scAddress, + ArrayList<String> parts, ArrayList<PendingIntent> sentIntents, + ArrayList<PendingIntent> deliveryIntents) { + + int ref = ++sConcatenatedRef & 0xff; + + for (int i = 0, count = parts.size(); i < count; i++) { + // build SmsHeader data + byte[] data = new byte[5]; + data[0] = (byte) SmsHeader.CONCATENATED_8_BIT_REFERENCE; + data[1] = (byte) 3; // 3 bytes follow + data[2] = (byte) ref; // reference #, unique per message + data[3] = (byte) count; // total part count + data[4] = (byte) (i + 1); // 1-based sequence + + PendingIntent sentIntent = null; + PendingIntent deliveryIntent = null; + + if (sentIntents != null && sentIntents.size() > i) { + sentIntent = sentIntents.get(i); + } + if (deliveryIntents != null && deliveryIntents.size() > i) { + deliveryIntent = deliveryIntents.get(i); + } + + SmsMessage.SubmitPdu pdus = SmsMessage.getSubmitPdu(scAddress, destinationAddress, + parts.get(i), deliveryIntent != null, data); + + sendRawPdu(pdus.encodedScAddress, pdus.encodedMessage, sentIntent, deliveryIntent); + } + } + + protected void sendRawPdu(byte[] smsc, byte[] pdu, PendingIntent sentIntent, + PendingIntent deliveryIntent) { + super.sendRawPdu(smsc, pdu, sentIntent, deliveryIntent); + } + + /** {@inheritDoc} */ + protected void sendSms(SmsTracker tracker) { + HashMap map = tracker.mData; + + byte smsc[] = (byte[]) map.get("smsc"); + byte pdu[] = (byte[]) map.get("pdu"); + + Message reply = obtainMessage(EVENT_SEND_SMS_COMPLETE, tracker); + + mCm.sendCdmaSms(pdu, reply); + } + + /** {@inheritDoc} */ + protected void sendMultipartSms (SmsTracker tracker) { + Log.d(TAG, "TODO: CdmaSMSDispatcher.sendMultipartSms not implemented"); + } + + /** {@inheritDoc} */ + protected void acknowledgeLastIncomingSms(boolean success, Message response){ + // FIXME unit test leaves cm == null. this should change + if (mCm != null) { + mCm.acknowledgeLastIncomingCdmaSms(success, response); + } + } + + /** {@inheritDoc} */ + protected void activateCellBroadcastSms(int activate, Message response) { + mCm.activateCdmaBroadcastSms(activate, response); + } + + /** {@inheritDoc} */ + protected void getCellBroadcastSmsConfig(Message response) { + mCm.getCdmaBroadcastConfig(response); + } + + /** {@inheritDoc} */ + protected void setCellBroadcastConfig(int[] configValuesArray, Message response) { + mCm.setCdmaBroadcastConfig(configValuesArray, response); + } + +} diff --git a/telephony/java/com/android/internal/telephony/cdma/CdmaServiceStateTracker.java b/telephony/java/com/android/internal/telephony/cdma/CdmaServiceStateTracker.java new file mode 100644 index 0000000..ca40e76 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/CdmaServiceStateTracker.java @@ -0,0 +1,1016 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import android.app.AlarmManager; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.database.ContentObserver; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.os.Registrant; +import android.os.RegistrantList; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.provider.Checkin; +import android.provider.Settings; +import android.provider.Settings.SettingNotFoundException; +import android.provider.Telephony.Intents; +import android.telephony.ServiceState; +import android.telephony.cdma.CdmaCellLocation; +import android.text.TextUtils; +import android.util.EventLog; +import android.util.Log; +import android.util.TimeUtils; + +import com.android.internal.telephony.CommandException; +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.DataConnectionTracker; +// pretty sure importing stuff from GSM is bad: +import com.android.internal.telephony.gsm.MccTable; +import com.android.internal.telephony.PhoneProxy; +import com.android.internal.telephony.ServiceStateTracker; +import com.android.internal.telephony.TelephonyEventLog; +import com.android.internal.telephony.TelephonyIntents; + +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ALPHA; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ISMANUAL; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ISROAMING; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_NUMERIC; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA; + +import java.util.Arrays; +import java.util.Date; +import java.util.TimeZone; + +/** + * {@hide} + */ +final class CdmaServiceStateTracker extends ServiceStateTracker { + //***** Instance Variables + CDMAPhone phone; + CdmaCellLocation cellLoc; + CdmaCellLocation newCellLoc; + + int rssi = 99; // signal strength 0-31, 99=unknown + // That's "received signal strength indication" fyi + + /** + * The access technology currently in use: DATA_ACCESS_ + */ + private int networkType = 0; + private int newNetworkType = 0; + + private boolean mCdmaRoaming = false; + + private int cdmaDataConnectionState = -1;//Initial we assume no data connection + private int newCdmaDataConnectionState = -1;//Initial we assume no data connection + private int mRegistrationState = -1; + private RegistrantList cdmaDataConnectionAttachedRegistrants = new RegistrantList(); + private RegistrantList cdmaDataConnectionDetachedRegistrants = new RegistrantList(); + + private boolean mGotCountryCode = false; + + // We can't register for SIM_RECORDS_LOADED immediately because the + // SIMRecords object may not be instantiated yet. + private boolean mNeedToRegForRuimLoaded; + + // Keep track of SPN display rules, so we only broadcast intent if something changes. + private String curSpn = null; + private String curPlmn = null; + private int curSpnRule = 0; + + //***** Constants + static final String LOG_TAG = "CDMA"; + static final String TMUK = "23430"; + + private ContentResolver cr; + + private ContentObserver mAutoTimeObserver = new ContentObserver(new Handler()) { + @Override + public void onChange(boolean selfChange) { + Log.i("CdmaServiceStateTracker", "Auto time state called ..."); + //NOTE in CDMA NITZ is not used + } + }; + + + //***** Constructors + + public CdmaServiceStateTracker(CDMAPhone phone) { + super(); + + this.phone = phone; + cm = phone.mCM; + ss = new ServiceState(); + newSS = new ServiceState(); + cellLoc = new CdmaCellLocation(); + newCellLoc = new CdmaCellLocation(); + + cm.registerForAvailable(this, EVENT_RADIO_AVAILABLE, null); + cm.registerForRadioStateChanged(this, EVENT_RADIO_STATE_CHANGED, null); + + cm.registerForNetworkStateChanged(this, EVENT_NETWORK_STATE_CHANGED_CDMA, null); + cm.setOnSignalStrengthUpdate(this, EVENT_SIGNAL_STRENGTH_UPDATE, null); + + cm.registerForRUIMReady(this, EVENT_RUIM_READY, null); + + phone.registerForNvLoaded(this, EVENT_NV_LOADED,null); + + // system setting property AIRPLANE_MODE_ON is set in Settings. + int airplaneMode = Settings.System.getInt( + phone.getContext().getContentResolver(), + Settings.System.AIRPLANE_MODE_ON, 0); + mDesiredPowerState = ! (airplaneMode > 0); + + cr = phone.getContext().getContentResolver(); + cr.registerContentObserver( + Settings.System.getUriFor(Settings.System.AUTO_TIME), true, + mAutoTimeObserver); + setRssiDefaultValues(); + + mNeedToRegForRuimLoaded = true; + } + + public void dispose() { + //Unregister for all events + cm.unregisterForAvailable(this); + cm.unregisterForRadioStateChanged(this); + cm.unregisterForNetworkStateChanged(this); + cm.unregisterForRUIMReady(this); + phone.unregisterForNvLoaded(this); + phone.mRuimRecords.unregisterForRecordsLoaded(this); + cm.unSetOnSignalStrengthUpdate(this); + cr.unregisterContentObserver(this.mAutoTimeObserver); + } + + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "CdmaServiceStateTracker finalized"); + } + + void registerForNetworkAttach(Handler h, int what, Object obj) { + Registrant r = new Registrant(h, what, obj); + networkAttachedRegistrants.add(r); + + if (ss.getState() == ServiceState.STATE_IN_SERVICE) { + r.notifyRegistrant(); + } + } + + void unregisterForNetworkAttach(Handler h) { + networkAttachedRegistrants.remove(h); + } + + /** + * Registration point for transition into Data attached. + * @param h handler to notify + * @param what what code of message when delivered + * @param obj placed in Message.obj + */ + /*protected*/ void + registerForCdmaDataConnectionAttached(Handler h, int what, Object obj) { + Registrant r = new Registrant(h, what, obj); + cdmaDataConnectionAttachedRegistrants.add(r); + + if (cdmaDataConnectionState == ServiceState.RADIO_TECHNOLOGY_1xRTT + || cdmaDataConnectionState == ServiceState.RADIO_TECHNOLOGY_EVDO_0 + || cdmaDataConnectionState == ServiceState.RADIO_TECHNOLOGY_EVDO_A) { + r.notifyRegistrant(); + } + } + void unregisterForCdmaDataConnectionAttached(Handler h) { + cdmaDataConnectionAttachedRegistrants.remove(h); + } + + /** + * Registration point for transition into Data detached. + * @param h handler to notify + * @param what what code of message when delivered + * @param obj placed in Message.obj + */ + /*protected*/ void + registerForCdmaDataConnectionDetached(Handler h, int what, Object obj) { + Registrant r = new Registrant(h, what, obj); + cdmaDataConnectionDetachedRegistrants.add(r); + + if (cdmaDataConnectionState != ServiceState.RADIO_TECHNOLOGY_1xRTT + && cdmaDataConnectionState != ServiceState.RADIO_TECHNOLOGY_EVDO_0 + && cdmaDataConnectionState != ServiceState.RADIO_TECHNOLOGY_EVDO_A) { + r.notifyRegistrant(); + } + } + void unregisterForCdmaDataConnectionDetached(Handler h) { + cdmaDataConnectionDetachedRegistrants.remove(h); + } + + //***** Called from CDMAPhone + public void + getLacAndCid(Message onComplete) { + cm.getRegistrationState(obtainMessage( + EVENT_GET_LOC_DONE_CDMA, onComplete)); + } + + + //***** Overridden from ServiceStateTracker + public void + handleMessage (Message msg) { + AsyncResult ar; + int[] ints; + String[] strings; + + switch (msg.what) { + case EVENT_RADIO_AVAILABLE: + //this is unnecessary + //setPowerStateToDesired(); + break; + + case EVENT_RUIM_READY: + // The RUIM is now ready i.e if it was locked + // it has been unlocked. At this stage, the radio is already + // powered on. + if (mNeedToRegForRuimLoaded) { + phone.mRuimRecords.registerForRecordsLoaded(this, + EVENT_RUIM_RECORDS_LOADED, null); + mNeedToRegForRuimLoaded = false; + } + // restore the previous network selection. + phone.restoreSavedNetworkSelection(null); + pollState(); + // Signal strength polling stops when radio is off + queueNextSignalStrengthPoll(); + break; + + case EVENT_RADIO_STATE_CHANGED: + // This will do nothing in the radio not + // available case + setPowerStateToDesired(); + pollState(); + break; + + case EVENT_NETWORK_STATE_CHANGED_CDMA: + pollState(); + break; + + case EVENT_GET_SIGNAL_STRENGTH: + // This callback is called when signal strength is polled + // all by itself + + if (!(cm.getRadioState().isOn()) || (cm.getRadioState().isGsm())) { + // Polling will continue when radio turns back on + return; + } + ar = (AsyncResult) msg.obj; + onSignalStrengthResult(ar); + queueNextSignalStrengthPoll(); + + break; + + case EVENT_GET_LOC_DONE_CDMA: + ar = (AsyncResult) msg.obj; + + if (ar.exception == null) { + String states[] = (String[])ar.result; + int baseStationId = -1; + int baseStationLongitude = -1; + int baseStationLatitude = -1; + + int baseStationData[] = { + -1, // baseStationId + -1, // baseStationLatitude + -1 // baseStationLongitude + }; + + if (states.length == 3) { + for(int i = 0; i < states.length; i++) { + try { + if (states[i] != null && states[i].length() > 0) { + baseStationData[i] = Integer.parseInt(states[i], 16); + } + } catch (NumberFormatException ex) { + Log.w(LOG_TAG, "error parsing cell location data: " + ex); + } + } + } + + // only update if cell location really changed + if (cellLoc.getBaseStationId() != baseStationData[0] + || cellLoc.getBaseStationLatitude() != baseStationData[1] + || cellLoc.getBaseStationLongitude() != baseStationData[2]) { + cellLoc.setCellLocationData(baseStationData[0], + baseStationData[1], + baseStationData[2]); + phone.notifyLocationChanged(); + } + } + + if (ar.userObj != null) { + AsyncResult.forMessage(((Message) ar.userObj)).exception + = ar.exception; + ((Message) ar.userObj).sendToTarget(); + } + break; + + case EVENT_POLL_STATE_NETWORK_SELECTION_MODE_CDMA: //Fall through + case EVENT_POLL_STATE_REGISTRATION_CDMA: //Fall through + case EVENT_POLL_STATE_OPERATOR_CDMA: + ar = (AsyncResult) msg.obj; + handlePollStateResult(msg.what, ar); + break; + + case EVENT_POLL_SIGNAL_STRENGTH: + // Just poll signal strength...not part of pollState() + + cm.getSignalStrength(obtainMessage(EVENT_GET_SIGNAL_STRENGTH)); + break; + + case EVENT_SIGNAL_STRENGTH_UPDATE: + // This is a notification from + // CommandsInterface.setOnSignalStrengthUpdate + + ar = (AsyncResult) msg.obj; + + // The radio is telling us about signal strength changes + // we don't have to ask it + dontPollSignalStrength = true; + + onSignalStrengthResult(ar); + break; + + case EVENT_RUIM_RECORDS_LOADED: + case EVENT_NV_LOADED: + updateSpnDisplay(); + break; + + case EVENT_LOCATION_UPDATES_ENABLED: + ar = (AsyncResult) msg.obj; + + if (ar.exception == null) { + getLacAndCid(null); + } + break; + + default: + Log.e(LOG_TAG, "Unhandled message with number: " + msg.what); + break; + } + } + + //***** Private Instance Methods + + protected void setPowerStateToDesired() + { + // If we want it on and it's off, turn it on + if (mDesiredPowerState + && cm.getRadioState() == CommandsInterface.RadioState.RADIO_OFF) { + cm.setRadioPower(true, null); + } else if (!mDesiredPowerState && cm.getRadioState().isOn()) { + DataConnectionTracker dcTracker = phone.mDataConnection; + if (! dcTracker.isDataConnectionAsDesired()) { + + EventLog.List val = new EventLog.List( + dcTracker.getStateInString(), + (dcTracker.getAnyDataEnabled() ? 1 : 0) ); + EventLog.writeEvent(TelephonyEventLog.EVENT_DATA_STATE_RADIO_OFF, val); + } + dcTracker.cleanConnectionBeforeRadioOff(); + + // poll data state up to 15 times, with a 100ms delay + // totaling 1.5 sec. Normal data disable action will finish in 100ms. + for (int i = 0; i < MAX_NUM_DATA_STATE_READS; i++) { + if (dcTracker.getState() != DataConnectionTracker.State.CONNECTED + && dcTracker.getState() != DataConnectionTracker.State.DISCONNECTING) { + Log.d(LOG_TAG, "Data shutdown complete."); + break; + } + SystemClock.sleep(DATA_STATE_POLL_SLEEP_MS); + } + // If it's on and available and we want it off.. + cm.setRadioPower(false, null); + } // Otherwise, we're in the desired state + } + + protected void updateSpnDisplay() { + + // TODO Check this method again, because it is not sure at the moment how + // the RUIM handles the SIM stuff + + //int rule = phone.mRuimRecords.getDisplayRule(ss.getOperatorNumeric()); + String spn = null; //phone.mRuimRecords.getServiceProviderName(); + String plmn = ss.getOperatorAlphaLong(); + + if (!TextUtils.equals(this.curPlmn, plmn)) { + //TODO (rule & SIMRecords.SPN_RULE_SHOW_SPN) == SIMRecords.SPN_RULE_SHOW_SPN; + boolean showSpn = false; + //TODO (rule & SIMRecords.SPN_RULE_SHOW_PLMN) == SIMRecords.SPN_RULE_SHOW_PLMN; + boolean showPlmn = true; + Intent intent = new Intent(Intents.SPN_STRINGS_UPDATED_ACTION); + intent.putExtra(Intents.EXTRA_SHOW_SPN, showSpn); + intent.putExtra(Intents.EXTRA_SPN, spn); + intent.putExtra(Intents.EXTRA_SHOW_PLMN, showPlmn); + intent.putExtra(Intents.EXTRA_PLMN, plmn); + phone.getContext().sendStickyBroadcast(intent); + } + + //curSpnRule = rule; + //curSpn = spn; + this.curPlmn = plmn; + } + + /** + * Handle the result of one of the pollState()-related requests + */ + + protected void + handlePollStateResult (int what, AsyncResult ar) { + int ints[]; + String states[]; + + // Ignore stale requests from last poll + if (ar.userObj != pollingContext) return; + + if (ar.exception != null) { + CommandException.Error err=null; + + if (ar.exception instanceof CommandException) { + err = ((CommandException)(ar.exception)).getCommandError(); + } + + if (err == CommandException.Error.RADIO_NOT_AVAILABLE) { + // Radio has crashed or turned off + cancelPollState(); + return; + } + + if (!cm.getRadioState().isOn()) { + // Radio has crashed or turned off + cancelPollState(); + return; + } + + if (err != CommandException.Error.OP_NOT_ALLOWED_BEFORE_REG_NW && + err != CommandException.Error.OP_NOT_ALLOWED_BEFORE_REG_NW) { + Log.e(LOG_TAG, + "RIL implementation has returned an error where it must succeed", + ar.exception); + } + } else try { + switch (what) { + case EVENT_POLL_STATE_REGISTRATION_CDMA: + //offset, because we don't want the first 3 values in the int-array + final int offset = 3; + states = (String[])ar.result; + + int responseValuesRegistrationState[] = { + -1, //[0] radioTechnology + -1, //[1] baseStationId + -1, //[2] baseStationLatitude + -1, //[3] baseStationLongitude + 0, //[4] cssIndicator; init with 0, because it is treated as a boolean + -1, //[5] systemId + -1 //[6] networkId + }; + + if (states.length > 0) { + try { + this.mRegistrationState = Integer.parseInt(states[0]); + if (states.length == 10) { + for(int i = 0; i < states.length - offset; i++) { + if (states[i + offset] != null + && states[i + offset].length() > 0) { + try { + responseValuesRegistrationState[i] = + Integer.parseInt(states[i + offset], 16); + } + catch(NumberFormatException ex) { + Log.w(LOG_TAG, "Warning! There is an unexpected value" + + "returned as response from " + + "RIL_REQUEST_REGISTRATION_STATE."); + } + } + } + } + else { + Log.e(LOG_TAG, "Too less parameters returned from" + + " RIL_REQUEST_REGISTRATION_STATE"); + } + } catch (NumberFormatException ex) { + Log.w(LOG_TAG, "error parsing RegistrationState: " + ex); + } + } + + mCdmaRoaming = regCodeIsRoaming(this.mRegistrationState); + this.newCdmaDataConnectionState = + radioTechnologyToServiceState(responseValuesRegistrationState[0]); + newSS.setState (regCodeToServiceState(this.mRegistrationState)); + newSS.setRadioTechnology(responseValuesRegistrationState[0]); + newSS.setCssIndicator(responseValuesRegistrationState[4]); + newSS.setSystemAndNetworkId(responseValuesRegistrationState[5], + responseValuesRegistrationState[6]); + + newNetworkType = responseValuesRegistrationState[0]; + + // values are -1 if not available + newCellLoc.setCellLocationData(responseValuesRegistrationState[1], + responseValuesRegistrationState[2], + responseValuesRegistrationState[3]); + break; + + case EVENT_POLL_STATE_OPERATOR_CDMA: + String opNames[] = (String[])ar.result; + + if (opNames != null && opNames.length >= 4) { + newSS.setOperatorName (opNames[0], opNames[1], opNames[2]); + } + break; + + case EVENT_POLL_STATE_NETWORK_SELECTION_MODE_CDMA: + ints = (int[])ar.result; + newSS.setIsManualSelection(ints[0] == 1); + break; + default: + Log.e(LOG_TAG, "RIL response handle in wrong phone!" + + " Expected CDMA RIL request and get GSM RIL request."); + break; + } + + } catch (RuntimeException ex) { + Log.e(LOG_TAG, "Exception while polling service state. " + + "Probably malformed RIL response.", ex); + } + + pollingContext[0]--; + + if (pollingContext[0] == 0) { + newSS.setRoaming(isRoamingBetweenOperators(mCdmaRoaming, newSS)); + + switch(this.mRegistrationState) { + case ServiceState.REGISTRATION_STATE_HOME_NETWORK: + newSS.setExtendedCdmaRoaming(ServiceState.REGISTRATION_STATE_HOME_NETWORK); + break; + case ServiceState.REGISTRATION_STATE_ROAMING: + newSS.setExtendedCdmaRoaming(ServiceState.REGISTRATION_STATE_ROAMING); + break; + case ServiceState.REGISTRATION_STATE_ROAMING_AFFILIATE: + newSS.setExtendedCdmaRoaming(ServiceState.REGISTRATION_STATE_ROAMING_AFFILIATE); + break; + default: + Log.w(LOG_TAG, "Received a different registration state, " + + "but don't changed the extended cdma roaming mode."); + } + pollStateDone(); + } + + } + + private void setRssiDefaultValues() { + rssi = 99; + } + + /** + * A complete "service state" from our perspective is + * composed of a handful of separate requests to the radio. + * + * We make all of these requests at once, but then abandon them + * and start over again if the radio notifies us that some + * event has changed + */ + + private void + pollState() { + pollingContext = new int[1]; + pollingContext[0] = 0; + + switch (cm.getRadioState()) { + case RADIO_UNAVAILABLE: + newSS.setStateOutOfService(); + newCellLoc.setStateInvalid(); + setRssiDefaultValues(); + mGotCountryCode = false; + + pollStateDone(); + break; + + case RADIO_OFF: + newSS.setStateOff(); + newCellLoc.setStateInvalid(); + setRssiDefaultValues(); + mGotCountryCode = false; + + pollStateDone(); + break; + + case SIM_NOT_READY: + case SIM_LOCKED_OR_ABSENT: + case SIM_READY: + log("Radio Technology Change ongoing, setting SS to off"); + newSS.setStateOff(); + newCellLoc.setStateInvalid(); + setRssiDefaultValues(); + mGotCountryCode = false; + + pollStateDone(); + break; + + default: + // Issue all poll-related commands at once + // then count down the responses, which + // are allowed to arrive out-of-order + + pollingContext[0]++; + //RIL_REQUEST_OPERATOR is necessary for CDMA + cm.getOperator( + obtainMessage(EVENT_POLL_STATE_OPERATOR_CDMA, pollingContext)); + + pollingContext[0]++; + //RIL_REQUEST_REGISTRATION_STATE is necessary for CDMA + cm.getRegistrationState( + obtainMessage(EVENT_POLL_STATE_REGISTRATION_CDMA, pollingContext)); + + pollingContext[0]++; + //RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE necessary for CDMA + cm.getNetworkSelectionMode( + obtainMessage(EVENT_POLL_STATE_NETWORK_SELECTION_MODE_CDMA, pollingContext)); + break; + } + } + + private static String networkTypeToString(int type) { + String ret = "unknown"; + + switch (type) { + case DATA_ACCESS_CDMA_IS95A: + case DATA_ACCESS_CDMA_IS95B: + ret = "CDMA"; + break; + case DATA_ACCESS_CDMA_1xRTT: + ret = "CDMA - 1xRTT"; + break; + case DATA_ACCESS_CDMA_EvDo_0: + ret = "CDMA - EvDo rev. 0"; + break; + case DATA_ACCESS_CDMA_EvDo_A: + ret = "CDMA - EvDo rev. A"; + break; + default: + if (DBG) { + Log.e(LOG_TAG, "Wrong network. Can not return a string."); + } + break; + } + + return ret; + } + + private void + pollStateDone() { + if (DBG) { + Log.d(LOG_TAG, "Poll ServiceState done: " + + " oldSS=[" + ss ); + Log.d(LOG_TAG, "Poll ServiceState done: " + + " newSS=[" + newSS); + } + + boolean hasRegistered = + ss.getState() != ServiceState.STATE_IN_SERVICE + && newSS.getState() == ServiceState.STATE_IN_SERVICE; + + boolean hasDeregistered = + ss.getState() == ServiceState.STATE_IN_SERVICE + && newSS.getState() != ServiceState.STATE_IN_SERVICE; + + boolean hasCdmaDataConnectionAttached = + (this.cdmaDataConnectionState != ServiceState.RADIO_TECHNOLOGY_1xRTT + && this.cdmaDataConnectionState != ServiceState.RADIO_TECHNOLOGY_EVDO_0 + && this.cdmaDataConnectionState != ServiceState.RADIO_TECHNOLOGY_EVDO_A) + && (this.newCdmaDataConnectionState == ServiceState.RADIO_TECHNOLOGY_1xRTT + || this.newCdmaDataConnectionState == ServiceState.RADIO_TECHNOLOGY_EVDO_0 + || this.newCdmaDataConnectionState == ServiceState.RADIO_TECHNOLOGY_EVDO_A); + + boolean hasCdmaDataConnectionDetached = + (this.cdmaDataConnectionState == ServiceState.RADIO_TECHNOLOGY_1xRTT + || this.cdmaDataConnectionState == ServiceState.RADIO_TECHNOLOGY_EVDO_0 + || this.cdmaDataConnectionState == ServiceState.RADIO_TECHNOLOGY_EVDO_A) + && (this.newCdmaDataConnectionState != ServiceState.RADIO_TECHNOLOGY_1xRTT + && this.newCdmaDataConnectionState != ServiceState.RADIO_TECHNOLOGY_EVDO_0 + && this.newCdmaDataConnectionState != ServiceState.RADIO_TECHNOLOGY_EVDO_A); + + boolean hasCdmaDataConnectionChanged = + cdmaDataConnectionState != newCdmaDataConnectionState; + + boolean hasNetworkTypeChanged = networkType != newNetworkType; + + boolean hasChanged = !newSS.equals(ss); + + boolean hasRoamingOn = !ss.getRoaming() && newSS.getRoaming(); + + boolean hasRoamingOff = ss.getRoaming() && !newSS.getRoaming(); + + boolean hasLocationChanged = !newCellLoc.equals(cellLoc); + + ServiceState tss; + tss = ss; + ss = newSS; + newSS = tss; + // clean slate for next time + newSS.setStateOutOfService(); + + CdmaCellLocation tcl = cellLoc; + cellLoc = newCellLoc; + newCellLoc = tcl; + + cdmaDataConnectionState = newCdmaDataConnectionState; + networkType = newNetworkType; + + newSS.setStateOutOfService(); // clean slate for next time + + if (hasNetworkTypeChanged) { + phone.setSystemProperty(PROPERTY_DATA_NETWORK_TYPE, + networkTypeToString(networkType)); + } + + if (hasRegistered) { + Checkin.updateStats(phone.getContext().getContentResolver(), + Checkin.Stats.Tag.PHONE_CDMA_REGISTERED, 1, 0.0); + networkAttachedRegistrants.notifyRegistrants(); + } + + if (hasChanged) { + String operatorNumeric; + + phone.setSystemProperty(PROPERTY_OPERATOR_ALPHA, + ss.getOperatorAlphaLong()); + + operatorNumeric = ss.getOperatorNumeric(); + phone.setSystemProperty(PROPERTY_OPERATOR_NUMERIC, operatorNumeric); + + if (operatorNumeric == null) { + phone.setSystemProperty(PROPERTY_OPERATOR_ISO_COUNTRY, ""); + } else { + String iso = ""; + try{ + iso = MccTable.countryCodeForMcc(Integer.parseInt( + operatorNumeric.substring(0,3))); + } catch ( NumberFormatException ex){ + Log.w(LOG_TAG, "countryCodeForMcc error" + ex); + } catch ( StringIndexOutOfBoundsException ex) { + Log.w(LOG_TAG, "countryCodeForMcc error" + ex); + } + + phone.setSystemProperty(PROPERTY_OPERATOR_ISO_COUNTRY, iso); + mGotCountryCode = true; + } + + phone.setSystemProperty(PROPERTY_OPERATOR_ISROAMING, + ss.getRoaming() ? "true" : "false"); + phone.setSystemProperty(PROPERTY_OPERATOR_ISMANUAL, + ss.getIsManualSelection() ? "true" : "false"); + + updateSpnDisplay(); + phone.notifyServiceStateChanged(ss); + } + + if (hasCdmaDataConnectionAttached) { + cdmaDataConnectionAttachedRegistrants.notifyRegistrants(); + } + + if (hasCdmaDataConnectionDetached) { + cdmaDataConnectionDetachedRegistrants.notifyRegistrants(); + } + + if (hasCdmaDataConnectionChanged) { + phone.notifyDataConnection(null); + } + + if (hasRoamingOn) { + roamingOnRegistrants.notifyRegistrants(); + } + + if (hasRoamingOff) { + roamingOffRegistrants.notifyRegistrants(); + } + + if (hasLocationChanged) { + phone.notifyLocationChanged(); + } + } + + /** + * Returns a TimeZone object based only on parameters from the NITZ string. + */ + private TimeZone getNitzTimeZone(int offset, boolean dst, long when) { + TimeZone guess = findTimeZone(offset, dst, when); + if (guess == null) { + // Couldn't find a proper timezone. Perhaps the DST data is wrong. + guess = findTimeZone(offset, !dst, when); + } + if (DBG) { + Log.d(LOG_TAG, "getNitzTimeZone returning " + + (guess == null ? guess : guess.getID())); + } + return guess; + } + + private TimeZone findTimeZone(int offset, boolean dst, long when) { + int rawOffset = offset; + if (dst) { + rawOffset -= 3600000; + } + String[] zones = TimeZone.getAvailableIDs(rawOffset); + TimeZone guess = null; + Date d = new Date(when); + for (String zone : zones) { + TimeZone tz = TimeZone.getTimeZone(zone); + if (tz.getOffset(when) == offset && + tz.inDaylightTime(d) == dst) { + guess = tz; + break; + } + } + + return guess; + } + + private void + queueNextSignalStrengthPoll() { + if (dontPollSignalStrength || (cm.getRadioState().isGsm())) { + // The radio is telling us about signal strength changes + // we don't have to ask it + return; + } + + Message msg; + + msg = obtainMessage(); + msg.what = EVENT_POLL_SIGNAL_STRENGTH; + + // TODO Done't poll signal strength if screen is off + sendMessageDelayed(msg, POLL_PERIOD_MILLIS); + } + + /** + * send signal-strength-changed notification if rssi changed + * Called both for solicited and unsolicited signal stength updates + */ + private void + onSignalStrengthResult(AsyncResult ar) { + int oldRSSI = rssi; + + if (ar.exception != null) { + // 99 = unknown + // most likely radio is resetting/disconnected + rssi = 99; + } else { + int[] ints = (int[])ar.result; + + // bug 658816 seems to be a case where the result is 0-length + if (ints.length != 0) { + rssi = ints[0]; + } else { + Log.e(LOG_TAG, "Bogus signal strength response"); + rssi = 99; + } + } + + if (rssi != oldRSSI) { + try { // This takes care of delayed EVENT_POLL_SIGNAL_STRENGTH (scheduled after + // POLL_PERIOD_MILLIS) during Radio Technology Change) + phone.notifySignalStrength(); + } catch (NullPointerException ex) { + log("onSignalStrengthResult() Phone already destroyed: " + ex + + "Signal Stranth not notified"); + } + } + } + + + private int radioTechnologyToServiceState(int code) { + int retVal = ServiceState.RADIO_TECHNOLOGY_UNKNOWN; + switch(code) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + break; + case 6: + retVal = ServiceState.RADIO_TECHNOLOGY_1xRTT; + break; + case 7: + retVal = ServiceState.RADIO_TECHNOLOGY_EVDO_0; + break; + case 8: + retVal = ServiceState.RADIO_TECHNOLOGY_EVDO_A; + break; + default: + Log.e(LOG_TAG, "Wrong radioTechnology code."); + break; + } + return(retVal); + } + + /** code is registration state 0-5 from TS 27.007 7.2 */ + private int + regCodeToServiceState(int code) { + switch (code) { + case 0: // Not searching and not registered + return ServiceState.STATE_OUT_OF_SERVICE; + case 1: + return ServiceState.STATE_IN_SERVICE; + case 2: // 2 is "searching", fall through + case 3: // 3 is "registration denied", fall through + case 4: // 4 is "unknown" no vaild in current baseband + return ServiceState.STATE_OUT_OF_SERVICE; + case 5:// fall through + case 6: + // Registered and: roaming (5) or roaming affiliates (6) + return ServiceState.STATE_IN_SERVICE; + + default: + Log.w(LOG_TAG, "unexpected service state " + code); + return ServiceState.STATE_OUT_OF_SERVICE; + } + } + + /** + * @return The current CDMA data connection state. ServiceState.RADIO_TECHNOLOGY_1xRTT or + * ServiceState.RADIO_TECHNOLOGY_EVDO is the same as "attached" and + * ServiceState.RADIO_TECHNOLOGY_UNKNOWN is the same as detached. + */ + /*package*/ int getCurrentCdmaDataConnectionState() { + return cdmaDataConnectionState; + } + + /** + * code is registration state 0-5 from TS 27.007 7.2 + * returns true if registered roam, false otherwise + */ + private boolean + regCodeIsRoaming (int code) { + // 5 is "in service -- roam" + return 5 == code; + } + + /** + * Set roaming state when cdmaRoaming is true and ons is different from spn + * @param cdmaRoaming TS 27.007 7.2 CREG registered roaming + * @param s ServiceState hold current ons + * @return true for roaming state set + */ + private + boolean isRoamingBetweenOperators(boolean cdmaRoaming, ServiceState s) { + String spn = SystemProperties.get(PROPERTY_ICC_OPERATOR_ALPHA, "empty"); + + String onsl = s.getOperatorAlphaLong(); + String onss = s.getOperatorAlphaShort(); + + boolean equalsOnsl = onsl != null && spn.equals(onsl); + boolean equalsOnss = onss != null && spn.equals(onss); + + return cdmaRoaming && !(equalsOnsl || equalsOnss); + } + + private boolean getAutoTime() { + try { + return Settings.System.getInt(phone.getContext().getContentResolver(), + Settings.System.AUTO_TIME) > 0; + } catch (SettingNotFoundException snfe) { + return true; + } + } + + /** + * @return true if phone is camping on a technology + * that could support voice and data simultaneously. + */ + boolean isConcurrentVoiceAndData() { + + // Note: it needs to be confirmed which CDMA network types + // can support voice and data calls concurrently. + // For the time-being, the return value will be false. + return false; + } + + protected void log(String s) { + Log.d(LOG_TAG, "[CdmaServiceStateTracker] " + s); + } + +} diff --git a/telephony/java/com/android/internal/telephony/cdma/FeatureCode.java b/telephony/java/com/android/internal/telephony/cdma/FeatureCode.java new file mode 100644 index 0000000..65b7336 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/FeatureCode.java @@ -0,0 +1,312 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import android.content.Context; +import android.os.*; +import android.util.Log; + +import com.android.internal.telephony.*; + +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * + * {@hide} + * + */ +public final class FeatureCode extends Handler implements MmiCode { + static final String LOG_TAG = "CDMA"; + + //***** Constants + + // Call Forwarding + static final String FC_CF_ACTIVATE = "72"; + static final String FC_CF_DEACTIVATE = "73"; + static final String FC_CF_FORWARD_TO_NUMBER = "56"; + + // Call Forwarding Busy Line + static final String FC_CFBL_ACTIVATE = "90"; + static final String FC_CFBL_DEACTIVATE = "91"; + static final String FC_CFBL_FORWARD_TO_NUMBER = "40"; + + // Call Forwarding Don't Answer + static final String FC_CFDA_ACTIVATE = "92"; + static final String FC_CFDA_DEACTIVATE = "93"; + static final String FC_CFDA_FORWARD_TO_NUMBER = "42"; + + // Cancel Call Waiting + static final String FC_CCW = "70"; + + // Usage Sensitive Three-way Calling + static final String FC_3WC = "71"; + + // Do Not Disturb + static final String FC_DND_ACTIVATE = "78"; + static final String FC_DND_DEACTIVATE = "79"; + + // Who Called Me? + static final String FC_WHO = "51"; + + // Rejection of Undesired Annoying Calls + static final String FC_RUAC_ACTIVATE = "60"; + static final String FC_RUAC_DEACTIVATE = "80"; + + // Calling Number Delivery + // Calling Number Identification Presentation + static final String FC_CNIP = "65"; + // Calling Number Identification Restriction + static final String FC_CNIR = "85"; + + + //***** Event Constants + + static final int EVENT_SET_COMPLETE = 1; + static final int EVENT_CDMA_FLASH_COMPLETED = 2; + + + //***** Instance Variables + + CDMAPhone phone; + Context context; + + String action; // '*' in CDMA + String sc; // Service Code + String poundString; // Entire Flash string + String dialingNumber; + + /** Set to true in processCode, not at newFromDialString time */ + + State state = State.PENDING; + CharSequence message; + + //***** Class Variables + + + // Flash Code Pattern + + static Pattern sPatternSuppService = Pattern.compile( + "((\\*)(\\d{2,3})(#?)([^*#]*)?)(.*)"); +/* 1 2 3 4 5 6 + + 1 = Full string up to and including # + 2 = action + 3 = service code + 4 = separator + 5 = dialing number +*/ + + static final int MATCH_GROUP_POUND_STRING = 1; + static final int MATCH_GROUP_ACTION_STRING = 2; + static final int MATCH_GROUP_SERVICE_CODE = 3; + static final int MATCH_GROUP_DIALING_NUMBER = 5; + + + //***** Public Class methods + + /** + * Some dial strings in CDMA are defined to do non-call setup + * things, such as set supplementary service settings (eg, call + * forwarding). These are generally referred to as "Feature Codes". + * We look to see if the dial string contains a valid Feature code (potentially + * with a dial string at the end as well) and return info here. + * + * If the dial string contains no Feature code, we return an instance with + * only "dialingNumber" set + * + * Please see also S.R0006-000-A v2.0 "Wireless Features Description" + */ + + static FeatureCode newFromDialString(String dialString, CDMAPhone phone) { + Matcher m; + FeatureCode ret = null; + + m = sPatternSuppService.matcher(dialString); + + // Is this formatted like a standard supplementary service code? + if (m.matches()) { + ret = new FeatureCode(phone); + ret.poundString = makeEmptyNull(m.group(MATCH_GROUP_POUND_STRING)); + ret.action = makeEmptyNull(m.group(MATCH_GROUP_ACTION_STRING)); + ret.sc = makeEmptyNull(m.group(MATCH_GROUP_SERVICE_CODE)); + ret.dialingNumber = makeEmptyNull(m.group(MATCH_GROUP_DIALING_NUMBER)); + } + + return ret; + } + + //***** Private Class methods + + /** make empty strings be null. + * Java regexp returns empty strings for empty groups + */ + private static String makeEmptyNull (String s) { + if (s != null && s.length() == 0) return null; + + return s; + } + + /** returns true of the string is empty or null */ + private static boolean isEmptyOrNull(CharSequence s) { + return s == null || (s.length() == 0); + } + + static boolean isServiceCodeCallForwarding(String sc) { + return sc != null && + (sc.equals(FC_CF_ACTIVATE) + || sc.equals(FC_CF_DEACTIVATE) || sc.equals(FC_CF_FORWARD_TO_NUMBER) + || sc.equals(FC_CFBL_ACTIVATE) || sc.equals(FC_CFBL_DEACTIVATE) + || sc.equals(FC_CFBL_FORWARD_TO_NUMBER) || sc.equals(FC_CFDA_ACTIVATE) + || sc.equals(FC_CFDA_DEACTIVATE) || sc.equals(FC_CFDA_FORWARD_TO_NUMBER)); + } + + static boolean isServiceCodeCallWaiting(String sc) { + return sc != null && sc.equals(FC_CCW); + } + + static boolean isServiceCodeThreeWayCalling(String sc) { + return sc != null && sc.equals(FC_3WC); + } + + static boolean isServiceCodeAnnoyingCalls(String sc) { + return sc != null && + (sc.equals(FC_RUAC_ACTIVATE) + || sc.equals(FC_RUAC_DEACTIVATE)); + } + + static boolean isServiceCodeCallingNumberDelivery(String sc) { + return sc != null && + (sc.equals(FC_CNIP) + || sc.equals(FC_CNIR)); + } + + static boolean isServiceCodeDoNotDisturb(String sc) { + return sc != null && + (sc.equals(FC_DND_ACTIVATE) + || sc.equals(FC_DND_DEACTIVATE)); + } + + + //***** Constructor + + FeatureCode (CDMAPhone phone) { + super(phone.getHandler().getLooper()); + this.phone = phone; + this.context = phone.getContext(); + } + + + //***** MmiCode implementation + + public State getState() { + return state; + } + + public CharSequence getMessage() { + return message; + } + + // inherited javadoc suffices + public void cancel() { + //Not used here + } + + public boolean isCancelable() { + Log.e(LOG_TAG, "isCancelable: not used in CDMA"); + return false; + } + + public boolean isUssdRequest() { + Log.e(LOG_TAG, "isUssdRequest: not used in CDMA"); + return false; + } + + /** Process a Flash Code...anything that isn't a dialing number */ + void processCode () { + Log.d(LOG_TAG, "send feature code..."); + phone.mCM.sendCDMAFeatureCode(this.poundString, + obtainMessage(EVENT_CDMA_FLASH_COMPLETED)); + } + + /** Called from CDMAPhone.handleMessage; not a Handler subclass */ + public void handleMessage (Message msg) { + AsyncResult ar; + + switch (msg.what) { + case EVENT_SET_COMPLETE: + ar = (AsyncResult) (msg.obj); + onSetComplete(ar); + break; + case EVENT_CDMA_FLASH_COMPLETED: + ar = (AsyncResult) (msg.obj); + + if (ar.exception != null) { + state = State.FAILED; + message = context.getText(com.android.internal.R.string.mmiError); + } else { + state = State.COMPLETE; + message = context.getText(com.android.internal.R.string.mmiComplete); + } + phone.onMMIDone(this); + break; + } + } + + + //***** Private instance methods + + private CharSequence getScString() { + if (sc != null) { + if (isServiceCodeCallForwarding(sc)) { + return context.getText(com.android.internal.R.string.CfMmi); + } else if (isServiceCodeCallWaiting(sc)) { + return context.getText(com.android.internal.R.string.CwMmi); + } else if (sc.equals(FC_CNIP)) { + return context.getText(com.android.internal.R.string.CnipMmi); + } else if (sc.equals(FC_CNIR)) { + return context.getText(com.android.internal.R.string.CnirMmi); + } else if (isServiceCodeThreeWayCalling(sc)) { + return context.getText(com.android.internal.R.string.ThreeWCMmi); + } else if (isServiceCodeAnnoyingCalls(sc)) { + return context.getText(com.android.internal.R.string.RuacMmi); + } else if (isServiceCodeCallingNumberDelivery(sc)) { + return context.getText(com.android.internal.R.string.CndMmi); + } else if (isServiceCodeDoNotDisturb(sc)) { + return context.getText(com.android.internal.R.string.DndMmi); + } + } + + return ""; + } + + private void onSetComplete(AsyncResult ar){ + StringBuilder sb = new StringBuilder(getScString()); + sb.append("\n"); + + if (ar.exception != null) { + state = State.FAILED; + sb.append(context.getText(com.android.internal.R.string.mmiError)); + } else { + state = State.FAILED; + sb.append(context.getText(com.android.internal.R.string.mmiError)); + } + + message = sb; + phone.onMMIDone(this); + } +} diff --git a/telephony/java/com/android/internal/telephony/cdma/RuimCard.java b/telephony/java/com/android/internal/telephony/cdma/RuimCard.java new file mode 100644 index 0000000..9d9f479 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/RuimCard.java @@ -0,0 +1,522 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.os.Registrant; +import android.os.RegistrantList; +import android.os.RemoteException; +import android.util.Log; + +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.IccCard; +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneProxy; +import com.android.internal.telephony.TelephonyIntents; +import com.android.internal.telephony.TelephonyProperties; + +import android.app.ActivityManagerNative; +import android.content.Intent; +import android.content.res.Configuration; + +import static android.Manifest.permission.READ_PHONE_STATE; + +/** + * Note: this class shares common code with SimCard, consider a base class to minimize code + * duplication. + * {@hide} + */ +public final class RuimCard extends Handler implements IccCard { + static final String LOG_TAG="CDMA"; + + //***** Instance Variables + private static final boolean DBG = true; + + private CDMAPhone phone; + + private CommandsInterface.IccStatus status = null; + private boolean mDesiredPinLocked; + private boolean mDesiredFdnEnabled; + private boolean mRuimPinLocked = true; // default to locked + private boolean mRuimFdnEnabled = false; // Default to disabled. + // Will be updated when RUIM_READY. +// //***** Constants + +// // FIXME I hope this doesn't conflict with the Dialer's notifications +// Nobody is using this at the moment +// static final int NOTIFICATION_ID_ICC_STATUS = 33456; + + //***** Event Constants + + static final int EVENT_RUIM_LOCKED_OR_ABSENT = 1; + static final int EVENT_GET_RUIM_STATUS_DONE = 2; + static final int EVENT_RADIO_OFF_OR_NOT_AVAILABLE = 3; + static final int EVENT_PINPUK_DONE = 4; + static final int EVENT_REPOLL_STATUS_DONE = 5; + static final int EVENT_RUIM_READY = 6; + static final int EVENT_QUERY_FACILITY_LOCK_DONE = 7; + static final int EVENT_CHANGE_FACILITY_LOCK_DONE = 8; + static final int EVENT_CHANGE_RUIM_PASSWORD_DONE = 9; + static final int EVENT_QUERY_FACILITY_FDN_DONE = 10; + static final int EVENT_CHANGE_FACILITY_FDN_DONE = 11; + + + //***** Constructor + + RuimCard(CDMAPhone phone) { + this.phone = phone; + + phone.mCM.registerForRUIMLockedOrAbsent( + this, EVENT_RUIM_LOCKED_OR_ABSENT, null); + + phone.mCM.registerForOffOrNotAvailable( + this, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null); + + phone.mCM.registerForRUIMReady( + this, EVENT_RUIM_READY, null); + + updateStateProperty(); + } + + //***** RuimCard implementation + + public State + getState() { + if (status == null) { + switch(phone.mCM.getRadioState()) { + /* This switch block must not return anything in + * State.isLocked() or State.ABSENT. + * If it does, handleSimStatus() may break + */ + case RADIO_OFF: + case RADIO_UNAVAILABLE: + case RUIM_NOT_READY: + return State.UNKNOWN; + case RUIM_LOCKED_OR_ABSENT: + //this should be transient-only + return State.UNKNOWN; + case RUIM_READY: + return State.READY; + case NV_READY: + case NV_NOT_READY: + return State.ABSENT; + } + } else { + switch (status) { + case ICC_ABSENT: return State.ABSENT; + case ICC_NOT_READY: return State.UNKNOWN; + case ICC_READY: return State.READY; + case ICC_PIN: return State.PIN_REQUIRED; + case ICC_PUK: return State.PUK_REQUIRED; + case ICC_NETWORK_PERSONALIZATION: return State.NETWORK_LOCKED; + } + } + + Log.e(LOG_TAG, "RuimCard.getState(): case should never be reached"); + return State.UNKNOWN; + } + + public void dispose() { + //Unregister for all events + phone.mCM.unregisterForRUIMLockedOrAbsent(this); + phone.mCM.unregisterForOffOrNotAvailable(this); + phone.mCM.unregisterForRUIMReady(this); + } + + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "RuimCard finalized"); + } + + private RegistrantList absentRegistrants = new RegistrantList(); + private RegistrantList pinLockedRegistrants = new RegistrantList(); + private RegistrantList networkLockedRegistrants = new RegistrantList(); + + + public void registerForAbsent(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + absentRegistrants.add(r); + + if (getState() == State.ABSENT) { + r.notifyRegistrant(); + } + } + + public void unregisterForAbsent(Handler h) { + absentRegistrants.remove(h); + } + + public void registerForNetworkLocked(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + networkLockedRegistrants.add(r); + + if (getState() == State.NETWORK_LOCKED) { + r.notifyRegistrant(); + } + } + + public void unregisterForNetworkLocked(Handler h) { + networkLockedRegistrants.remove(h); + } + + public void registerForLocked(Handler h, int what, Object obj) { + Registrant r = new Registrant (h, what, obj); + + pinLockedRegistrants.add(r); + + if (getState().isPinLocked()) { + r.notifyRegistrant(); + } + } + + public void unregisterForLocked(Handler h) { + pinLockedRegistrants.remove(h); + } + + public void supplyPin (String pin, Message onComplete) { + phone.mCM.supplyIccPin(pin, obtainMessage(EVENT_PINPUK_DONE, onComplete)); + } + + public void supplyPuk (String puk, String newPin, Message onComplete) { + phone.mCM.supplyIccPuk(puk, newPin, obtainMessage(EVENT_PINPUK_DONE, onComplete)); + } + + public void supplyPin2 (String pin2, Message onComplete) { + phone.mCM.supplyIccPin2(pin2, obtainMessage(EVENT_PINPUK_DONE, onComplete)); + } + + public void supplyPuk2 (String puk2, String newPin2, Message onComplete) { + phone.mCM.supplyIccPuk2(puk2, newPin2, obtainMessage(EVENT_PINPUK_DONE, onComplete)); + } + + public void supplyNetworkDepersonalization (String pin, Message onComplete) { + if(DBG) log("Network Despersonalization: " + pin); + phone.mCM.supplyNetworkDepersonalization(pin, + obtainMessage(EVENT_PINPUK_DONE, onComplete)); + } + + public boolean getIccLockEnabled() { + return mRuimPinLocked; + } + + public boolean getIccFdnEnabled() { + return mRuimFdnEnabled; + } + + public void setIccLockEnabled (boolean enabled, + String password, Message onComplete) { + int serviceClassX; + serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE + + CommandsInterface.SERVICE_CLASS_DATA + + CommandsInterface.SERVICE_CLASS_FAX; + + mDesiredPinLocked = enabled; + + phone.mCM.setFacilityLock(CommandsInterface.CB_FACILITY_BA_SIM, + enabled, password, serviceClassX, + obtainMessage(EVENT_CHANGE_FACILITY_LOCK_DONE, onComplete)); + } + + public void setIccFdnEnabled (boolean enabled, + String password, Message onComplete) { + int serviceClassX; + serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE + + CommandsInterface.SERVICE_CLASS_DATA + + CommandsInterface.SERVICE_CLASS_FAX + + CommandsInterface.SERVICE_CLASS_SMS; + + mDesiredFdnEnabled = enabled; + + phone.mCM.setFacilityLock(CommandsInterface.CB_FACILITY_BA_FD, + enabled, password, serviceClassX, + obtainMessage(EVENT_CHANGE_FACILITY_FDN_DONE, onComplete)); + } + + public void changeIccLockPassword(String oldPassword, String newPassword, + Message onComplete) { + if(DBG) log("Change Pin1 old: " + oldPassword + " new: " + newPassword); + phone.mCM.changeIccPin(oldPassword, newPassword, + obtainMessage(EVENT_CHANGE_RUIM_PASSWORD_DONE, onComplete)); + } + + public void changeIccFdnPassword(String oldPassword, String newPassword, + Message onComplete) { + if(DBG) log("Change Pin2 old: " + oldPassword + " new: " + newPassword); + phone.mCM.changeIccPin2(oldPassword, newPassword, + obtainMessage(EVENT_CHANGE_RUIM_PASSWORD_DONE, onComplete)); + } + + public String getServiceProviderName() { + return phone.mRuimRecords.getServiceProviderName(); + } + + //***** Handler implementation + @Override + public void handleMessage(Message msg){ + AsyncResult ar; + int serviceClassX; + + serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE + + CommandsInterface.SERVICE_CLASS_DATA + + CommandsInterface.SERVICE_CLASS_FAX; + + switch (msg.what) { + case EVENT_RADIO_OFF_OR_NOT_AVAILABLE: + Log.d(LOG_TAG, "Event EVENT_RADIO_OFF_OR_NOT_AVAILABLE Received"); + status = null; + updateStateProperty(); + broadcastRuimStateChangedIntent(RuimCard.INTENT_VALUE_ICC_NOT_READY, null); + break; + case EVENT_RUIM_READY: + Log.d(LOG_TAG, "Event EVENT_RUIM_READY Received"); + //TODO: put facility read in SIM_READY now, maybe in REG_NW + phone.mCM.getIccStatus(obtainMessage(EVENT_GET_RUIM_STATUS_DONE)); + phone.mCM.queryFacilityLock ( + CommandsInterface.CB_FACILITY_BA_SIM, "", serviceClassX, + obtainMessage(EVENT_QUERY_FACILITY_LOCK_DONE)); + phone.mCM.queryFacilityLock ( + CommandsInterface.CB_FACILITY_BA_FD, "", serviceClassX, + obtainMessage(EVENT_QUERY_FACILITY_FDN_DONE)); + break; + case EVENT_RUIM_LOCKED_OR_ABSENT: + Log.d(LOG_TAG, "Event EVENT_RUIM_LOCKED_OR_ABSENT Received"); + phone.mCM.getIccStatus(obtainMessage(EVENT_GET_RUIM_STATUS_DONE)); + phone.mCM.queryFacilityLock ( + CommandsInterface.CB_FACILITY_BA_SIM, "", serviceClassX, + obtainMessage(EVENT_QUERY_FACILITY_LOCK_DONE)); + break; + case EVENT_GET_RUIM_STATUS_DONE: + Log.d(LOG_TAG, "Event EVENT_GET_RUIM_STATUS_DONE Received"); + ar = (AsyncResult)msg.obj; + + getRuimStatusDone(ar); + break; + case EVENT_PINPUK_DONE: + Log.d(LOG_TAG, "Event EVENT_PINPUK_DONE Received"); + // a PIN/PUK/PIN2/PUK2/Network Personalization + // request has completed. ar.userObj is the response Message + // Repoll before returning + ar = (AsyncResult)msg.obj; + // TODO should abstract these exceptions + AsyncResult.forMessage(((Message)ar.userObj)).exception + = ar.exception; + phone.mCM.getIccStatus( + obtainMessage(EVENT_REPOLL_STATUS_DONE, ar.userObj)); + break; + case EVENT_REPOLL_STATUS_DONE: + Log.d(LOG_TAG, "Event EVENT_REPOLL_STATUS_DONE Received"); + // Finished repolling status after PIN operation + // ar.userObj is the response messaeg + // ar.userObj.obj is already an AsyncResult with an + // appropriate exception filled in if applicable + + ar = (AsyncResult)msg.obj; + getRuimStatusDone(ar); + ((Message)ar.userObj).sendToTarget(); + break; + case EVENT_QUERY_FACILITY_LOCK_DONE: + Log.d(LOG_TAG, "Event EVENT_QUERY_FACILITY_LOCK_DONE Received"); + ar = (AsyncResult)msg.obj; + onQueryFacilityLock(ar); + break; + case EVENT_QUERY_FACILITY_FDN_DONE: + Log.d(LOG_TAG, "Event EVENT_QUERY_FACILITY_FDN_DONE Received"); + ar = (AsyncResult)msg.obj; + onQueryFdnEnabled(ar); + break; + case EVENT_CHANGE_FACILITY_LOCK_DONE: + Log.d(LOG_TAG, "Event EVENT_CHANGE_FACILITY_LOCK_DONE Received"); + ar = (AsyncResult)msg.obj; + if (ar.exception == null) { + mRuimPinLocked = mDesiredPinLocked; + if (DBG) log( "EVENT_CHANGE_FACILITY_LOCK_DONE: " + + "mRuimPinLocked= " + mRuimPinLocked); + } else { + Log.e(LOG_TAG, "Error change facility lock with exception " + + ar.exception); + } + AsyncResult.forMessage(((Message)ar.userObj)).exception + = ar.exception; + ((Message)ar.userObj).sendToTarget(); + break; + case EVENT_CHANGE_FACILITY_FDN_DONE: + Log.d(LOG_TAG, "Event EVENT_CHANGE_FACILITY_FDN_DONE Received"); + ar = (AsyncResult)msg.obj; + + if (ar.exception == null) { + mRuimFdnEnabled = mDesiredFdnEnabled; + if (DBG) log("EVENT_CHANGE_FACILITY_FDN_DONE: " + + "mRuimFdnEnabled=" + mRuimFdnEnabled); + } else { + Log.e(LOG_TAG, "Error change facility fdn with exception " + + ar.exception); + } + AsyncResult.forMessage(((Message)ar.userObj)).exception + = ar.exception; + ((Message)ar.userObj).sendToTarget(); + break; + case EVENT_CHANGE_RUIM_PASSWORD_DONE: + Log.d(LOG_TAG, "Event EVENT_CHANGE_RUIM_PASSWORD_DONE Received"); + ar = (AsyncResult)msg.obj; + if(ar.exception != null) { + Log.e(LOG_TAG, "Error in change sim password with exception" + + ar.exception); + } + AsyncResult.forMessage(((Message)ar.userObj)).exception + = ar.exception; + ((Message)ar.userObj).sendToTarget(); + break; + default: + Log.e(LOG_TAG, "[CdmaRuimCard] Unknown Event " + msg.what); + } + } + + //***** Private methods + + /** + * Interpret EVENT_QUERY_FACILITY_LOCK_DONE + * @param ar is asyncResult of Query_Facility_Locked + */ + private void onQueryFacilityLock(AsyncResult ar) { + if(ar.exception != null) { + if (DBG) log("Error in querying facility lock:" + ar.exception); + return; + } + + int[] ints = (int[])ar.result; + if(ints.length != 0) { + mRuimPinLocked = (0!=ints[0]); + if(DBG) log("Query facility lock : " + mRuimPinLocked); + } else { + Log.e(LOG_TAG, "[CdmaRuimCard] Bogus facility lock response"); + } + } + + /** + * Interpret EVENT_QUERY_FACILITY_LOCK_DONE + * @param ar is asyncResult of Query_Facility_Locked + */ + private void onQueryFdnEnabled(AsyncResult ar) { + if(ar.exception != null) { + if(DBG) log("Error in querying facility lock:" + ar.exception); + return; + } + + int[] ints = (int[])ar.result; + if(ints.length != 0) { + mRuimFdnEnabled = (0!=ints[0]); + if(DBG) log("Query facility lock : " + mRuimFdnEnabled); + } else { + Log.e(LOG_TAG, "[CdmaRuimCard] Bogus facility lock response"); + } + } + + private void + getRuimStatusDone(AsyncResult ar) { + if (ar.exception != null) { + Log.e(LOG_TAG,"Error getting SIM status. " + + "RIL_REQUEST_GET_SIM_STATUS should " + + "never return an error", ar.exception); + return; + } + + CommandsInterface.IccStatus newStatus + = (CommandsInterface.IccStatus) ar.result; + + handleRuimStatus(newStatus); + } + + private void + handleRuimStatus(CommandsInterface.IccStatus newStatus) { + boolean transitionedIntoPinLocked; + boolean transitionedIntoAbsent; + boolean transitionedIntoNetworkLocked; + + RuimCard.State oldState, newState; + + oldState = getState(); + status = newStatus; + newState = getState(); + + updateStateProperty(); + + transitionedIntoPinLocked = ( + (oldState != State.PIN_REQUIRED && newState == State.PIN_REQUIRED) + || (oldState != State.PUK_REQUIRED && newState == State.PUK_REQUIRED)); + transitionedIntoAbsent = (oldState != State.ABSENT && newState == State.ABSENT); + transitionedIntoNetworkLocked = (oldState != State.NETWORK_LOCKED + && newState == State.NETWORK_LOCKED); + + if (transitionedIntoPinLocked) { + if(DBG) log("Notify RUIM pin or puk locked."); + pinLockedRegistrants.notifyRegistrants(); + broadcastRuimStateChangedIntent(RuimCard.INTENT_VALUE_ICC_LOCKED, + (newState == State.PIN_REQUIRED) ? + INTENT_VALUE_LOCKED_ON_PIN : INTENT_VALUE_LOCKED_ON_PUK); + } else if (transitionedIntoAbsent) { + if(DBG) log("Notify RUIM missing."); + absentRegistrants.notifyRegistrants(); + broadcastRuimStateChangedIntent(RuimCard.INTENT_VALUE_ICC_ABSENT, null); + } else if (transitionedIntoNetworkLocked) { + if(DBG) log("Notify RUIM network locked."); + networkLockedRegistrants.notifyRegistrants(); + broadcastRuimStateChangedIntent(RuimCard.INTENT_VALUE_ICC_LOCKED, + INTENT_VALUE_LOCKED_NETWORK); + } + } + + public void broadcastRuimStateChangedIntent(String value, String reason) { + Intent intent = new Intent(TelephonyIntents.ACTION_SIM_STATE_CHANGED); + intent.putExtra(Phone.PHONE_NAME_KEY, phone.getPhoneName()); + intent.putExtra(RuimCard.INTENT_KEY_ICC_STATE, value); + intent.putExtra(RuimCard.INTENT_KEY_LOCKED_REASON, reason); + if(DBG) log("Broadcasting intent SIM_STATE_CHANGED_ACTION " + value + + " reason " + reason); + ActivityManagerNative.broadcastStickyIntent(intent, READ_PHONE_STATE); + } + + public void updateImsiConfiguration(String imsi) { + if (imsi.length() >= 6) { + Configuration config = new Configuration(); + config.mcc = ((imsi.charAt(0)-'0')*100) + + ((imsi.charAt(1)-'0')*10) + + (imsi.charAt(2)-'0'); + config.mnc = ((imsi.charAt(3)-'0')*100) + + ((imsi.charAt(4)-'0')*10) + + (imsi.charAt(5)-'0'); + try { + ActivityManagerNative.getDefault().updateConfiguration(config); + } catch (RemoteException e) { + } + } + } + + private void + updateStateProperty() { + phone.setSystemProperty( + TelephonyProperties.PROPERTY_SIM_STATE, + getState().toString()); + } + + private void log(String msg) { + Log.d(LOG_TAG, "[RuimCard] " + msg); + } +} + diff --git a/telephony/java/com/android/internal/telephony/cdma/RuimFileHandler.java b/telephony/java/com/android/internal/telephony/cdma/RuimFileHandler.java new file mode 100644 index 0000000..7d392f0 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/RuimFileHandler.java @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import android.os.*; +import android.os.AsyncResult; +import android.util.Log; + +import com.android.internal.telephony.IccConstants; +import com.android.internal.telephony.IccException; +import com.android.internal.telephony.IccFileHandler; +import com.android.internal.telephony.IccFileTypeMismatch; +import com.android.internal.telephony.IccIoResult; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.PhoneProxy; + +import java.util.ArrayList; + +/** + * {@hide} + */ +public final class RuimFileHandler extends IccFileHandler { + static final String LOG_TAG = "CDMA"; + + //***** Instance Variables + + //***** Constructor + RuimFileHandler(CDMAPhone phone) { + super(phone); + } + + public void dispose() { + } + + protected void finalize() { + Log.d(LOG_TAG, "RuimFileHandler finalized"); + } + + //***** Overridden from IccFileHandler + + @Override + public void loadEFImgTransparent(int fileid, int highOffset, int lowOffset, + int length, Message onLoaded) { + Message response = obtainMessage(EVENT_READ_ICON_DONE, fileid, 0, + onLoaded); + + phone.mCM.iccIO(COMMAND_GET_RESPONSE, fileid, "img", 0, 0, + GET_RESPONSE_EF_IMG_SIZE_BYTES, null, null, response); + } + + @Override + public void handleMessage(Message msg) { + + super.handleMessage(msg); + } + + protected void logd(String msg) { + Log.d(LOG_TAG, "[RuimFileHandler] " + msg); + } + + protected void loge(String msg) { + Log.e(LOG_TAG, "[RuimFileHandler] " + msg); + } + +} diff --git a/telephony/java/com/android/internal/telephony/cdma/RuimPhoneBookInterfaceManager.java b/telephony/java/com/android/internal/telephony/cdma/RuimPhoneBookInterfaceManager.java new file mode 100644 index 0000000..78e89d5 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/RuimPhoneBookInterfaceManager.java @@ -0,0 +1,101 @@ +/* +** Copyright 2007, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +package com.android.internal.telephony.cdma; + +import android.content.pm.PackageManager; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.os.ServiceManager; +import android.telephony.PhoneNumberUtils; +import android.util.Log; + +import com.android.internal.telephony.AdnRecord; +import com.android.internal.telephony.AdnRecordCache; +import com.android.internal.telephony.IccPhoneBookInterfaceManager; +import com.android.internal.telephony.PhoneProxy; + +import java.util.ArrayList; +import java.util.List; + +/** + * RuimPhoneBookInterfaceManager to provide an inter-process communication to + * access ADN-like SIM records. + */ + + +public class RuimPhoneBookInterfaceManager extends IccPhoneBookInterfaceManager { + static final String LOG_TAG = "CDMA"; + + + Handler mHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + AsyncResult ar; + + switch(msg.what) { + default: + mBaseHandler.handleMessage(msg); + break; + } + } + }; + + public RuimPhoneBookInterfaceManager(CDMAPhone phone) { + super(phone); + adnCache = phone.mRuimRecords.getAdnCache(); + //NOTE service "simphonebook" added by IccSmsInterfaceManagerProxy + } + + public void dispose() { + super.dispose(); + } + + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "RuimPhoneBookInterfaceManager finalized"); + } + + public int[] getAdnRecordsSize(int efid) { + if (DBG) logd("getAdnRecordsSize: efid=" + efid); + synchronized(mLock) { + checkThread(); + recordSize = new int[3]; + + //Using mBaseHandler, no difference in EVENT_GET_SIZE_DONE handling + Message response = mBaseHandler.obtainMessage(EVENT_GET_SIZE_DONE); + + phone.getIccFileHandler().getEFLinearRecordSize(efid, response); + try { + mLock.wait(); + } catch (InterruptedException e) { + logd("interrupted while trying to load from the RUIM"); + } + } + + return recordSize; + } + + protected void logd(String msg) { + Log.d(LOG_TAG, "[RuimPbInterfaceManager] " + msg); + } + + protected void loge(String msg) { + Log.e(LOG_TAG, "[RuimPbInterfaceManager] " + msg); + } +} + diff --git a/telephony/java/com/android/internal/telephony/cdma/RuimRecords.java b/telephony/java/com/android/internal/telephony/cdma/RuimRecords.java new file mode 100644 index 0000000..7776f8b --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/RuimRecords.java @@ -0,0 +1,380 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_ICC_OPERATOR_ISO_COUNTRY; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.os.Registrant; +import android.util.Log; + +import static com.android.internal.telephony.TelephonyProperties.*; +import com.android.internal.telephony.AdnRecord; +import com.android.internal.telephony.AdnRecordCache; +import com.android.internal.telephony.AdnRecordLoader; +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.cdma.RuimCard; +import com.android.internal.telephony.gsm.MccTable; + +// can't be used since VoiceMailConstants is not public +//import com.android.internal.telephony.gsm.VoiceMailConstants; +import com.android.internal.telephony.IccException; +import com.android.internal.telephony.IccRecords; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.PhoneProxy; + + +/** + * {@hide} + */ +public final class RuimRecords extends IccRecords { + static final String LOG_TAG = "CDMA"; + + private static final boolean DBG = true; + + //***** Instance Variables + String imsi_m; + String mdn = null; // My mobile number + String h_sid; + String h_nid; + + // is not initialized + + //***** Event Constants + + private static final int EVENT_RUIM_READY = 1; + private static final int EVENT_RADIO_OFF_OR_NOT_AVAILABLE = 2; + private static final int EVENT_GET_DEVICE_IDENTITY_DONE = 4; + private static final int EVENT_GET_ICCID_DONE = 5; + private static final int EVENT_GET_CDMA_SUBSCRIPTION_DONE = 10; + private static final int EVENT_UPDATE_DONE = 14; + private static final int EVENT_GET_SST_DONE = 17; + private static final int EVENT_GET_ALL_SMS_DONE = 18; + private static final int EVENT_MARK_SMS_READ_DONE = 19; + + private static final int EVENT_SMS_ON_RUIM = 21; + private static final int EVENT_GET_SMS_DONE = 22; + + private static final int EVENT_RUIM_REFRESH = 31; + + //***** Constructor + + RuimRecords(CDMAPhone p) { + super(p); + + adnCache = new AdnRecordCache(phone); + + recordsRequested = false; // No load request is made till SIM ready + + // recordsToLoad is set to 0 because no requests are made yet + recordsToLoad = 0; + + + p.mCM.registerForRUIMReady(this, EVENT_RUIM_READY, null); + p.mCM.registerForOffOrNotAvailable(this, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null); + // NOTE the EVENT_SMS_ON_RUIM is not registered + p.mCM.setOnIccRefresh(this, EVENT_RUIM_REFRESH, null); + + // Start off by setting empty state + onRadioOffOrNotAvailable(); + + } + + public void dispose() { + //Unregister for all events + phone.mCM.unregisterForRUIMReady(this); + phone.mCM.unregisterForOffOrNotAvailable( this); + phone.mCM.unSetOnIccRefresh(this); + } + + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "RuimRecords finalized"); + } + + protected void onRadioOffOrNotAvailable() { + countVoiceMessages = 0; + mncLength = 0; + iccid = null; + + adnCache.reset(); + + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_NUMERIC, null); + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_ISO_COUNTRY, null); + + // recordsRequested is set to false indicating that the SIM + // read requests made so far are not valid. This is set to + // true only when fresh set of read requests are made. + recordsRequested = false; + } + + //***** Public Methods + + /** Returns null if RUIM is not yet ready */ + public String getIMSI_M() { + return imsi_m; + } + + public String getMdnNumber() { + return mdn; + } + + public void setVoiceMailNumber(String alphaTag, String voiceNumber, Message onComplete){ + // In CDMA this is Operator/OEM dependent + AsyncResult.forMessage((onComplete)).exception = + new IccException("setVoiceMailNumber not implemented"); + onComplete.sendToTarget(); + Log.e(LOG_TAG, "method setVoiceMailNumber is not implemented"); + } + + /** + * Called by CCAT Service when REFRESH is received. + * @param fileChanged indicates whether any files changed + * @param fileList if non-null, a list of EF files that changed + */ + public void onRefresh(boolean fileChanged, int[] fileList) { + if (fileChanged) { + // A future optimization would be to inspect fileList and + // only reload those files that we care about. For now, + // just re-fetch all RUIM records that we cache. + fetchRuimRecords(); + } + } + + /** Returns the 5 or 6 digit MCC/MNC of the operator that + * provided the RUIM card. Returns null of RUIM is not yet ready + */ + String getRUIMOperatorNumeric() { + if (imsi_m == null) { + return null; + } + + if (mncLength != 0) { + // Length = length of MCC + length of MNC + // TODO: change spec name + // length of mcc = 3 (3GPP2 C.S0005 - Section 2.3) + return imsi_m.substring(0, 3 + mncLength); + } + + // Guess the MNC length based on the MCC if we don't + // have a valid value in ef[ad] + + int mcc; + + mcc = Integer.parseInt(imsi_m.substring(0,3)); + + return imsi_m.substring(0, 3 + MccTable.smallestDigitsMccForMnc(mcc)); + } + + //***** Overridden from Handler + public void handleMessage(Message msg) { + AsyncResult ar; + + byte data[]; + + boolean isRecordLoadResponse = false; + + try { switch (msg.what) { + case EVENT_RUIM_READY: + onRuimReady(); + break; + + case EVENT_RADIO_OFF_OR_NOT_AVAILABLE: + onRadioOffOrNotAvailable(); + break; + + case EVENT_GET_DEVICE_IDENTITY_DONE: + Log.d(LOG_TAG, "Event EVENT_GET_DEVICE_IDENTITY_DONE Received"); + break; + + /* IO events */ + + case EVENT_GET_CDMA_SUBSCRIPTION_DONE: + ar = (AsyncResult)msg.obj; + String localTemp[] = (String[])ar.result; + if (ar.exception != null) { + break; + } + + mdn = localTemp[0]; + h_sid = localTemp[1]; + h_nid = localTemp[2]; + + Log.d(LOG_TAG, "MDN: " + mdn); + + break; + + case EVENT_GET_ICCID_DONE: + isRecordLoadResponse = true; + + ar = (AsyncResult)msg.obj; + data = (byte[])ar.result; + + if (ar.exception != null) { + break; + } + + iccid = IccUtils.bcdToString(data, 0, data.length); + + Log.d(LOG_TAG, "iccid: " + iccid); + + break; + + case EVENT_UPDATE_DONE: + ar = (AsyncResult)msg.obj; + if (ar.exception != null) { + Log.i(LOG_TAG, "RuimRecords update failed", ar.exception); + } + break; + + case EVENT_GET_ALL_SMS_DONE: + case EVENT_MARK_SMS_READ_DONE: + case EVENT_SMS_ON_RUIM: + case EVENT_GET_SMS_DONE: + Log.w(LOG_TAG, "Event not supported: " + msg.what); + break; + + // TODO: probably EF_CST should be read instead + case EVENT_GET_SST_DONE: + Log.d(LOG_TAG, "Event EVENT_GET_SST_DONE Received"); + break; + + case EVENT_RUIM_REFRESH: + isRecordLoadResponse = false; + ar = (AsyncResult)msg.obj; + if (ar.exception == null) { + handleRuimRefresh((int[])(ar.result)); + } + break; + + }}catch (RuntimeException exc) { + // I don't want these exceptions to be fatal + Log.w(LOG_TAG, "Exception parsing RUIM record", exc); + } finally { + // Count up record load responses even if they are fails + if (isRecordLoadResponse) { + onRecordLoaded(); + } + } + } + + protected void onRecordLoaded() { + // One record loaded successfully or failed, In either case + // we need to update the recordsToLoad count + recordsToLoad -= 1; + + if (recordsToLoad == 0 && recordsRequested == true) { + onAllRecordsLoaded(); + } else if (recordsToLoad < 0) { + Log.e(LOG_TAG, "RuimRecords: recordsToLoad <0, programmer error suspected"); + recordsToLoad = 0; + } + } + + protected void onAllRecordsLoaded() { + Log.d(LOG_TAG, "RuimRecords: record load complete"); + + // Further records that can be inserted are Operator/OEM dependent + + recordsLoadedRegistrants.notifyRegistrants( + new AsyncResult(null, null, null)); + ((CDMAPhone) phone).mRuimCard.broadcastRuimStateChangedIntent( + RuimCard.INTENT_VALUE_ICC_LOADED, null); + } + + + //***** Private Methods + + private void onRuimReady() { + /* broadcast intent ICC_READY here so that we can make sure + READY is sent before IMSI ready + */ + + ((CDMAPhone) phone).mRuimCard.broadcastRuimStateChangedIntent( + RuimCard.INTENT_VALUE_ICC_READY, null); + + fetchRuimRecords(); + + phone.mCM.getCDMASubscription(obtainMessage(EVENT_GET_CDMA_SUBSCRIPTION_DONE)); + + } + + private void fetchRuimRecords() { + recordsRequested = true; + + Log.v(LOG_TAG, "RuimRecords:fetchRuimRecords " + recordsToLoad); + + phone.getIccFileHandler().loadEFTransparent(EF_ICCID, + obtainMessage(EVENT_GET_ICCID_DONE)); + recordsToLoad++; + + // Further records that can be inserted are Operator/OEM dependent + } + + @Override + protected int getDisplayRule(String plmn) { + // TODO together with spn + return 0; + } + + @Override + public void setVoiceMessageWaiting(int line, int countWaiting) { + Log.i(LOG_TAG, "RuimRecords: setVoiceMessageWaiting not supported."); + } + + private void handleRuimRefresh(int[] result) { + if (result == null || result.length == 0) { + if (DBG) log("handleRuimRefresh without input"); + return; + } + + switch ((result[0])) { + case CommandsInterface.SIM_REFRESH_FILE_UPDATED: + if (DBG) log("handleRuimRefresh with SIM_REFRESH_FILE_UPDATED"); + adnCache.reset(); + fetchRuimRecords(); + break; + case CommandsInterface.SIM_REFRESH_INIT: + if (DBG) log("handleRuimRefresh with SIM_REFRESH_INIT"); + // need to reload all files (that we care about) + fetchRuimRecords(); + break; + case CommandsInterface.SIM_REFRESH_RESET: + if (DBG) log("handleRuimRefresh with SIM_REFRESH_RESET"); + phone.mCM.setRadioPower(false, null); + /* Note: no need to call setRadioPower(true). Assuming the desired + * radio power state is still ON (as tracked by ServiceStateTracker), + * ServiceStateTracker will call setRadioPower when it receives the + * RADIO_STATE_CHANGED notification for the power off. And if the + * desired power state has changed in the interim, we don't want to + * override it with an unconditional power on. + */ + break; + default: + // unknown refresh operation + if (DBG) log("handleRuimRefresh with unknown operation"); + break; + } + } + + protected void log(String s) { + Log.d(LOG_TAG, "[RuimRecords] " + s); + } + +} + diff --git a/telephony/java/com/android/internal/telephony/cdma/RuimSmsInterfaceManager.java b/telephony/java/com/android/internal/telephony/cdma/RuimSmsInterfaceManager.java new file mode 100644 index 0000000..9439359 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/RuimSmsInterfaceManager.java @@ -0,0 +1,192 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +package com.android.internal.telephony.cdma; + +import android.content.Context; +import android.os.AsyncResult; +import android.os.Handler; +import android.os.Message; +import android.util.Log; + +import com.android.internal.telephony.IccConstants; +import com.android.internal.telephony.IccSmsInterfaceManager; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.PhoneProxy; +import com.android.internal.telephony.SmsRawData; + +import java.util.ArrayList; +import java.util.List; + +import static android.telephony.SmsManager.STATUS_ON_ICC_FREE; + +/** + * RuimSmsInterfaceManager to provide an inter-process communication to + * access Sms in Ruim. + */ +public class RuimSmsInterfaceManager extends IccSmsInterfaceManager { + static final String LOG_TAG = "CDMA"; + static final boolean DBG = true; + + private final Object mLock = new Object(); + private boolean mSuccess; + private List<SmsRawData> mSms; + + private static final int EVENT_LOAD_DONE = 1; + private static final int EVENT_UPDATE_DONE = 2; + + Handler mHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + AsyncResult ar; + + switch (msg.what) { + case EVENT_UPDATE_DONE: + ar = (AsyncResult) msg.obj; + synchronized (mLock) { + mSuccess = (ar.exception == null); + mLock.notifyAll(); + } + break; + case EVENT_LOAD_DONE: + ar = (AsyncResult)msg.obj; + synchronized (mLock) { + if (ar.exception == null) { + mSms = (List<SmsRawData>) + buildValidRawData((ArrayList<byte[]>) ar.result); + } else { + if(DBG) log("Cannot load Sms records"); + if (mSms != null) + mSms.clear(); + } + mLock.notifyAll(); + } + break; + } + } + }; + + public RuimSmsInterfaceManager(CDMAPhone phone) { + super(phone); + mDispatcher = new CdmaSMSDispatcher(phone); + } + + public void dispose() { + } + + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "RuimSmsInterfaceManager finalized"); + } + + /** + * Update the specified message on the RUIM. + * + * @param index record index of message to update + * @param status new message status (STATUS_ON_ICC_READ, + * STATUS_ON_ICC_UNREAD, STATUS_ON_ICC_SENT, + * STATUS_ON_ICC_UNSENT, STATUS_ON_ICC_FREE) + * @param pdu the raw PDU to store + * @return success or not + * + */ + public boolean + updateMessageOnIccEf(int index, int status, byte[] pdu) { + if (DBG) log("updateMessageOnIccEf: index=" + index + + " status=" + status + " ==> " + + "("+ pdu + ")"); + enforceReceiveAndSend("Updating message on RUIM"); + synchronized(mLock) { + mSuccess = false; + Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE); + + if (status == STATUS_ON_ICC_FREE) { + // Special case FREE: call deleteSmsOnRuim instead of + // manipulating the RUIM record + mPhone.mCM.deleteSmsOnRuim(index, response); + } else { + byte[] record = makeSmsRecordData(status, pdu); + mPhone.getIccFileHandler().updateEFLinearFixed( + IccConstants.EF_SMS, index, record, null, response); + } + try { + mLock.wait(); + } catch (InterruptedException e) { + log("interrupted while trying to update by index"); + } + } + return mSuccess; + } + + /** + * Copy a raw SMS PDU to the RUIM. + * + * @param pdu the raw PDU to store + * @param status message status (STATUS_ON_ICC_READ, STATUS_ON_ICC_UNREAD, + * STATUS_ON_ICC_SENT, STATUS_ON_ICC_UNSENT) + * @return success or not + * + */ + public boolean copyMessageToIccEf(int status, byte[] pdu, byte[] smsc) { + //NOTE smsc not used in RUIM + if (DBG) log("copyMessageToIccEf: status=" + status + " ==> " + + "pdu=("+ pdu + ")"); + enforceReceiveAndSend("Copying message to RUIM"); + synchronized(mLock) { + mSuccess = false; + Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE); + + mPhone.mCM.writeSmsToRuim(status, IccUtils.bytesToHexString(pdu), + response); + + try { + mLock.wait(); + } catch (InterruptedException e) { + log("interrupted while trying to update by index"); + } + } + return mSuccess; + } + + /** + * Retrieves all messages currently stored on RUIM. + */ + public List<SmsRawData> getAllMessagesFromIccEf() { + if (DBG) log("getAllMessagesFromEF"); + + Context context = mPhone.getContext(); + + context.enforceCallingPermission( + "android.permission.RECEIVE_SMS", + "Reading messages from RUIM"); + synchronized(mLock) { + Message response = mHandler.obtainMessage(EVENT_LOAD_DONE); + mPhone.getIccFileHandler().loadEFLinearFixedAll(IccConstants.EF_SMS, response); + + try { + mLock.wait(); + } catch (InterruptedException e) { + log("interrupted while trying to load from the RUIM"); + } + } + return mSms; + } + + protected void log(String msg) { + Log.d(LOG_TAG, "[RuimSmsInterfaceManager] " + msg); + } +} + diff --git a/telephony/java/com/android/internal/telephony/cdma/SmsMessage.java b/telephony/java/com/android/internal/telephony/cdma/SmsMessage.java new file mode 100644 index 0000000..e4b474a --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/SmsMessage.java @@ -0,0 +1,905 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +import android.os.Parcel; +import android.text.format.Time; +import android.util.Config; +import android.util.Log; +import com.android.internal.telephony.EncodeException; +import com.android.internal.telephony.GsmAlphabet; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.SmsHeader; +import com.android.internal.telephony.SmsMessageBase; +import com.android.internal.telephony.cdma.sms.BearerData; +import com.android.internal.telephony.cdma.sms.CdmaSmsAddress; +import com.android.internal.telephony.cdma.sms.SmsDataCoding; +import com.android.internal.telephony.cdma.sms.SmsEnvelope; +import com.android.internal.telephony.cdma.sms.UserData; + +import java.io.BufferedInputStream; +import java.io.BufferedOutputStream; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.util.Random; + +import static android.telephony.SmsMessage.ENCODING_7BIT; +import static android.telephony.SmsMessage.ENCODING_8BIT; +import static android.telephony.SmsMessage.ENCODING_16BIT; +import static android.telephony.SmsMessage.ENCODING_UNKNOWN; +import static android.telephony.SmsMessage.MAX_USER_DATA_BYTES; +import static android.telephony.SmsMessage.MAX_USER_DATA_BYTES_WITH_HEADER; +import static android.telephony.SmsMessage.MAX_USER_DATA_SEPTETS; +import static android.telephony.SmsMessage.MAX_USER_DATA_SEPTETS_WITH_HEADER; +import static android.telephony.SmsMessage.MessageClass; +import static com.android.internal.telephony.cdma.sms.BearerData.ERROR_NONE; +import static com.android.internal.telephony.cdma.sms.BearerData.ERROR_TEMPORARY; +import static com.android.internal.telephony.cdma.sms.BearerData.ERROR_PERMANENT; +import static com.android.internal.telephony.cdma.sms.BearerData.MESSAGE_TYPE_DELIVER; +import static com.android.internal.telephony.cdma.sms.BearerData.MESSAGE_TYPE_SUBMIT; +import static com.android.internal.telephony.cdma.sms.BearerData.MESSAGE_TYPE_CANCELLATION; +import static com.android.internal.telephony.cdma.sms.BearerData.MESSAGE_TYPE_DELIVERY_ACK; +import static com.android.internal.telephony.cdma.sms.BearerData.MESSAGE_TYPE_USER_ACK; +import static com.android.internal.telephony.cdma.sms.BearerData.MESSAGE_TYPE_READ_ACK; +import static com.android.internal.telephony.cdma.sms.CdmaSmsAddress.SMS_ADDRESS_MAX; +import static com.android.internal.telephony.cdma.sms.CdmaSmsAddress.SMS_SUBADDRESS_MAX; +import static com.android.internal.telephony.cdma.sms.SmsEnvelope.SMS_BEARER_DATA_MAX; +import static com.android.internal.telephony.cdma.sms.UserData.UD_ENCODING_7BIT_ASCII; +import static com.android.internal.telephony.cdma.sms.UserData.UD_ENCODING_GSM_7BIT_ALPHABET; +import static com.android.internal.telephony.cdma.sms.UserData.UD_ENCODING_IA5; +import static com.android.internal.telephony.cdma.sms.UserData.UD_ENCODING_OCTET; +import static com.android.internal.telephony.cdma.sms.UserData.UD_ENCODING_UNICODE_16; + +/** + * A Short Message Service message. + * + */ +public class SmsMessage extends SmsMessageBase { + static final String LOG_TAG = "CDMA"; + + /** + * Status of a previously submitted SMS. + * This field applies to SMS Delivery Acknowledge messages. 0 indicates success; + * Here, the error class is defined by the bits from 9-8, the status code by the bits from 7-0. + * See C.S0015-B, v2.0, 4.5.21 for a detailed description of possible values. + */ + private int status; + + /** The next message ID for the BearerData. Shall be a random value on first use. + * (See C.S0015-B, v2.0, 4.3.1.5) + */ + private static int nextMessageId = 0; + + /** Specifies if this is the first SMS message submit */ + private static boolean firstSMS = true; + + /** Specifies if a return of an acknowledgment is requested for send SMS */ + private static final int RETURN_NO_ACK = 0; + private static final int RETURN_ACK = 1; + + private SmsEnvelope mEnvelope; + private BearerData mBearerData; + + public static class SubmitPdu extends SubmitPduBase { + } + + /** + * Create an SmsMessage from a raw PDU. + * Note: In CDMA the PDU is just a byte representation of the received Sms. + */ + public static SmsMessage createFromPdu(byte[] pdu) { + SmsMessage msg = new SmsMessage(); + + try { + msg.parsePdu(pdu); + return msg; + } catch (RuntimeException ex) { + Log.e(LOG_TAG, "SMS PDU parsing failed: ", ex); + return null; + } + } + + /** + * Note: This function is a GSM specific functionality which is not supported in CDMA mode. + */ + public static SmsMessage newFromCMT(String[] lines) { + Log.w(LOG_TAG, "newFromCMT: is not supported in CDMA mode."); + return null; + } + + /** + * Note: This function is a GSM specific functionality which is not supported in CDMA mode. + */ + public static SmsMessage newFromCMTI(String line) { + Log.w(LOG_TAG, "newFromCMTI: is not supported in CDMA mode."); + return null; + } + + /** + * Note: This function is a GSM specific functionality which is not supported in CDMA mode. + */ + public static SmsMessage newFromCDS(String line) { + Log.w(LOG_TAG, "newFromCDS: is not supported in CDMA mode."); + return null; + } + + /** + * Create a "raw" CDMA SmsMessage from a Parcel that was forged in ril.cpp. + * Note: Only primitive fields are set. + */ + public static SmsMessage newFromParcel(Parcel p) { + // Note: Parcel.readByte actually reads one Int and masks to byte + SmsMessage msg = new SmsMessage(); + SmsEnvelope env = new SmsEnvelope(); + CdmaSmsAddress addr = new CdmaSmsAddress(); + byte[] data; + byte count; + int countInt; + + //currently not supported by the modem-lib: env.mMessageType + env.teleService = p.readInt(); //p_cur->uTeleserviceID + + if (0 != p.readByte()) { //p_cur->bIsServicePresent + env.messageType = SmsEnvelope.MESSAGE_TYPE_BROADCAST; + } + else { + if (SmsEnvelope.TELESERVICE_NOT_SET == env.teleService) { + // assume type ACK + env.messageType = SmsEnvelope.MESSAGE_TYPE_ACKNOWLEDGE; + } else { + env.messageType = SmsEnvelope.MESSAGE_TYPE_POINT_TO_POINT; + } + } + env.serviceCategory = p.readInt(); //p_cur->uServicecategory + + // address + addr.digitMode = (byte) (0xFF & p.readInt()); //p_cur->sAddress.digit_mode + addr.numberMode = (byte) (0xFF & p.readInt()); //p_cur->sAddress.number_mode + addr.ton = p.readInt(); //p_cur->sAddress.number_type + addr.numberPlan = (byte) (0xFF & p.readInt()); //p_cur->sAddress.number_plan + count = p.readByte(); //p_cur->sAddress.number_of_digits + addr.numberOfDigits = count; + data = new byte[count]; + //p_cur->sAddress.digits[digitCount] + for (int index=0; index < count; index++) { + data[index] = p.readByte(); + } + addr.origBytes = data; + + // ignore subaddress + p.readInt(); //p_cur->sSubAddress.subaddressType + p.readByte(); //p_cur->sSubAddress.odd + count = p.readByte(); //p_cur->sSubAddress.number_of_digits + //p_cur->sSubAddress.digits[digitCount] : + for (int index=0; index < count; index++) { + p.readByte(); + } + + /* currently not supported by the modem-lib: + env.bearerReply + env.replySeqNo + env.errorClass + env.causeCode + */ + + // bearer data + countInt = p.readInt(); //p_cur->uBearerDataLen + if (countInt >0) { + data = new byte[countInt]; + //p_cur->aBearerData[digitCount] : + for (int index=0; index < countInt; index++) { + data[index] = p.readByte(); + } + env.bearerData = data; + // BD gets further decoded when accessed in SMSDispatcher + } + + // link the the filled objects to the SMS + env.origAddress = addr; + msg.originatingAddress = addr; + msg.mEnvelope = env; + + // create byte stream representation for transportation through the layers. + msg.createPdu(); + + return msg; + } + + /** + * Create an SmsMessage from an SMS EF record. + * + * @param index Index of SMS record. This should be index in ArrayList + * returned by RuimSmsInterfaceManager.getAllMessagesFromIcc + 1. + * @param data Record data. + * @return An SmsMessage representing the record. + * + * @hide + */ + public static SmsMessage createFromEfRecord(int index, byte[] data) { + try { + SmsMessage msg = new SmsMessage(); + + msg.indexOnIcc = index; + + // First byte is status: RECEIVED_READ, RECEIVED_UNREAD, STORED_SENT, + // or STORED_UNSENT + // See 3GPP2 C.S0023 3.4.27 + if ((data[0] & 1) == 0) { + Log.w(LOG_TAG, "SMS parsing failed: Trying to parse a free record"); + return null; + } else { + msg.statusOnIcc = data[0] & 0x07; + } + + // Second byte is the MSG_LEN, length of the message + // See 3GPP2 C.S0023 3.4.27 + int size = data[1]; + + // Note: Data may include trailing FF's. That's OK; message + // should still parse correctly. + byte[] pdu = new byte[size]; + System.arraycopy(data, 2, pdu, 0, size); + // the message has to be parsed before it can be displayed + // see gsm.SmsMessage + return msg; + } catch (RuntimeException ex) { + Log.e(LOG_TAG, "SMS PDU parsing failed: ", ex); + return null; + } + + } + + /** + * Note: This function is a GSM specific functionality which is not supported in CDMA mode. + */ + public static int getTPLayerLengthForPDU(String pdu) { + Log.w(LOG_TAG, "getTPLayerLengthForPDU: is not supported in CDMA mode."); + return 0; + } + + /** + * Get an SMS-SUBMIT PDU for a destination address and a message + * + * @param scAddress Service Centre address. Null means use default. + * @param destinationAddress Address of the recipient. + * @param message String representation of the message payload. + * @param statusReportRequested Indicates whether a report is requested for this message. + * @param headerData Array containing the data for the User Data Header, preceded + * by the Element Identifiers. + * @return a <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message. + * Returns null on encode error. + * @hide + */ + public static SubmitPdu getSubmitPdu(String scAddress, + String destinationAddress, String message, + boolean statusReportRequested, byte[] headerData) { + + SmsMessage sms = new SmsMessage(); + SubmitPdu ret = new SubmitPdu(); + UserData uData = new UserData(); + SmsHeader smsHeader; + + // Perform null parameter checks. + if (message == null || destinationAddress == null) { + return null; + } + + // ** Set UserData + SmsHeader ** + try { + // First, try encoding it with the GSM alphabet + int septetCount = GsmAlphabet.countGsmSeptets(message, true); + // User Data (and length) + + uData.userData = message.getBytes(); + + if (uData.userData.length > MAX_USER_DATA_SEPTETS) { + // Message too long + return null; + } + + // desired TP-Data-Coding-Scheme + uData.userDataEncoding = UserData.UD_ENCODING_GSM_7BIT_ALPHABET; + + // paddingBits not needed for UD_ENCODING_GSM_7BIT_ALPHABET + + // sms header + if(headerData != null) { + smsHeader = SmsHeader.parse(headerData); + uData.userDataHeader = smsHeader; + } else { + // no user data header available! + } + + } catch (EncodeException ex) { + byte[] textPart; + // Encoding to the 7-bit alphabet failed. Let's see if we can + // send it as a UCS-2 encoded message + + try { + textPart = message.getBytes("utf-16be"); + } catch (UnsupportedEncodingException uex) { + Log.e(LOG_TAG, "Implausible UnsupportedEncodingException ", uex); + return null; + } + + uData.userData = textPart; + + if (uData.userData.length > MAX_USER_DATA_BYTES) { + // Message too long + return null; + } + + // TP-Data-Coding-Scheme + uData.userDataEncoding = UserData.UD_ENCODING_UNICODE_16; + + // sms header + if(headerData != null) { + smsHeader = SmsHeader.parse(headerData); + uData.userDataHeader = smsHeader; + } else { + // no user data header available! + } + } + + byte[] data = sms.getEnvelope(destinationAddress, statusReportRequested, uData, + (headerData != null), (null == headerData)); + + if (null == data) return null; + + ret.encodedMessage = data; + ret.encodedScAddress = null; + return ret; + } + + + /** + * Get an SMS-SUBMIT PDU for a destination address and a message + * + * @param scAddress Service Centre address. Null means use default. + * @return a <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message. + * Returns null on encode error. + */ + public static SubmitPdu getSubmitPdu(String scAddress, + String destinationAddress, String message, + boolean statusReportRequested) { + return getSubmitPdu(scAddress, destinationAddress, message, statusReportRequested, null); + } + + /** + * Get an SMS-SUBMIT PDU for a data message to a destination address & port + * + * @param scAddress Service Centre address. null == use default + * @param destinationAddress the address of the destination for the message + * @param destinationPort the port to deliver the message to at the + * destination + * @param data the data for the message + * @return a <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message. + * Returns null on encode error. + */ + public static SubmitPdu getSubmitPdu(String scAddress, + String destinationAddress, short destinationPort, byte[] data, + boolean statusReportRequested) { + + SmsMessage sms = new SmsMessage(); + SubmitPdu ret = new SubmitPdu(); + UserData uData = new UserData(); + SmsHeader smsHeader = new SmsHeader(); + + if (data.length > (MAX_USER_DATA_BYTES - 7 /* UDH size */)) { + Log.e(LOG_TAG, "SMS data message may only contain " + + (MAX_USER_DATA_BYTES - 7) + " bytes"); + return null; + } + + byte[] destPort = new byte[4]; + destPort[0] = (byte) ((destinationPort >> 8) & 0xFF); // MSB of destination port + destPort[1] = (byte) (destinationPort & 0xFF); // LSB of destination port + destPort[2] = 0x00; // MSB of originating port + destPort[3] = 0x00; // LSB of originating port + smsHeader.add( + new SmsHeader.Element(SmsHeader.APPLICATION_PORT_ADDRESSING_16_BIT, destPort)); + + smsHeader.nbrOfHeaders = smsHeader.getElements().size(); + uData.userDataHeader = smsHeader; + + // TP-Data-Coding-Scheme + // No class, 8 bit data + uData.userDataEncoding = UserData.UD_ENCODING_OCTET; + uData.userData = data; + + byte[] msgData = sms.getEnvelope(destinationAddress, statusReportRequested, uData, + true, true); + + ret.encodedMessage = msgData; + ret.encodedScAddress = null; + return ret; + } + + static class PduParser { + + PduParser() { + } + + /** + * Parses an SC timestamp and returns a currentTimeMillis()-style + * timestamp + */ + static long getSCTimestampMillis(byte[] timestamp) { + // TP-Service-Centre-Time-Stamp + int year = IccUtils.beBcdByteToInt(timestamp[0]); + int month = IccUtils.beBcdByteToInt(timestamp[1]); + int day = IccUtils.beBcdByteToInt(timestamp[2]); + int hour = IccUtils.beBcdByteToInt(timestamp[3]); + int minute = IccUtils.beBcdByteToInt(timestamp[4]); + int second = IccUtils.beBcdByteToInt(timestamp[5]); + + Time time = new Time(Time.TIMEZONE_UTC); + + // C.S0015-B v2.0, 4.5.4: range is 1996-2095 + time.year = year >= 96 ? year + 1900 : year + 2000; + time.month = month - 1; + time.monthDay = day; + time.hour = hour; + time.minute = minute; + time.second = second; + + return time.toMillis(true); + } + + } + + /** + * Note: This function is a GSM specific functionality which is not supported in CDMA mode. + */ + public int getProtocolIdentifier() { + Log.w(LOG_TAG, "getProtocolIdentifier: is not supported in CDMA mode."); + // (3GPP TS 23.040): "no interworking, but SME to SME protocol": + return 0; + } + + /** + * Note: This function is a GSM specific functionality which is not supported in CDMA mode. + */ + public boolean isReplace() { + Log.w(LOG_TAG, "isReplace: is not supported in CDMA mode."); + return false; + } + + /** + * {@inheritDoc} + * Note: This function is a GSM specific functionality which is not supported in CDMA mode. + */ + public boolean isCphsMwiMessage() { + Log.w(LOG_TAG, "isCphsMwiMessage: is not supported in CDMA mode."); + return false; + } + + /** + * {@inheritDoc} + */ + public boolean isMWIClearMessage() { + if ((mBearerData != null) && (0 == mBearerData.numberOfMessages)) { + return true; + } + return false; + } + + /** + * {@inheritDoc} + */ + public boolean isMWISetMessage() { + if ((mBearerData != null) && (mBearerData.numberOfMessages >0)) { + return true; + } + return false; + } + + /** + * {@inheritDoc} + */ + public boolean isMwiDontStore() { + if ((mBearerData != null) && (mBearerData.numberOfMessages >0) + && (null == mBearerData.userData)) { + return true; + } + return false; + } + + /** + * Returns the status for a previously submitted message. + * For not interfering with status codes from GSM, this status code is + * shifted to the bits 31-16. + */ + public int getStatus() { + return(status<<16); + } + + /** + * Note: This function is a GSM specific functionality which is not supported in CDMA mode. + */ + public boolean isStatusReportMessage() { + Log.w(LOG_TAG, "isStatusReportMessage: is not supported in CDMA mode."); + return false; + } + + /** + * Note: This function is a GSM specific functionality which is not supported in CDMA mode. + */ + public boolean isReplyPathPresent() { + Log.w(LOG_TAG, "isReplyPathPresent: is not supported in CDMA mode."); + return false; + } + + /** + * Returns the teleservice type of the message. + * @return the teleservice: + * {@link com.android.internal.telephony.cdma.sms.SmsEnvelope#TELESERVICE_NOT_SET}, + * {@link com.android.internal.telephony.cdma.sms.SmsEnvelope#TELESERVICE_WMT}, + * {@link com.android.internal.telephony.cdma.sms.SmsEnvelope#TELESERVICE_WEMT}, + * {@link com.android.internal.telephony.cdma.sms.SmsEnvelope#TELESERVICE_VMN}, + * {@link com.android.internal.telephony.cdma.sms.SmsEnvelope#TELESERVICE_WAP} + */ + public int getTeleService() { + return mEnvelope.teleService; + } + + /** + * Decodes pdu to an empty SMS object. + * In the CDMA case the pdu is just an internal byte stream representation + * of the SMS Java-object. + * @see #createPdu() + */ + private void parsePdu(byte[] pdu) { + ByteArrayInputStream bais = new ByteArrayInputStream(pdu); + DataInputStream dis = new DataInputStream(new BufferedInputStream(bais)); + byte length; + SmsEnvelope env = new SmsEnvelope(); + CdmaSmsAddress addr = new CdmaSmsAddress(); + + try { + env.messageType = dis.readInt(); + env.teleService = dis.readInt(); + env.serviceCategory = dis.readInt(); + + addr.digitMode = dis.readByte(); + addr.numberMode = dis.readByte(); + addr.ton = dis.readByte(); + addr.numberPlan = dis.readByte(); + + length = dis.readByte(); + addr.numberOfDigits = length; + addr.origBytes = new byte[length]; + dis.read(addr.origBytes, 0, length); // digits + + env.bearerReply = dis.readInt(); + // CauseCode values: + env.replySeqNo = dis.readByte(); + env.errorClass = dis.readByte(); + env.causeCode = dis.readByte(); + + //encoded BearerData: + length = dis.readByte(); + env.bearerData = new byte[length]; + dis.read(env.bearerData, 0, length); + dis.close(); + } catch (Exception ex) { + Log.e(LOG_TAG, "createFromPdu: conversion from byte array to object failed: " + ex); + } + + // link the filled objects to this SMS + originatingAddress = addr; + env.origAddress = addr; + mEnvelope = env; + + parseSms(); + } + + /** + * Parses a SMS message from its BearerData stream. (mobile-terminated only) + */ + protected void parseSms() { + mBearerData = SmsDataCoding.decodeCdmaSms(mEnvelope.bearerData); + messageRef = mBearerData.messageID; + + // TP-Message-Type-Indicator + // (See 3GPP2 C.S0015-B, v2, 4.5.1) + int messageType = mBearerData.messageType; + + switch (messageType) { + case MESSAGE_TYPE_USER_ACK: + case MESSAGE_TYPE_READ_ACK: + case MESSAGE_TYPE_DELIVER: + // Deliver (mobile-terminated only) + parseSmsDeliver(); + break; + case MESSAGE_TYPE_DELIVERY_ACK: + parseSmsDeliveryAck(); + break; + + default: + // the rest of these + throw new RuntimeException("Unsupported message type: " + messageType); + } + } + + /** + * Parses a SMS-DELIVER message. (mobile-terminated only) + * See 3GPP2 C.S0015-B, v2, 4.4.1 + */ + private void parseSmsDeliver() { + if (originatingAddress != null) { + originatingAddress.address = new String(originatingAddress.origBytes); + if (Config.LOGV) Log.v(LOG_TAG, "SMS originating address: " + + originatingAddress.address); + } + + if (mBearerData.timeStamp != null) { + scTimeMillis = PduParser.getSCTimestampMillis(mBearerData.timeStamp); + } + + if (Config.LOGD) Log.d(LOG_TAG, "SMS SC timestamp: " + scTimeMillis); + + parseUserData(mBearerData.userData); + } + + /** + * Parses a SMS-DELIVER message. (mobile-terminated only) + * See 3GPP2 C.S0015-B, v2, 4.4.1 + */ + private void parseSmsDeliveryAck() { + if (originatingAddress != null) { + originatingAddress.address = new String(originatingAddress.origBytes); + if (Config.LOGV) Log.v(LOG_TAG, "SMS originating address: " + + originatingAddress.address); + } + + if (mBearerData.timeStamp != null) { + scTimeMillis = PduParser.getSCTimestampMillis(mBearerData.timeStamp); + } + + if (Config.LOGD) Log.d(LOG_TAG, "SMS SC timestamp: " + scTimeMillis); + + if (mBearerData.errorClass != BearerData.ERROR_UNDEFINED) { + status = mBearerData.errorClass << 8; + status |= mBearerData.messageStatus; + } + + parseUserData(mBearerData.userData); + + } + + /** + * Parses the User Data of an SMS. + */ + private void parseUserData(UserData uData) { + int encodingType; + + if (null == uData) { + return; + } + + encodingType = uData.userDataEncoding; + + // insert DCS-decoding here when type is supported by ril-library + + userData = uData.userData; + userDataHeader = uData.userDataHeader; + + switch (encodingType) { + case UD_ENCODING_GSM_7BIT_ALPHABET: + case UD_ENCODING_UNICODE_16: + // user data was already decoded by wmsts-library + messageBody = new String(userData); + break; + + // data and unsupported encodings: + case UD_ENCODING_OCTET: + default: + messageBody = null; + break; + } + + if (Config.LOGV) Log.v(LOG_TAG, "SMS message body (raw): '" + messageBody + "'"); + + if (messageBody != null) { + parseMessageBody(); + } + } + + /** + * {@inheritDoc} + */ + public MessageClass getMessageClass() { + if (BearerData.DISPLAY_IMMEDIATE == mBearerData.displayMode ) { + return MessageClass.CLASS_0; + } else { + return MessageClass.UNKNOWN; + } + } + + /** + * Creates BearerData and Envelope from parameters for a Submit SMS. + * @return byte stream for SubmitPdu. + */ + private byte[] getEnvelope(String destinationAddress, boolean statusReportRequested, + UserData userData, boolean hasHeaders, boolean useNewId) { + + BearerData mBearerData = new BearerData(); + SmsEnvelope env = new SmsEnvelope(); + CdmaSmsAddress mSmsAddress = new CdmaSmsAddress(); + + // ** set SmsAddress ** + mSmsAddress.digitMode = CdmaSmsAddress.DIGIT_MODE_8BIT_CHAR; + try { + mSmsAddress.origBytes = destinationAddress.getBytes("UTF-8"); + } catch (Exception e) { + Log.e(LOG_TAG, "doGetSubmitPdu: conversion of destinationAddress from string to byte[]" + + " failed: " + e.getMessage()); + return null; + } + mSmsAddress.numberOfDigits = (byte)mSmsAddress.origBytes.length; + mSmsAddress.numberMode = CdmaSmsAddress.NUMBER_MODE_NOT_DATA_NETWORK; + // see C.S0015-B, v2.0, 3.4.3.3 + mSmsAddress.numberPlan = CdmaSmsAddress.NUMBERING_PLAN_ISDN_TELEPHONY; + mSmsAddress.ton = CdmaSmsAddress.TON_INTERNATIONAL_OR_IP; + + // ** set BearerData ** + mBearerData.userData = userData; + mBearerData.messageType = BearerData.MESSAGE_TYPE_SUBMIT; + + if (useNewId) { + setNextMessageId(); + } + mBearerData.messageID = nextMessageId; + + // Set the reply options (See C.S0015-B, v2.0, 4.5.11) + if(statusReportRequested) { + mBearerData.deliveryAckReq = true; + } else { + mBearerData.deliveryAckReq = false; + } + // Currently settings applications do not support this + mBearerData.userAckReq = false; + mBearerData.readAckReq = false; + mBearerData.reportReq = false; + + // Set the display mode (See C.S0015-B, v2.0, 4.5.16) + mBearerData.displayMode = BearerData.DISPLAY_DEFAULT; + + // number of messages: not needed for encoding! + + // indicate whether a user data header is available + mBearerData.hasUserDataHeader = hasHeaders; + + // ** encode BearerData ** + byte[] encodedBearerData = null; + try { + encodedBearerData = SmsDataCoding.encodeCdmaSms(mBearerData); + } catch (Exception e) { + Log.e(LOG_TAG, "doGetSubmitPdu: EncodeCdmaSMS function in JNI interface failed: " + + e.getMessage()); + return null; + } + + // ** SmsEnvelope ** + env.messageType = SmsEnvelope.MESSAGE_TYPE_POINT_TO_POINT; + env.teleService = SmsEnvelope.TELESERVICE_WEMT; + env.destAddress = mSmsAddress; + env.bearerReply = RETURN_ACK; + env.bearerData = encodedBearerData; + mEnvelope = env; + + // get byte array output stream from SmsAddress object and SmsEnvelope member. + return serialize(mSmsAddress); + } + + /** + * Set the nextMessageId to a random value between 0 and 65536 + * See C.S0015-B, v2.0, 4.3.1.5 + */ + private void setNextMessageId() { + // Message ID, modulo 65536 + if(firstSMS) { + Random generator = new Random(); + nextMessageId = generator.nextInt(65536); + firstSMS = false; + } else { + nextMessageId = ++nextMessageId & 0xFFFF; + } + } + + /** + * Creates ByteArrayOutputStream from CdmaSmsAddress and SmsEnvelope objects + * + * @param address CdmaSmsAddress object + * @return ByteArrayOutputStream + */ + private byte[] serialize(CdmaSmsAddress destAddress) { + SmsEnvelope env = mEnvelope; + ByteArrayOutputStream baos = new ByteArrayOutputStream(100); + DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(baos)); + + try { + dos.writeInt(env.teleService); + dos.writeInt(0); //servicePresent + dos.writeInt(0); //serviceCategory + dos.write(destAddress.digitMode); + dos.write(destAddress.numberMode); + dos.write(destAddress.ton); // number_type + dos.write(destAddress.numberPlan); + dos.write(destAddress.numberOfDigits); + dos.write(destAddress.origBytes, 0, destAddress.origBytes.length); // digits + // Subaddress is not supported. + dos.write(0); //subaddressType + dos.write(0); //subaddr_odd + dos.write(0); //subaddr_nbr_of_digits + dos.write(env.bearerData.length); + dos.write(env.bearerData, 0, env.bearerData.length); + dos.close(); + return baos.toByteArray(); + } catch(IOException ex) { + Log.e(LOG_TAG, "serialize: conversion from object to data output stream failed: " + ex); + return null; + } + } + + /** + * Creates byte array (pseudo pdu) from SMS object. + * Note: Do not call this method more than once per object! + */ + private void createPdu() { + SmsEnvelope env = mEnvelope; + CdmaSmsAddress addr = env.origAddress; + ByteArrayOutputStream baos = new ByteArrayOutputStream(100); + DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(baos)); + + try { + dos.writeInt(env.messageType); + dos.writeInt(env.teleService); + dos.writeInt(env.serviceCategory); + + dos.writeByte(addr.digitMode); + dos.writeByte(addr.numberMode); + dos.writeByte(addr.ton); + dos.writeByte(addr.numberPlan); + dos.writeByte(addr.numberOfDigits); + dos.write(addr.origBytes, 0, addr.origBytes.length); // digits + + dos.writeInt(env.bearerReply); + // CauseCode values: + dos.writeByte(env.replySeqNo); + dos.writeByte(env.errorClass); + dos.writeByte(env.causeCode); + //encoded BearerData: + dos.writeByte(env.bearerData.length); + dos.write(env.bearerData, 0, env.bearerData.length); + dos.close(); + + mPdu = baos.toByteArray(); + } catch (IOException ex) { + Log.e(LOG_TAG, "createPdu: conversion from object to byte array failed: " + ex); + } + } + +} diff --git a/telephony/java/com/android/internal/telephony/cdma/TtyIntent.java b/telephony/java/com/android/internal/telephony/cdma/TtyIntent.java new file mode 100644 index 0000000..f27f79c --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/TtyIntent.java @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma; + +public class TtyIntent { + + private static final String TAG = "TtyIntent"; + + + /** Event for TTY mode change */ + + /** + * Broadcast intent action indicating that the TTY has either been + * enabled or disabled. An intent extra provides this state as a boolean, + * where {@code true} means enabled. + * @see #TTY_ENABLED + * + * {@hide} + */ + public static final String TTY_ENABLED_CHANGE_ACTION = + "com.android.internal.telephony.cdma.intent.action.TTY_ENABLED_CHANGE"; + + /** + * The lookup key for a boolean that indicates whether TTY mode is enabled or + * disabled. {@code true} means TTY mode is enabled. Retrieve it with + * {@link android.content.Intent#getBooleanExtra(String,boolean)}. + * + * {@hide} + */ + public static final String TTY_ENABLED = "ttyEnabled"; + +} diff --git a/telephony/java/com/android/internal/telephony/cdma/package.html b/telephony/java/com/android/internal/telephony/cdma/package.html new file mode 100644 index 0000000..cf1ad4a --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/package.html @@ -0,0 +1,6 @@ +<HTML> +<BODY> +Provides classes to control or read data from CDMA phones. +@hide +</BODY> +</HTML> diff --git a/telephony/java/com/android/internal/telephony/cdma/sms/BearerData.java b/telephony/java/com/android/internal/telephony/cdma/sms/BearerData.java new file mode 100644 index 0000000..fec9529 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/sms/BearerData.java @@ -0,0 +1,192 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma.sms; + +public final class BearerData{ + + // For completeness the following fields are listed, though not used yet. + /** + * Supported priority modes for CDMA SMS messages + * (See 3GPP2 C.S0015-B, v2.0, table 4.5.9-1) + */ + //public static final int PRIORITY_NORMAL = 0x0; + //public static final int PRIORITY_INTERACTIVE = 0x1; + //public static final int PRIORITY_URGENT = 0x2; + //public static final int PRIORITY_EMERGENCY = 0x3; + + /** + * Supported privacy modes for CDMA SMS messages + * (See 3GPP2 C.S0015-B, v2.0, table 4.5.10-1) + */ + //public static final int PRIVACY_NOT_RESTRICTED = 0x0; + //public static final int PRIVACY_RESTRICTED = 0x1; + //public static final int PRIVACY_CONFIDENTIAL = 0x2; + //public static final int PRIVACY_SECRET = 0x3; + + /** + * Supported alert modes for CDMA SMS messages + * (See 3GPP2 C.S0015-B, v2.0, table 4.5.13-1) + */ + //public static final int ALERT_DEFAULT = 0x0; + //public static final int ALERT_LOW_PRIO = 0x1; + //public static final int ALERT_MEDIUM_PRIO = 0x2; + //public static final int ALERT_HIGH_PRIO = 0x3; + + /** + * Supported display modes for CDMA SMS messages + * (See 3GPP2 C.S0015-B, v2.0, table 4.5.16-1) + */ + public static final int DISPLAY_IMMEDIATE = 0x0; + public static final int DISPLAY_DEFAULT = 0x1; + public static final int DISPLAY_USER = 0x2; + + /** + * Supported message types for CDMA SMS messages + * (See 3GPP2 C.S0015-B, v2.0, table 4.5.1-1) + */ + public static final int MESSAGE_TYPE_DELIVER = 0x01; + public static final int MESSAGE_TYPE_SUBMIT = 0x02; + public static final int MESSAGE_TYPE_CANCELLATION = 0x03; + public static final int MESSAGE_TYPE_DELIVERY_ACK = 0x04; + public static final int MESSAGE_TYPE_USER_ACK = 0x05; + public static final int MESSAGE_TYPE_READ_ACK = 0x06; + public static final int MESSAGE_TYPE_DELIVER_REPORT = 0x07; + public static final int MESSAGE_TYPE_SUBMIT_REPORT = 0x08; + + /** + * SMS Message Status Codes + * (See 3GPP2 C.S0015-B, v2.0, table 4.5.21-1) + */ + /* no-error codes */ + public static final int ERROR_NONE = 0x00; + public static final int STATUS_ACCEPTED = 0x00; + public static final int STATUS_DEPOSITED_TO_INTERNET = 0x01; + public static final int STATUS_DELIVERED = 0x02; + public static final int STATUS_CANCELLED = 0x03; + /* temporary-error and permanent-error codes */ + public static final int ERROR_TEMPORARY = 0x02; + public static final int STATUS_NETWORK_CONGESTION = 0x04; + public static final int STATUS_NETWORK_ERROR = 0x05; + public static final int STATUS_UNKNOWN_ERROR = 0x1F; + /* permanent-error codes */ + public static final int ERROR_PERMANENT = 0x03; + public static final int STATUS_CANCEL_FAILED = 0x06; + public static final int STATUS_BLOCKED_DESTINATION = 0x07; + public static final int STATUS_TEXT_TOO_LONG = 0x08; + public static final int STATUS_DUPLICATE_MESSAGE = 0x09; + public static final int STATUS_INVALID_DESTINATION = 0x0A; + public static final int STATUS_MESSAGE_EXPIRED = 0x0D; + /* undefined-status codes */ + public static final int ERROR_UNDEFINED = 0xFF; + public static final int STATUS_UNDEFINED = 0xFF; + + /** Bit-mask indicating used fields for SmsDataCoding */ + public int mask; + + /** + * 4-bit value indicating the message type in accordance to + * table 4.5.1-1 + * (See 3GPP2 C.S0015-B, v2, 4.5.1) + */ + public byte messageType; + + /** + * 16-bit value indicating the message ID, which increments modulo 65536. + * (Special rules apply for WAP-messages.) + * (See 3GPP2 C.S0015-B, v2, 4.5.1) + */ + public int messageID; + + /** + * 1-bit value that indicates whether a User Data Header is present. + * (See 3GPP2 C.S0015-B, v2, 4.5.1) + */ + public boolean hasUserDataHeader; + + /** + * provides the information for the user data + * (e.g. padding bits, user data, user data header, etc) + * (See 3GPP2 C.S.0015-B, v2, 4.5.2) + */ + public UserData userData; + + //public UserResponseCode userResponseCode; + + /** + * 6-byte-field, see 3GPP2 C.S0015-B, v2, 4.5.4 + * year, month, day, hours, minutes, seconds; + */ + public byte[] timeStamp; + + //public SmsTime validityPeriodAbsolute; + //public SmsRelTime validityPeriodRelative; + //public SmsTime deferredDeliveryTimeAbsolute; + //public SmsRelTime deferredDeliveryTimeRelative; + //public byte priority; + //public byte privacy; + + /** + * Reply Option + * 1-bit values which indicate whether SMS acknowledgment is requested or not. + * (See 3GPP2 C.S0015-B, v2, 4.5.11) + */ + public boolean userAckReq; + public boolean deliveryAckReq; + public boolean readAckReq; + public boolean reportReq; + + /** + * The number of Messages element (8-bit value) is a decimal number in the 0 to 99 range + * representing the number of messages stored at the Voice Mail System. This element is + * used by the Voice Mail Notification service. + * (See 3GPP2 C.S0015-B, v2, 4.5.12) + */ + public int numberOfMessages; + + //public int alert; + //public int language; + + /** + * 4-bit or 8-bit value that indicates the number to be dialed in reply to a + * received SMS message. + * (See 3GPP2 C.S0015-B, v2, 4.5.15) + */ + public CdmaSmsAddress callbackNumber; + + /** + * 2-bit value that is used to indicate to the mobile station when to display + * the received message. + * (See 3GPP2 C.S0015-B, v2, 4.5.16) + */ + public byte displayMode = DISPLAY_DEFAULT; + + /** + * First component of the Message status, that indicates if an error has occurred + * and whether the error is considered permanent or temporary. + * (See 3GPP2 C.S0015-B, v2, 4.5.21) + */ + public int errorClass = ERROR_UNDEFINED; + + /** + * Second component of the Message status, that indicates if an error has occurred + * and the cause of the error. + * (See 3GPP2 C.S0015-B, v2, 4.5.21) + */ + public int messageStatus = STATUS_UNDEFINED; + +} + diff --git a/telephony/java/com/android/internal/telephony/cdma/sms/CdmaSmsAddress.java b/telephony/java/com/android/internal/telephony/cdma/sms/CdmaSmsAddress.java new file mode 100644 index 0000000..1643cab --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/sms/CdmaSmsAddress.java @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma.sms; + +import com.android.internal.telephony.SmsAddress; + +public class CdmaSmsAddress extends SmsAddress { + /** + * digit mode indicators + * (See 3GPP2 C.S0015-B, v2, 3.4.3.3) + */ + static public final int DIGIT_MODE_4BIT_DTMF = 0x00; + static public final int DIGIT_MODE_8BIT_CHAR = 0x01; + + /** + * number mode indicators + * (See 3GPP2 C.S0015-B, v2, 3.4.3.3) + */ + static public final int NUMBER_MODE_NOT_DATA_NETWORK = 0x00; + static public final int NUMBER_MODE_DATA_NETWORK = 0x01; + + /** + * number types for data networks + * (See 3GPP2 C.S0015-B, v2, 3.4.3.3) + */ + static public final int TON_UNKNOWN = 0x00; + static public final int TON_INTERNATIONAL_OR_IP = 0x01; + static public final int TON_NATIONAL_OR_EMAIL = 0x02; + static public final int TON_NETWORK = 0x03; + static public final int TON_SUBSCRIBER = 0x04; + static public final int TON_ALPHANUMERIC = 0x05; + static public final int TON_ABBREVIATED = 0x06; + static public final int TON_RESERVED = 0x07; + + /** + * maximum lengths for fields as defined in ril_cdma_sms.h + */ + static public final int SMS_ADDRESS_MAX = 36; + static public final int SMS_SUBADDRESS_MAX = 36; + + /** + * Supported numbering plan identification + * (See C.S005-D, v1.0, table 2.7.1.3.2.4-3) + */ + static public final int NUMBERING_PLAN_UNKNOWN = 0x0; + static public final int NUMBERING_PLAN_ISDN_TELEPHONY = 0x1; + //static protected final int NUMBERING_PLAN_DATA = 0x3; + //static protected final int NUMBERING_PLAN_TELEX = 0x4; + //static protected final int NUMBERING_PLAN_PRIVATE = 0x9; + + /** + * 1-bit value that indicates whether the address digits are 4-bit DTMF codes + * or 8-bit codes. + * (See 3GPP2 C.S0015-B, v2, 3.4.3.3) + */ + public byte digitMode; + + /** + * 1-bit value that indicates whether the address type is a data network address or not. + * (See 3GPP2 C.S0015-B, v2, 3.4.3.3) + */ + public byte numberMode; + + // use parent class member ton instead public byte numberType; + + /** + * 0 or 4-bit value that indicates which numbering plan identification is set. + * (See 3GPP2, C.S0015-B, v2, 3.4.3.3 and C.S005-D, table2.7.1.3.2.4-3) + */ + public byte numberPlan; + + /** + * This field shall be set to the number of address digits + * (See 3GPP2 C.S0015-B, v2, 3.4.3.3) + */ + public byte numberOfDigits; + + // use parent class member orig_bytes instead of public byte[] digits; + + // Constructor + public CdmaSmsAddress(){ + } + +} diff --git a/telephony/java/com/android/internal/telephony/cdma/sms/SmsDataCoding.java b/telephony/java/com/android/internal/telephony/cdma/sms/SmsDataCoding.java new file mode 100644 index 0000000..6ba7463 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/sms/SmsDataCoding.java @@ -0,0 +1,371 @@ +/* + * Copyright (C) 2007 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma.sms; + +import com.android.internal.telephony.SmsHeader; + +/* + * The SMSDataCoding class encodes and decodes CDMA SMS messages. + */ +public class SmsDataCoding { + private final static String TAG = "CDMA_SMS_JNI"; + + private final static int CDMA_SMS_WMS_MASK_BD_NULL = 0x00000000; + private final static int CDMA_SMS_WMS_MASK_BD_MSG_ID = 0x00000001; + private final static int CDMA_SMS_WMS_MASK_BD_USER_DATA = 0x00000002; +// private final static int CDMA_SMS_WMS_MASK_BD_USER_RESP = 0x00000004; + private final static int CDMA_SMS_WMS_MASK_BD_MC_TIME = 0x00000008; +// private final static int CDMA_SMS_WMS_MASK_BD_VALID_ABS = 0x00000010; +// private final static int CDMA_SMS_WMS_MASK_BD_VALID_REL = 0x00000020; +// private final static int CDMA_SMS_WMS_MASK_BD_DEFER_ABS = 0x00000040; +// private final static int CDMA_SMS_WMS_MASK_BD_DEFER_REL = 0x00000080; +// private final static int CDMA_SMS_WMS_MASK_BD_PRIORITY = 0x00000100; +// private final static int CDMA_SMS_WMS_MASK_BD_PRIVACY = 0x00000200; +// private final static int CDMA_SMS_WMS_MASK_BD_REPLY_OPTION = 0x00000400; + private final static int CDMA_SMS_WMS_MASK_BD_NUM_OF_MSGS = 0x00000800; +// private final static int CDMA_SMS_WMS_MASK_BD_ALERT = 0x00001000; +// private final static int CDMA_SMS_WMS_MASK_BD_LANGUAGE = 0x00002000; + private final static int CDMA_SMS_WMS_MASK_BD_CALLBACK = 0x00004000; + private final static int CDMA_SMS_WMS_MASK_BD_DISPLAY_MODE = 0x00008000; +// private final static int CDMA_SMS_WMS_MASK_BD_SCPT_DATA = 0x00010000; +// private final static int CDMA_SMS_WMS_MASK_BD_SCPT_RESULT = 0x00020000; +// private final static int CDMA_SMS_WMS_MASK_BD_DEPOSIT_INDEX = 0x00040000; +// private final static int CDMA_SMS_WMS_MASK_BD_DELIVERY_STATUS = 0x00080000; +// private final static int CDMA_SMS_WMS_MASK_BD_IP_ADDRESS = 0x10000000; +// private final static int CDMA_SMS_WMS_MASK_BD_RSN_NO_NOTIFY = 0x20000000; +// private final static int CDMA_SMS_WMS_MASK_BD_OTHER = 0x40000000; + + /** + * Successful operation. + */ + private static final int JNI_CDMA_SMS_SUCCESS = 0; + + /** + * General failure. + */ + private static final int JNI_CDMA_SMS_FAILURE = 1; + + /** + * Data length is out of length. + */ + private static final int JNI_CDMA_SMS_DATA_LEN_OUT_OF_RANGE = 2; + + /** + * Class name unknown. + */ + private static final int JNI_CDMA_SMS_CLASS_UNKNOWN = 3; + + /** + * Field ID unknown. + */ + private static final int JNI_CDMA_SMS_FIELD_ID_UNKNOWN = 4; + + /** + * Memory allocation failed. + */ + private static final int JNI_CDMA_SMS_OUT_OF_MEMORY = 5; + + /** + * Encode SMS. + * + * @param bearerData an instance of BearerData. + * + * @return the encoded SMS as byte[]. + */ + public static byte[] encodeCdmaSms(BearerData bearerData) { + byte[] encodedSms; + + if( nativeCdmaSmsConstructClientBD() == JNI_CDMA_SMS_FAILURE){ + return null; + } + + // check bearer data and generate bit mask + generateBearerDataBitMask(bearerData); + encodedSms = startEncoding(bearerData); + + if( nativeCdmaSmsDestructClientBD() == JNI_CDMA_SMS_FAILURE){ + return null; + } + return encodedSms; + } + + /** + * Decode SMS. + * + * @param SmsData the encoded SMS. + * + * @return an instance of BearerData. + */ + public static BearerData decodeCdmaSms(byte[] SmsData) { + BearerData bearerData; + + if( nativeCdmaSmsConstructClientBD() == JNI_CDMA_SMS_FAILURE){ + return null; + } + + bearerData = startDecoding(SmsData); + + if( nativeCdmaSmsDestructClientBD() == JNI_CDMA_SMS_FAILURE){ + return null; + } + return bearerData; + } + + private static void generateBearerDataBitMask(BearerData bearerData) { + // initial + bearerData.mask = CDMA_SMS_WMS_MASK_BD_NULL; + + // check message type + if (bearerData.messageType != 0){ + bearerData.mask |= CDMA_SMS_WMS_MASK_BD_MSG_ID; + } + + // check mUserData + if (bearerData.userData != null){ + bearerData.mask |= CDMA_SMS_WMS_MASK_BD_USER_DATA; + } + + // check mTimeStamp + if (bearerData.timeStamp != null){ + bearerData.mask |= CDMA_SMS_WMS_MASK_BD_MC_TIME; + } + + // check mNumberOfMessages + if (bearerData.numberOfMessages > 0){ + bearerData.mask |= CDMA_SMS_WMS_MASK_BD_NUM_OF_MSGS; + } + + // check mCallbackNumber + if(bearerData.callbackNumber != null){ + bearerData.mask |= CDMA_SMS_WMS_MASK_BD_CALLBACK; + } + + // check DisplayMode + if(bearerData.displayMode == BearerData.DISPLAY_DEFAULT || + bearerData.displayMode == BearerData.DISPLAY_IMMEDIATE || + bearerData.displayMode == BearerData.DISPLAY_USER){ + bearerData.mask |= CDMA_SMS_WMS_MASK_BD_DISPLAY_MODE; + } + } + + private static byte[] startEncoding(BearerData bearerData) { + int m_id; + byte[] m_data; + int dataLength; + byte[] encodedSms; + int nbrOfHeaders = 0; + + if( nativeCdmaSmsSetBearerDataPrimitives(bearerData) == JNI_CDMA_SMS_FAILURE){ + return null; + } + + if ((bearerData.mask & CDMA_SMS_WMS_MASK_BD_USER_DATA) == CDMA_SMS_WMS_MASK_BD_USER_DATA){ + if( nativeCdmaSmsSetUserData(bearerData.userData) == JNI_CDMA_SMS_FAILURE){ + return null; + } + + if (bearerData.userData.userDataHeader != null){ + nbrOfHeaders = bearerData.userData.userDataHeader.nbrOfHeaders; + } + + for (int i = 0; i < nbrOfHeaders; i++) { + m_id = bearerData.userData.userDataHeader.getElements().get(i).getID(); + m_data = bearerData.userData.userDataHeader.getElements().get(i).getData(); + dataLength = m_data.length; + if( nativeCdmaSmsSetUserDataHeader(m_id, m_data, dataLength, i) + == JNI_CDMA_SMS_FAILURE){ + return null; + } + } + } + + if ((bearerData.mask & CDMA_SMS_WMS_MASK_BD_CALLBACK) == CDMA_SMS_WMS_MASK_BD_CALLBACK) { + if( nativeCdmaSmsSetSmsAddress(bearerData.callbackNumber) == JNI_CDMA_SMS_FAILURE){ + return null; + } + } + + /* call native method to encode SMS */ + encodedSms = nativeCdmaSmsEncodeSms(); + + return encodedSms; + } + + private static BearerData startDecoding(byte[] SmsData) { + BearerData bData = new BearerData(); + byte[] udhData; + + /* call native method to decode SMS */ + if( nativeCdmaSmsDecodeSms(SmsData) == JNI_CDMA_SMS_FAILURE){ + return null; + } + + if( nativeCdmaSmsGetBearerDataPrimitives(bData) == JNI_CDMA_SMS_FAILURE){ + return null; + } + + if ((bData.mask & CDMA_SMS_WMS_MASK_BD_USER_DATA) == CDMA_SMS_WMS_MASK_BD_USER_DATA) { + bData.userData = new UserData(); + if( nativeCdmaSmsGetUserData(bData.userData) == JNI_CDMA_SMS_FAILURE){ + return null; + } + + udhData = nativeCdmaSmsGetUserDataHeader(); + if (udhData != null) { + bData.userData.userDataHeader = SmsHeader.parse(udhData); + } + } + + if ((bData.mask & CDMA_SMS_WMS_MASK_BD_CALLBACK) == CDMA_SMS_WMS_MASK_BD_CALLBACK) { + bData.callbackNumber = new CdmaSmsAddress(); + if( nativeCdmaSmsGetSmsAddress(bData.callbackNumber) == JNI_CDMA_SMS_FAILURE){ + return null; + } + } + + return bData; + } + + // native methods + + /** + * native method: Allocate memory for clientBD structure + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsConstructClientBD(); + + /** + * native method: Free memory used for clientBD structure + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsDestructClientBD(); + + /** + * native method: fill clientBD structure with bearerData primitives + * + * @param bearerData an instance of BearerData. + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsSetBearerDataPrimitives(BearerData bearerData); + + /** + * native method: fill bearerData primitives with clientBD variables + * + * @param bearerData an instance of BearerData. + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsGetBearerDataPrimitives(BearerData bearerData); + + /** + * native method: fill clientBD.user_data with UserData primitives + * + * @param userData an instance of UserData. + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsSetUserData(UserData userData); + + /** + * native method: fill UserData primitives with clientBD.user_data + * + * @param userData an instance of UserData. + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsGetUserData(UserData userData); + + /** + * native method: fill clientBD.user_data.headers with UserDataHeader primitives + * + * @param ID ID of element. + * @param data element data. + * @param dataLength data length + * @param index index of element + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsSetUserDataHeader( + int ID, byte[] data, int dataLength, int index); + + /** + * native method: fill UserDataHeader primitives with clientBD.user_data.headers + * + * @return user data headers + */ + private static native byte[] nativeCdmaSmsGetUserDataHeader(); + + /** + * native method: fill clientBD.callback with SmsAddress primitives + * + * @param smsAddr an instance of SmsAddress. + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsSetSmsAddress(CdmaSmsAddress smsAddr); + + /** + * native method: fill SmsAddress primitives with clientBD.callback + * + * @param smsAddr an instance of SmsAddress. + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsGetSmsAddress(CdmaSmsAddress smsAddr); + + /** + * native method: call encoding functions and get encoded SMS + * + * @return the encoded SMS + */ + private static native byte[] nativeCdmaSmsEncodeSms(); + + /** + * native method: call decode functions + * + * @param encodedSMS encoded SMS. + * + * @return #JNI_CDMA_SMS_SUCCESS if succeed. + * #JNI_CDMA_SMS_FAILURE if fail. + */ + private static native int nativeCdmaSmsDecodeSms(byte[] encodedSMS); + + /** + * Load the shared library to link the native methods. + */ + static { + try { + System.loadLibrary("cdma_sms_jni"); + } + catch (UnsatisfiedLinkError ule) { + System.err.println("WARNING: Could not load cdma_sms_jni.so"); + } + } +} + diff --git a/telephony/java/com/android/internal/telephony/cdma/sms/SmsEnvelope.java b/telephony/java/com/android/internal/telephony/cdma/sms/SmsEnvelope.java new file mode 100644 index 0000000..f80e8c0 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/sms/SmsEnvelope.java @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma.sms; + + +public final class SmsEnvelope{ + /** + * Message Types + * (See 3GPP2 C.S0015-B 3.4.1) + */ + static public final int MESSAGE_TYPE_POINT_TO_POINT = 0x00; + static public final int MESSAGE_TYPE_BROADCAST = 0x01; + static public final int MESSAGE_TYPE_ACKNOWLEDGE = 0x02; + + /** + * Supported Teleservices + * (See 3GPP2 N.S0005 and TIA-41) + */ + static public final int TELESERVICE_NOT_SET = 0x0000; + static public final int TELESERVICE_WMT = 0x1002; + static public final int TELESERVICE_VMN = 0x1003; + static public final int TELESERVICE_WAP = 0x1004; + static public final int TELESERVICE_WEMT = 0x1005; + + // ServiceCategories for Cell Broadcast, see 3GPP2 C.R1001 table 9.3.1-1 + //static public final int SERVICECATEGORY_EMERGENCY = 0x0010; + //... + + /** + * maximum lengths for fields as defined in ril_cdma_sms.h + */ + static public final int SMS_BEARER_DATA_MAX = 255; + + /** + * Provides the type of a SMS message like point to point, broadcast or acknowledge + */ + public int messageType; + + /** + * The 16-bit Teleservice parameter identifies which upper layer service access point is sending + * or receiving the message. + * (See 3GPP2 C.S0015-B, v2, 3.4.3.1) + */ + public int teleService = TELESERVICE_NOT_SET; + + /** + * The 16-bit service category parameter identifies the type of service provided + * by the SMS message. + * (See 3GPP2 C.S0015-B, v2, 3.4.3.2) + */ + public int serviceCategory; + + /** + * The origination address identifies the originator of the SMS message. + * (See 3GPP2 C.S0015-B, v2, 3.4.3.4) + */ + public CdmaSmsAddress origAddress; + + /** + * The destination address identifies the target of the SMS message. + * (See 3GPP2 C.S0015-B, v2, 3.4.3.4) + */ + public CdmaSmsAddress destAddress; + + /** + * The 6-bit bearer reply parameter is used to request the return of a + * SMS Acknowledge Message. + * (See 3GPP2 C.S0015-B, v2, 3.4.3.5) + */ + public int bearerReply; + + /** + * Cause Code values: + * The cause code parameters are an indication whether an SMS error has occurred and if so, + * whether the condition is considered temporary or permanent. + * ReplySeqNo 6-bit value, + * ErrorClass 2-bit value, + * CauseCode 0-bit or 8-bit value + * (See 3GPP2 C.S0015-B, v2, 3.4.3.6) + */ + public byte replySeqNo; + public byte errorClass; + public byte causeCode; + + /** + * encoded bearer data + * (See 3GPP2 C.S0015-B, v2, 3.4.3.7) + */ + public byte[] bearerData; + + public SmsEnvelope() { + // nothing to see here + } + +} + diff --git a/telephony/java/com/android/internal/telephony/cdma/sms/UserData.java b/telephony/java/com/android/internal/telephony/cdma/sms/UserData.java new file mode 100644 index 0000000..e761469 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/sms/UserData.java @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.cdma.sms; + +import com.android.internal.telephony.SmsHeader; + +public class UserData{ + + /** + * Supported user data encoding types + * (See 3GPP2 C.R1001-F, v1.0, table 9.1-1) + */ + public static final int UD_ENCODING_OCTET = 0x00; + //public static final int UD_ENCODING_EXTENDED_PROTOCOL = 0x01; + public static final int UD_ENCODING_7BIT_ASCII = 0x02; + public static final int UD_ENCODING_IA5 = 0x03; + public static final int UD_ENCODING_UNICODE_16 = 0x04; + //public static final int UD_ENCODING_SHIFT_JIS = 0x05; + //public static final int UD_ENCODING_KOREAN = 0x06; + //public static final int UD_ENCODING_LATIN_HEBREW = 0x07; + //public static final int UD_ENCODING_LATIN = 0x08; + public static final int UD_ENCODING_GSM_7BIT_ALPHABET = 0x09; + //public static final int UD_ENCODING_GSM_DCS = 0x0A; + + /** + * Contains the data header of the user data + */ + public SmsHeader userDataHeader; + + /** + * Contains the data encoding type for the SMS message + */ + public int userDataEncoding; + + // needed when encoding is IS91 or DCS (not supported yet): + //public int messageType; + + /** + * Number of invalid bits in the last byte of data. + */ + public int paddingBits; + + /** + * Contains the user data of a SMS message + * (See 3GPP2 C.S0015-B, v2, 4.5.2) + */ + public byte[] userData; + +} diff --git a/telephony/java/com/android/internal/telephony/cdma/sms/package.html b/telephony/java/com/android/internal/telephony/cdma/sms/package.html new file mode 100644 index 0000000..48e1034 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/cdma/sms/package.html @@ -0,0 +1,6 @@ +<HTML> +<BODY> +Provides CDMA-specific features for text/data/PDU SMS messages +@hide +</BODY> +</HTML> diff --git a/telephony/java/com/android/internal/telephony/gsm/AdnRecord.java b/telephony/java/com/android/internal/telephony/gsm/AdnRecord.java deleted file mode 100644 index 30df699..0000000 --- a/telephony/java/com/android/internal/telephony/gsm/AdnRecord.java +++ /dev/null @@ -1,570 +0,0 @@ -/* - * Copyright (C) 2006 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.android.internal.telephony.gsm; - -import com.android.internal.telephony.*; -import android.os.Parcel; -import android.os.Parcelable; -import android.os.Message; -import android.os.Handler; -import android.os.Looper; -import android.os.AsyncResult; -import android.util.Log; -import android.telephony.PhoneNumberUtils; -import java.util.ArrayList; - -class AdnRecordLoader extends Handler -{ - static final String LOG_TAG = "GSM"; - - //***** Instance Variables - - GSMPhone phone; - int ef; - int extensionEF; - int pendingExtLoads; - Message userResponse; - String pin2; - - // For "load one" - int recordNumber; - - // for "load all" - ArrayList<AdnRecord> adns; // only valid after EVENT_ADN_LOAD_ALL_DONE - - // Either an AdnRecord or a reference to adns depending - // if this is a load one or load all operation - Object result; - - //***** Event Constants - - static final int EVENT_ADN_LOAD_DONE = 1; - static final int EVENT_EXT_RECORD_LOAD_DONE = 2; - static final int EVENT_ADN_LOAD_ALL_DONE = 3; - static final int EVENT_EF_LINEAR_RECORD_SIZE_DONE = 4; - static final int EVENT_UPDATE_RECORD_DONE = 5; - - //***** Constructor - - AdnRecordLoader(GSMPhone phone) - { - // The telephony unit-test cases may create AdnRecords - // in secondary threads - super(phone.h.getLooper()); - - this.phone = phone; - } - - /** - * Resulting AdnRecord is placed in response.obj.result - * or response.obj.exception is set - */ - void - loadFromEF(int ef, int extensionEF, int recordNumber, - Message response) - { - this.ef = ef; - this.extensionEF = extensionEF; - this.recordNumber = recordNumber; - this.userResponse = response; - - phone.mSIMFileHandler.loadEFLinearFixed( - ef, recordNumber, - obtainMessage(EVENT_ADN_LOAD_DONE)); - - } - - - /** - * Resulting ArrayList<adnRecord> is placed in response.obj.result - * or response.obj.exception is set - */ - void - loadAllFromEF(int ef, int extensionEF, - Message response) - { - this.ef = ef; - this.extensionEF = extensionEF; - this.userResponse = response; - - phone.mSIMFileHandler.loadEFLinearFixedAll( - ef, - obtainMessage(EVENT_ADN_LOAD_ALL_DONE)); - - } - - /** - * Write adn to a EF SIM record - * It will get the record size of EF record and compose hex adn array - * then write the hex array to EF record - * - * @param adn is set with alphaTag and phoneNubmer - * @param ef EF fileid - * @param extensionEF extension EF fileid - * @param recordNumber 1-based record index - * @param pin2 for CHV2 operations, must be null if pin2 is not needed - * @param response will be sent to its handler when completed - */ - void - updateEF(AdnRecord adn, int ef, int extensionEF, int recordNumber, - String pin2, Message response) - { - this.ef = ef; - this.extensionEF = extensionEF; - this.recordNumber = recordNumber; - this.userResponse = response; - this.pin2 = pin2; - - phone.mSIMFileHandler.getEFLinearRecordSize( ef, - obtainMessage(EVENT_EF_LINEAR_RECORD_SIZE_DONE, adn)); - } - - //***** Overridden from Handler - - public void - handleMessage(Message msg) - { - AsyncResult ar; - byte data[]; - AdnRecord adn; - - try { - switch (msg.what) { - case EVENT_EF_LINEAR_RECORD_SIZE_DONE: - ar = (AsyncResult)(msg.obj); - adn = (AdnRecord)(ar.userObj); - - if (ar.exception != null) { - throw new RuntimeException("get EF record size failed", - ar.exception); - } - - int[] recordSize = (int[])ar.result; - // recordSize is int[3] array - // int[0] is the record length - // int[1] is the total length of the EF file - // int[2] is the number of records in the EF file - // So int[0] * int[2] = int[1] - if (recordSize.length != 3 || recordNumber > recordSize[2]) { - throw new RuntimeException("get wrong EF record size format", - ar.exception); - } - - data = adn.buildAdnString(recordSize[0]); - - if(data == null) { - throw new RuntimeException("worong ADN format", - ar.exception); - } - - phone.mSIMFileHandler.updateEFLinearFixed(ef, recordNumber, - data, pin2, obtainMessage(EVENT_UPDATE_RECORD_DONE)); - - pendingExtLoads = 1; - - break; - case EVENT_UPDATE_RECORD_DONE: - ar = (AsyncResult)(msg.obj); - if (ar.exception != null) { - throw new RuntimeException("update EF adn record failed", - ar.exception); - } - pendingExtLoads = 0; - result = null; - break; - case EVENT_ADN_LOAD_DONE: - ar = (AsyncResult)(msg.obj); - data = (byte[])(ar.result); - - if (ar.exception != null) { - throw new RuntimeException("load failed", ar.exception); - } - - if (false) { - Log.d(LOG_TAG,"ADN EF: 0x" - + Integer.toHexString(ef) - + ":" + recordNumber - + "\n" + SimUtils.bytesToHexString(data)); - } - - adn = new AdnRecord(ef, recordNumber, data); - result = adn; - - if (adn.hasExtendedRecord()) { - // If we have a valid value in the ext record field, - // we're not done yet: we need to read the corresponding - // ext record and append it - - pendingExtLoads = 1; - - phone.mSIMFileHandler.loadEFLinearFixed( - extensionEF, adn.extRecord, - obtainMessage(EVENT_EXT_RECORD_LOAD_DONE, adn)); - } - break; - - case EVENT_EXT_RECORD_LOAD_DONE: - ar = (AsyncResult)(msg.obj); - data = (byte[])(ar.result); - adn = (AdnRecord)(ar.userObj); - - if (ar.exception != null) { - throw new RuntimeException("load failed", ar.exception); - } - - Log.d(LOG_TAG,"ADN extention EF: 0x" - + Integer.toHexString(extensionEF) - + ":" + adn.extRecord - + "\n" + SimUtils.bytesToHexString(data)); - - adn.appendExtRecord(data); - - pendingExtLoads--; - // result should have been set in - // EVENT_ADN_LOAD_DONE or EVENT_ADN_LOAD_ALL_DONE - break; - - case EVENT_ADN_LOAD_ALL_DONE: - ar = (AsyncResult)(msg.obj); - ArrayList<byte[]> datas = (ArrayList<byte[]>)(ar.result); - - if (ar.exception != null) { - throw new RuntimeException("load failed", ar.exception); - } - - adns = new ArrayList<AdnRecord>(datas.size()); - result = adns; - pendingExtLoads = 0; - - for(int i = 0, s = datas.size() ; i < s ; i++) { - adn = new AdnRecord(ef, 1 + i, datas.get(i)); - adns.add(adn); - - if (adn.hasExtendedRecord()) { - // If we have a valid value in the ext record field, - // we're not done yet: we need to read the corresponding - // ext record and append it - - pendingExtLoads++; - - phone.mSIMFileHandler.loadEFLinearFixed( - extensionEF, adn.extRecord, - obtainMessage(EVENT_EXT_RECORD_LOAD_DONE, adn)); - } - } - break; - } - } catch (RuntimeException exc) { - if (userResponse != null) { - AsyncResult.forMessage(userResponse) - .exception = exc; - userResponse.sendToTarget(); - // Loading is all or nothing--either every load succeeds - // or we fail the whole thing. - userResponse = null; - } - return; - } - - if (userResponse != null && pendingExtLoads == 0) { - AsyncResult.forMessage(userResponse).result - = result; - - userResponse.sendToTarget(); - userResponse = null; - } - } - - -} - -/** - * - * Used to load or store ADNs (Abbreviated Dialing Numbers). - * - * {@hide} - * - */ -public class AdnRecord implements Parcelable -{ - static final String LOG_TAG = "GSM"; - - //***** Instance Variables - - String alphaTag = ""; - String number = ""; - int extRecord = 0xff; - int efid; // or 0 if none - int recordNumber; // or 0 if none - - - //***** Constants - - // In an ADN record, everything but the alpha identifier - // is in a footer that's 14 bytes - static final int FOOTER_SIZE_BYTES = 14; - - // Maximum size of the un-extended number field - static final int MAX_NUMBER_SIZE_BYTES = 11; - - static final int EXT_RECORD_LENGTH_BYTES = 13; - static final int EXT_RECORD_TYPE_ADDITIONAL_DATA = 2; - static final int EXT_RECORD_TYPE_MASK = 3; - static final int MAX_EXT_CALLED_PARTY_LENGTH = 0xa; - - // ADN offset - static final int ADN_BCD_NUMBER_LENGTH = 0; - static final int ADN_TON_AND_NPI = 1; - static final int ADN_DAILING_NUMBER_START = 2; - static final int ADN_DAILING_NUMBER_END = 11; - static final int ADN_CAPABILITY_ID = 12; - static final int ADN_EXTENSION_ID = 13; - - //***** Static Methods - - public static final Parcelable.Creator<AdnRecord> CREATOR - = new Parcelable.Creator<AdnRecord>() - { - public AdnRecord createFromParcel(Parcel source) - { - int efid; - int recordNumber; - String alphaTag; - String number; - - efid = source.readInt(); - recordNumber = source.readInt(); - alphaTag = source.readString(); - number = source.readString(); - - return new AdnRecord(efid, recordNumber, alphaTag, number); - } - - public AdnRecord[] newArray(int size) - { - return new AdnRecord[size]; - } - }; - - - //***** Constructor - public - AdnRecord (byte[] record) - { - this(0, 0, record); - } - - public - AdnRecord (int efid, int recordNumber, byte[] record) - { - this.efid = efid; - this.recordNumber = recordNumber; - parseRecord(record); - } - - public - AdnRecord (String alphaTag, String number) - { - this(0, 0, alphaTag, number); - } - - public - AdnRecord (int efid, int recordNumber, String alphaTag, String number) - { - this.efid = efid; - this.recordNumber = recordNumber; - this.alphaTag = alphaTag; - this.number = number; - } - - //***** Instance Methods - - public String getAlphaTag() - { - return alphaTag; - } - - public String getNumber() - { - return number; - } - - public String toString() - { - return "ADN Record '" + alphaTag + "' '" + number + "'"; - } - - public boolean isEmpty() - { - return alphaTag.equals("") && number.equals(""); - } - - public boolean hasExtendedRecord() - { - return extRecord != 0 && extRecord != 0xff; - } - - public boolean isEqual(AdnRecord adn) { - return ( alphaTag.equals(adn.getAlphaTag()) && - number.equals(adn.getNumber()) ); - } - //***** Parcelable Implementation - - public int describeContents() { - return 0; - } - - public void writeToParcel(Parcel dest, int flags) - { - dest.writeInt(efid); - dest.writeInt(recordNumber); - dest.writeString(alphaTag); - dest.writeString(number); - } - - /** - * Build adn hex byte array based on record size - * The format of byte array is defined in 51.011 10.5.1 - * - * @param recordSize is the size X of EF record - * @return hex byte[recordSize] to be written to EF record - * return nulll for wrong format of dialing nubmer or tag - */ - public byte[] buildAdnString(int recordSize) { - byte[] bcdNumber; - byte[] byteTag; - byte[] adnString = null; - int footerOffset = recordSize - FOOTER_SIZE_BYTES; - - if (number == null || number.equals("") || - alphaTag == null || alphaTag.equals("")) { - - Log.w(LOG_TAG, "[buildAdnString] Empty alpha tag or number"); - adnString = new byte[recordSize]; - for (int i = 0; i < recordSize; i++) { - adnString[i] = (byte) 0xFF; - } - } else if (number.length() - > (ADN_DAILING_NUMBER_END - ADN_DAILING_NUMBER_START + 1) * 2) { - Log.w(LOG_TAG, - "[buildAdnString] Max length of dailing number is 20"); - } else if (alphaTag.length() > footerOffset) { - Log.w(LOG_TAG, - "[buildAdnString] Max length of tag is " + footerOffset); - } else { - - adnString = new byte[recordSize]; - for (int i = 0; i < recordSize; i++) { - adnString[i] = (byte) 0xFF; - } - - bcdNumber = PhoneNumberUtils.numberToCalledPartyBCD(number); - - System.arraycopy(bcdNumber, 0, adnString, - footerOffset + ADN_TON_AND_NPI, bcdNumber.length); - - adnString[footerOffset + ADN_BCD_NUMBER_LENGTH] - = (byte) (bcdNumber.length); - adnString[footerOffset + ADN_CAPABILITY_ID] - = (byte) 0xFF; // Capacility Id - adnString[footerOffset + ADN_EXTENSION_ID] - = (byte) 0xFF; // Extension Record Id - - byteTag = GsmAlphabet.stringToGsm8BitPacked(alphaTag); - System.arraycopy(byteTag, 0, adnString, 0, byteTag.length); - - } - - return adnString; - } - - /** - * See TS 51.011 10.5.10 - */ - public void - appendExtRecord (byte[] extRecord) { - try { - if (extRecord.length != EXT_RECORD_LENGTH_BYTES) { - return; - } - - if ((extRecord[0] & EXT_RECORD_TYPE_MASK) - != EXT_RECORD_TYPE_ADDITIONAL_DATA - ) { - return; - } - - if ((0xff & extRecord[1]) > MAX_EXT_CALLED_PARTY_LENGTH) { - // invalid or empty record - return; - } - - number += PhoneNumberUtils.calledPartyBCDFragmentToString( - extRecord, 2, 0xff & extRecord[1]); - - // We don't support ext record chaining. - - } catch (RuntimeException ex) { - - - - - Log.w(LOG_TAG, "Error parsing AdnRecord ext record", ex); - } - } - - //***** Private Methods - - /** - * alphaTag and number are set to null on invalid format - */ - private void - parseRecord(byte[] record) { - try { - alphaTag = SimUtils.adnStringFieldToString( - record, 0, record.length - FOOTER_SIZE_BYTES); - - int footerOffset = record.length - FOOTER_SIZE_BYTES; - - int numberLength = 0xff & record[footerOffset]; - - if (numberLength > MAX_NUMBER_SIZE_BYTES) { - // Invalid number length - number = ""; - return; - } - - // Please note 51.011 10.5.1: - // - // "If the Dialling Number/SSC String does not contain - // a dialling number, e.g. a control string deactivating - // a service, the TON/NPI byte shall be set to 'FF' by - // the ME (see note 2)." - - number = PhoneNumberUtils.calledPartyBCDToString( - record, footerOffset + 1, numberLength); - - - extRecord = 0xff & record[record.length - 1]; - - } catch (RuntimeException ex) { - Log.w(LOG_TAG, "Error parsing AdnRecord", ex); - number = ""; - alphaTag = ""; - } - } -} diff --git a/telephony/java/com/android/internal/telephony/gsm/BaseCommands.java b/telephony/java/com/android/internal/telephony/gsm/BaseCommands.java deleted file mode 100644 index 8e14b43..0000000 --- a/telephony/java/com/android/internal/telephony/gsm/BaseCommands.java +++ /dev/null @@ -1,367 +0,0 @@ -/* - * Copyright (C) 2006 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.android.internal.telephony.gsm; - -import android.content.Context; -import android.os.RegistrantList; -import android.os.Registrant; -import android.os.Handler; -import android.os.AsyncResult; -import android.os.SystemProperties; -import android.provider.Checkin; -import android.util.Config; -import android.util.Log; - -/** - * {@hide} - */ -public abstract class BaseCommands implements CommandsInterface -{ - static final String LOG_TAG = "GSM"; - - //***** Instance Variables - protected Context mContext; - protected RadioState mState = RadioState.RADIO_UNAVAILABLE; - protected Object mStateMonitor = new Object(); - - protected RegistrantList mRadioStateChangedRegistrants = new RegistrantList(); - protected RegistrantList mOnRegistrants = new RegistrantList(); - protected RegistrantList mAvailRegistrants = new RegistrantList(); - protected RegistrantList mOffOrNotAvailRegistrants = new RegistrantList(); - protected RegistrantList mNotAvailRegistrants = new RegistrantList(); - protected RegistrantList mSIMReadyRegistrants = new RegistrantList(); - protected RegistrantList mSIMLockedRegistrants = new RegistrantList(); - protected RegistrantList mCallStateRegistrants = new RegistrantList(); - protected RegistrantList mNetworkStateRegistrants = new RegistrantList(); - protected RegistrantList mPDPRegistrants = new RegistrantList(); - protected Registrant mSMSRegistrant; - protected Registrant mNITZTimeRegistrant; - protected Registrant mSignalStrengthRegistrant; - protected Registrant mUSSDRegistrant; - protected Registrant mSmsOnSimRegistrant; - /** Registrant for handling SMS Status Reports */ - protected Registrant mSmsStatusRegistrant; - /** Registrant for handling Supplementary Service Notifications */ - protected Registrant mSsnRegistrant; - protected Registrant mStkSessionEndRegistrant; - protected Registrant mStkProCmdRegistrant; - protected Registrant mStkEventRegistrant; - protected Registrant mStkCallSetUpRegistrant; - /** Registrant for handling SIM SMS storage full messages */ - protected Registrant mSimSmsFullRegistrant; - /** Registrant for handling SIM Refresh notifications */ - protected Registrant mSimRefreshRegistrant; - /** Registrant for handling RING notifications */ - protected Registrant mRingRegistrant; - /** Registrant for handling RESTRICTED STATE changed notification */ - protected Registrant mRestrictedStateRegistrant; - - public BaseCommands(Context context) { - mContext = context; // May be null (if so we won't log statistics) - } - - //***** CommandsInterface implementation - - public RadioState - getRadioState() - { - return mState; - } - - - public void - registerForRadioStateChanged(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - synchronized (mStateMonitor) { - mRadioStateChangedRegistrants.add(r); - r.notifyRegistrant(); - } - } - - public void - registerForOn(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - synchronized (mStateMonitor) { - mOnRegistrants.add(r); - - if (mState.isOn()) { - r.notifyRegistrant(new AsyncResult(null, null, null)); - } - } - } - - - public void - registerForAvailable(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - synchronized (mStateMonitor) { - mAvailRegistrants.add(r); - - if (mState.isAvailable()) { - r.notifyRegistrant(new AsyncResult(null, null, null)); - } - } - } - - public void - registerForNotAvailable(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - synchronized (mStateMonitor) { - mNotAvailRegistrants.add(r); - - if (!mState.isAvailable()) { - r.notifyRegistrant(new AsyncResult(null, null, null)); - } - } - } - - public void - registerForOffOrNotAvailable(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - synchronized (mStateMonitor) { - mOffOrNotAvailRegistrants.add(r); - - if (mState == RadioState.RADIO_OFF || !mState.isAvailable()) { - r.notifyRegistrant(new AsyncResult(null, null, null)); - } - } - } - - - /** Any transition into SIM_READY */ - public void - registerForSIMReady(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - synchronized (mStateMonitor) { - mSIMReadyRegistrants.add(r); - - if (mState.isSIMReady()) { - r.notifyRegistrant(new AsyncResult(null, null, null)); - } - } - } - - public void - registerForSIMLockedOrAbsent(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - synchronized (mStateMonitor) { - mSIMLockedRegistrants.add(r); - - if (mState == RadioState.SIM_LOCKED_OR_ABSENT) { - r.notifyRegistrant(new AsyncResult(null, null, null)); - } - } - } - - public void - registerForCallStateChanged(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - mCallStateRegistrants.add(r); - } - - public void - registerForNetworkStateChanged(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - mNetworkStateRegistrants.add(r); - } - - public void - registerForPDPStateChanged(Handler h, int what, Object obj) - { - Registrant r = new Registrant (h, what, obj); - - mPDPRegistrants.add(r); - } - - public void - setOnNewSMS(Handler h, int what, Object obj) - { - mSMSRegistrant = new Registrant (h, what, obj); - } - - public void - setOnSmsOnSim(Handler h, int what, Object obj) - { - mSmsOnSimRegistrant = new Registrant (h, what, obj); - } - - public void setOnSmsStatus(Handler h, int what, Object obj) { - mSmsStatusRegistrant = new Registrant (h, what, obj); - } - - public void - setOnSignalStrengthUpdate(Handler h, int what, Object obj) - { - mSignalStrengthRegistrant = new Registrant (h, what, obj); - } - - public void - setOnNITZTime(Handler h, int what, Object obj) - { - mNITZTimeRegistrant = new Registrant (h, what, obj); - } - - public void - setOnUSSD(Handler h, int what, Object obj) - { - mUSSDRegistrant = new Registrant (h, what, obj); - } - - public void - setOnSuppServiceNotification(Handler h, int what, Object obj) - { - mSsnRegistrant = new Registrant (h, what, obj); - } - - public void - setOnStkSessionEnd(Handler h, int what, Object obj) - { - mStkSessionEndRegistrant = new Registrant (h, what, obj); - } - - public void - setOnStkProactiveCmd(Handler h, int what, Object obj) - { - mStkProCmdRegistrant = new Registrant (h, what, obj); - } - - public void - setOnStkEvent(Handler h, int what, Object obj) - { - mStkEventRegistrant = new Registrant (h, what, obj); - } - - public void - setOnStkCallSetUp(Handler h, int what, Object obj) - { - mStkCallSetUpRegistrant = new Registrant (h, what, obj); - } - - public void setOnSimSmsFull(Handler h, int what, Object obj) { - mSimSmsFullRegistrant = new Registrant (h, what, obj); - } - - public void setOnSimRefresh(Handler h, int what, Object obj) { - mSimRefreshRegistrant = new Registrant (h, what, obj); - } - - public void setOnCallRing(Handler h, int what, Object obj) { - mRingRegistrant = new Registrant (h, what, obj); - } - - public void - setOnRestrictedStateChanged(Handler h, int what, Object obj) - { - mRestrictedStateRegistrant = new Registrant (h, what, obj); - } - - //***** Protected Methods - /** - * Store new RadioState and send notification based on the changes - * - * This function is called only by RIL.java when receiving unsolicited - * RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED - * - * RadioState has 5 values : RADIO_OFF, RADIO_UNAVAILABLE, SIM_NOT_READY, - * SIM_LOCKED_OR_ABSENT, and SIM_READY. - * - * @param newState new RadioState decoded from RIL_UNSOL_RADIO_STATE_CHANGED - */ - protected void setRadioState(RadioState newState) { - RadioState oldState; - - synchronized (mStateMonitor) { - if (Config.LOGV) { - Log.v(LOG_TAG, "setRadioState old: " + mState - + " new " + newState); - } - - oldState = mState; - mState = newState; - - if (oldState == mState) { - // no state transition - return; - } - - if (mContext != null && - newState == RadioState.RADIO_UNAVAILABLE && - oldState != RadioState.RADIO_OFF) { - Checkin.updateStats(mContext.getContentResolver(), - Checkin.Stats.Tag.PHONE_RADIO_RESETS, 1, 0.0); - } - - mRadioStateChangedRegistrants.notifyRegistrants(); - - if (mState.isAvailable() && !oldState.isAvailable()) { - Log.d(LOG_TAG,"Notifying: radio available"); - mAvailRegistrants.notifyRegistrants(); - onRadioAvailable(); - } - - if (!mState.isAvailable() && oldState.isAvailable()) { - Log.d(LOG_TAG,"Notifying: radio not available"); - mNotAvailRegistrants.notifyRegistrants(); - } - - if (mState.isSIMReady() && !oldState.isSIMReady()) { - Log.d(LOG_TAG,"Notifying: SIM ready"); - mSIMReadyRegistrants.notifyRegistrants(); - } - - if (mState == RadioState.SIM_LOCKED_OR_ABSENT) { - Log.d(LOG_TAG,"Notifying: SIM locked or absent"); - mSIMLockedRegistrants.notifyRegistrants(); - } - - if (mState.isOn() && !oldState.isOn()) { - Log.d(LOG_TAG,"Notifying: Radio On"); - mOnRegistrants.notifyRegistrants(); - } - - if ((!mState.isOn() || !mState.isAvailable()) - && !((!oldState.isOn() || !oldState.isAvailable())) - ) { - Log.d(LOG_TAG,"Notifying: radio off or not available"); - mOffOrNotAvailRegistrants.notifyRegistrants(); - } - } - } - - protected void - onRadioAvailable() - { - } -} diff --git a/telephony/java/com/android/internal/telephony/gsm/GSMPhone.java b/telephony/java/com/android/internal/telephony/gsm/GSMPhone.java index f93c724..d1ae997 100644 --- a/telephony/java/com/android/internal/telephony/gsm/GSMPhone.java +++ b/telephony/java/com/android/internal/telephony/gsm/GSMPhone.java @@ -16,18 +16,6 @@ package com.android.internal.telephony.gsm; -import static com.android.internal.telephony.TelephonyProperties.PROPERTY_BASEBAND_VERSION; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_ACTION_DISABLE; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_ACTION_ENABLE; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_ACTION_ERASURE; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_ACTION_REGISTRATION; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_REASON_ALL; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_REASON_ALL_CONDITIONAL; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_REASON_BUSY; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_REASON_NOT_REACHABLE; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_REASON_NO_REPLY; -import static com.android.internal.telephony.gsm.CommandsInterface.CF_REASON_UNCONDITIONAL; -import static com.android.internal.telephony.gsm.CommandsInterface.SERVICE_CLASS_VOICE; import android.content.ContentValues; import android.content.Context; import android.content.SharedPreferences; @@ -41,26 +29,47 @@ import android.os.Registrant; import android.os.RegistrantList; import android.os.SystemProperties; import android.preference.PreferenceManager; +import android.provider.Settings; import android.provider.Telephony; import android.telephony.CellLocation; import android.telephony.PhoneNumberUtils; import android.telephony.ServiceState; -import android.telephony.TelephonyManager; import android.text.TextUtils; import android.util.Log; -import com.android.internal.telephony.Call; +import static com.android.internal.telephony.CommandsInterface.CF_ACTION_DISABLE; +import static com.android.internal.telephony.CommandsInterface.CF_ACTION_ENABLE; +import static com.android.internal.telephony.CommandsInterface.CF_ACTION_ERASURE; +import static com.android.internal.telephony.CommandsInterface.CF_ACTION_REGISTRATION; +import static com.android.internal.telephony.CommandsInterface.CF_REASON_ALL; +import static com.android.internal.telephony.CommandsInterface.CF_REASON_ALL_CONDITIONAL; +import static com.android.internal.telephony.CommandsInterface.CF_REASON_NO_REPLY; +import static com.android.internal.telephony.CommandsInterface.CF_REASON_NOT_REACHABLE; +import static com.android.internal.telephony.CommandsInterface.CF_REASON_BUSY; +import static com.android.internal.telephony.CommandsInterface.CF_REASON_UNCONDITIONAL; +import static com.android.internal.telephony.CommandsInterface.SERVICE_CLASS_VOICE; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_BASEBAND_VERSION; + +import com.android.internal.telephony.CallForwardInfo; import com.android.internal.telephony.CallStateException; +import com.android.internal.telephony.CommandsInterface; import com.android.internal.telephony.Connection; +import com.android.internal.telephony.DataConnection; +import com.android.internal.telephony.DataConnectionTracker; +import com.android.internal.telephony.IccCard; +import com.android.internal.telephony.IccFileHandler; +import com.android.internal.telephony.IccPhoneBookInterfaceManager; +import com.android.internal.telephony.IccSmsInterfaceManager; import com.android.internal.telephony.MmiCode; import com.android.internal.telephony.Phone; import com.android.internal.telephony.PhoneBase; import com.android.internal.telephony.PhoneNotifier; +import com.android.internal.telephony.PhoneProxy; import com.android.internal.telephony.PhoneSubInfo; -import com.android.internal.telephony.SimCard; -import com.android.internal.telephony.gsm.SimException; +import com.android.internal.telephony.RILConstants; import com.android.internal.telephony.gsm.stk.StkService; import com.android.internal.telephony.test.SimulatedRadioControl; +import com.android.internal.telephony.IccVmNotSupportedException; import java.io.IOException; import java.net.InetSocketAddress; @@ -77,40 +86,28 @@ public class GSMPhone extends PhoneBase { // from this file will go into the radio log rather than the main // log. (Use "adb logcat -b radio" to see them.) static final String LOG_TAG = "GSM"; - private static final boolean LOCAL_DEBUG = false; + private static final boolean LOCAL_DEBUG = true; - // Key used to read and write the saved network selection value - public static final String NETWORK_SELECTION_KEY = "network_selection_key"; - // Key used to read/write "disable data connection on boot" pref (used for testing) - public static final String DATA_DISABLED_ON_BOOT_KEY = "disabled_on_boot_key"; // Key used to read/write current ciphering state public static final String CIPHERING_KEY = "ciphering_key"; - // Key used to read/write current CLIR setting - public static final String CLIR_KEY = "clir_key"; // Key used to read/write voice mail number public static final String VM_NUMBER = "vm_number_key"; // Key used to read/write the SIM IMSI used for storing the voice mail public static final String VM_SIM_IMSI = "vm_sim_imsi_key"; - // Key used to read/write "disable DNS server check" pref (used for testing) - public static final String DNS_SERVER_CHECK_DISABLED_KEY = "dns_server_check_disabled_key"; //***** Instance Variables - - CallTracker mCT; - ServiceStateTracker mSST; - CommandsInterface mCM; - SMSDispatcher mSMS; - DataConnectionTracker mDataConnection; - SIMFileHandler mSIMFileHandler; + GsmCallTracker mCT; + GsmServiceStateTracker mSST; + GsmSMSDispatcher mSMS; + GsmDataConnectionTracker mDataConnection; SIMRecords mSIMRecords; - GsmSimCard mSimCard; + SimCard mSimCard; StkService mStkService; MyHandler h; ArrayList <GsmMmiCode> mPendingMMIs = new ArrayList<GsmMmiCode>(); SimPhoneBookInterfaceManager mSimPhoneBookIntManager; SimSmsInterfaceManager mSimSmsIntManager; PhoneSubInfo mSubInfo; - boolean mDnsCheckDisabled = false; Registrant mPostDialHandler; @@ -129,44 +126,17 @@ public class GSMPhone extends PhoneBase { private String mImeiSv; private String mVmNumber; - //***** Event Constants - - static final int EVENT_RADIO_AVAILABLE = 1; - /** Supplemnetary Service Notification received. */ - static final int EVENT_SSN = 2; - static final int EVENT_SIM_RECORDS_LOADED = 3; - static final int EVENT_MMI_DONE = 4; - static final int EVENT_RADIO_ON = 5; - static final int EVENT_GET_BASEBAND_VERSION_DONE = 6; - static final int EVENT_USSD = 7; - static final int EVENT_RADIO_OFF_OR_NOT_AVAILABLE = 8; - static final int EVENT_GET_IMEI_DONE = 9; - static final int EVENT_GET_IMEISV_DONE = 10; - static final int EVENT_GET_SIM_STATUS_DONE = 11; - static final int EVENT_SET_CALL_FORWARD_DONE = 12; - static final int EVENT_GET_CALL_FORWARD_DONE = 13; - static final int EVENT_CALL_RING = 14; - // Used to intercept the carriere selection calls so that - // we can save the values. - static final int EVENT_SET_NETWORK_MANUAL_COMPLETE = 15; - static final int EVENT_SET_NETWORK_AUTOMATIC_COMPLETE = 16; - static final int EVENT_SET_CLIR_COMPLETE = 17; - static final int EVENT_REGISTERED_TO_NETWORK = 18; - static final int EVENT_SET_VM_NUMBER_DONE = 19; //***** Constructors public - GSMPhone (Context context, CommandsInterface ci, PhoneNotifier notifier) - { + GSMPhone (Context context, CommandsInterface ci, PhoneNotifier notifier) { this(context,ci,notifier, false); } public - GSMPhone (Context context, CommandsInterface ci, PhoneNotifier notifier, boolean unitTestMode) - { + GSMPhone (Context context, CommandsInterface ci, PhoneNotifier notifier, boolean unitTestMode) { super(notifier, context, unitTestMode); - h = new MyHandler(); mCM = ci; @@ -174,34 +144,31 @@ public class GSMPhone extends PhoneBase { mSimulatedRadioControl = (SimulatedRadioControl) ci; } - mCT = new CallTracker(this); - mSST = new ServiceStateTracker (this); - mSMS = new SMSDispatcher(this); - mSIMFileHandler = new SIMFileHandler(this); + mCM.setPhoneType(RILConstants.GSM_PHONE); + mCT = new GsmCallTracker(this); + mSST = new GsmServiceStateTracker (this); + mSMS = new GsmSMSDispatcher(this); + mIccFileHandler = new SIMFileHandler(this); mSIMRecords = new SIMRecords(this); - mDataConnection = new DataConnectionTracker (this); - mSimCard = new GsmSimCard(this); + mDataConnection = new GsmDataConnectionTracker (this); + mSimCard = new SimCard(this); if (!unitTestMode) { mSimPhoneBookIntManager = new SimPhoneBookInterfaceManager(this); mSimSmsIntManager = new SimSmsInterfaceManager(this); mSubInfo = new PhoneSubInfo(this); } mStkService = StkService.getInstance(mCM, mSIMRecords, mContext, - mSIMFileHandler, mSimCard); - + (SIMFileHandler)mIccFileHandler, mSimCard); + mCM.registerForAvailable(h, EVENT_RADIO_AVAILABLE, null); mSIMRecords.registerForRecordsLoaded(h, EVENT_SIM_RECORDS_LOADED, null); - mCM.registerForOffOrNotAvailable(h, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, - null); + mCM.registerForOffOrNotAvailable(h, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null); mCM.registerForOn(h, EVENT_RADIO_ON, null); mCM.setOnUSSD(h, EVENT_USSD, null); mCM.setOnSuppServiceNotification(h, EVENT_SSN, null); mCM.setOnCallRing(h, EVENT_CALL_RING, null); mSST.registerForNetworkAttach(h, EVENT_REGISTERED_TO_NETWORK, null); - SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context); - mDnsCheckDisabled = sp.getBoolean(DNS_SERVER_CHECK_DISABLED_KEY, false); - if (false) { try { //debugSocket = new LocalServerSocket("com.android.internal.telephony.debug"); @@ -221,7 +188,7 @@ public class GSMPhone extends PhoneBase { mCM.resetRadio(null); sock.close(); } catch (IOException ex) { - Log.w(LOG_TAG, + Log.w(LOG_TAG, "Exception accepting socket", ex); } } @@ -235,13 +202,64 @@ public class GSMPhone extends PhoneBase { Log.w(LOG_TAG, "Failure to open com.android.internal.telephony.debug socket", ex); } } + + //Change the system setting + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.CURRENT_ACTIVE_PHONE, RILConstants.GSM_PHONE); + } + + public void dispose() { + synchronized(PhoneProxy.lockForRadioTechnologyChange) { + //Unregister from all former registered events + mCM.unregisterForAvailable(h); //EVENT_RADIO_AVAILABLE + mSIMRecords.unregisterForRecordsLoaded(h); //EVENT_SIM_RECORDS_LOADED + mCM.unregisterForOffOrNotAvailable(h); //EVENT_RADIO_OFF_OR_NOT_AVAILABLE + mCM.unregisterForOn(h); //EVENT_RADIO_ON + mSST.unregisterForNetworkAttach(h); //EVENT_REGISTERED_TO_NETWORK + mCM.unSetOnUSSD(h); + mCM.unSetOnSuppServiceNotification(h); + mCM.unSetOnCallRing(h); + + mPendingMMIs.clear(); + + //Force all referenced classes to unregister their former registered events + mStkService.dispose(); + mCT.dispose(); + mDataConnection.dispose(); + mSST.dispose(); + mIccFileHandler.dispose(); // instance of SimFileHandler + mSIMRecords.dispose(); + mSimCard.dispose(); + mSimPhoneBookIntManager.dispose(); + mSimSmsIntManager.dispose(); + mSubInfo.dispose(); + } } - + + public void removeReferences() { + this.mSimulatedRadioControl = null; + this.mStkService = null; + this.mSimPhoneBookIntManager = null; + this.mSimSmsIntManager = null; + this.mSMS = null; + this.mSubInfo = null; + this.mSIMRecords = null; + this.mIccFileHandler = null; + this.mSimCard = null; + this.mDataConnection = null; + this.mCT = null; + this.mSST = null; + } + + protected void finalize() { + if(LOCAL_DEBUG) Log.d(LOG_TAG, "GSMPhone finalized"); + } + + //***** Overridden from Phone - public ServiceState - getServiceState() - { + public ServiceState + getServiceState() { return mSST.ss; } @@ -249,15 +267,13 @@ public class GSMPhone extends PhoneBase { return mSST.cellLoc; } - public Phone.State - getState() - { + public Phone.State + getState() { return mCT.state; } public String - getPhoneName() - { + getPhoneName() { return "GSM"; } @@ -270,14 +286,12 @@ public class GSMPhone extends PhoneBase { } public int - getSignalStrengthASU() - { + getSignalStrengthASU() { return mSST.rssi == 99 ? -1 : mSST.rssi; } public boolean - getMessageWaitingIndicator() - { + getMessageWaitingIndicator() { return mSIMRecords.getVoiceMessageWaiting(); } @@ -287,8 +301,7 @@ public class GSMPhone extends PhoneBase { } public List<? extends MmiCode> - getPendingMmiCodes() - { + getPendingMmiCodes() { return mPendingMMIs; } @@ -309,27 +322,27 @@ public class GSMPhone extends PhoneBase { // but no data will flow ret = DataState.DISCONNECTED; } else { /* mSST.gprsState == ServiceState.STATE_IN_SERVICE */ - switch (mDataConnection.state) { - case FAILED: - case IDLE: - ret = DataState.DISCONNECTED; - break; + switch (mDataConnection.getState()) { + case FAILED: + case IDLE: + ret = DataState.DISCONNECTED; + break; - case CONNECTED: - case DISCONNECTING: - if ( mCT.state != Phone.State.IDLE - && !mSST.isConcurrentVoiceAndData()) { - ret = DataState.SUSPENDED; - } else { - ret = DataState.CONNECTED; - } - break; + case CONNECTED: + case DISCONNECTING: + if ( mCT.state != Phone.State.IDLE + && !mSST.isConcurrentVoiceAndData()) { + ret = DataState.SUSPENDED; + } else { + ret = DataState.CONNECTED; + } + break; - case INITING: - case CONNECTING: - case SCANNING: - ret = DataState.CONNECTING; - break; + case INITING: + case CONNECTING: + case SCANNING: + ret = DataState.CONNECTING; + break; } } @@ -340,19 +353,18 @@ public class GSMPhone extends PhoneBase { DataActivityState ret = DataActivityState.NONE; if (mSST.getCurrentGprsState() == ServiceState.STATE_IN_SERVICE) { - switch (mDataConnection.activity) { - - case DATAIN: - ret = DataActivityState.DATAIN; - break; + switch (mDataConnection.getActivity()) { + case DATAIN: + ret = DataActivityState.DATAIN; + break; - case DATAOUT: - ret = DataActivityState.DATAOUT; - break; + case DATAOUT: + ret = DataActivityState.DATAOUT; + break; - case DATAINANDOUT: - ret = DataActivityState.DATAINANDOUT; - break; + case DATAINANDOUT: + ret = DataActivityState.DATAINANDOUT; + break; } } @@ -371,15 +383,13 @@ public class GSMPhone extends PhoneBase { * changes to call state (including Phone and Connection changes). */ /*package*/ void - notifyCallStateChanged() - { + notifyCallStateChanged() { /* we'd love it if this was package-scoped*/ super.notifyCallStateChangedP(); } /*package*/ void - notifyNewRingingConnection(Connection c) - { + notifyNewRingingConnection(Connection c) { /* we'd love it if this was package-scoped*/ super.notifyNewRingingConnectionP(c); } @@ -387,28 +397,26 @@ public class GSMPhone extends PhoneBase { /** * Notifiy registrants of a RING event. */ - void notifyIncomingRing() { + void notifyIncomingRing() { AsyncResult ar = new AsyncResult(null, this, null); mIncomingRingRegistrants.notifyRegistrants(ar); } - + /*package*/ void - notifyDisconnect(Connection cn) - { + notifyDisconnect(Connection cn) { mDisconnectRegistrants.notifyResult(cn); } void notifyUnknownConnection() { mUnknownConnectionRegistrants.notifyResult(this); } - + void notifySuppServiceFailed(SuppService code) { mSuppServiceFailedRegistrants.notifyResult(code); } /*package*/ void - notifyServiceStateChanged(ServiceState ss) - { + notifyServiceStateChanged(ServiceState ss) { super.notifyServiceStateChangedP(ss); } @@ -418,55 +426,38 @@ public class GSMPhone extends PhoneBase { } /*package*/ void - notifySignalStrength() - { + notifySignalStrength() { mNotifier.notifySignalStrength(this); } /*package*/ void - notifyDataConnection(String reason) { - mNotifier.notifyDataConnection(this, reason); - } - - /*package*/ void notifyDataConnectionFailed(String reason) { mNotifier.notifyDataConnectionFailed(this, reason); } /*package*/ void - notifyDataActivity() { - mNotifier.notifyDataActivity(this); - } - - /*package*/ void - updateMessageWaitingIndicator(boolean mwi) - { + updateMessageWaitingIndicator(boolean mwi) { // this also calls notifyMessageWaitingIndicator() mSIMRecords.setVoiceMessageWaiting(1, mwi ? -1 : 0); } - /*package*/ void - notifyMessageWaitingIndicator() - { + public void + notifyMessageWaitingIndicator() { mNotifier.notifyMessageWaitingChanged(this); } - /*package*/ void + public void notifyCallForwardingIndicator() { mNotifier.notifyCallForwardingChanged(this); } + // override for allowing access from other classes of this package /** - * Set a system property, unless we're in unit test mode + * {@inheritDoc} */ - - /*package*/ void - setSystemProperty(String property, String value) - { - if(getUnitTestMode()) { - return; - } - SystemProperties.set(property, value); + public final void + setSystemProperty(String property, String value) { + super.setSystemProperty(property, value); } public void registerForSuppServiceNotification( @@ -480,71 +471,57 @@ public class GSMPhone extends PhoneBase { if (mSsnRegistrants.size() == 0) mCM.setSuppServiceNotifications(false, null); } - public void - acceptCall() throws CallStateException - { + public void + acceptCall() throws CallStateException { mCT.acceptCall(); } - public void - rejectCall() throws CallStateException - { + public void + rejectCall() throws CallStateException { mCT.rejectCall(); } public void - switchHoldingAndActive() throws CallStateException - { + switchHoldingAndActive() throws CallStateException { mCT.switchWaitingOrHoldingAndActive(); } - - public boolean canConference() - { + public boolean canConference() { return mCT.canConference(); } - public boolean canDial() - { + public boolean canDial() { return mCT.canDial(); } - public void conference() throws CallStateException - { + public void conference() throws CallStateException { mCT.conference(); } - public void clearDisconnected() - { - + public void clearDisconnected() { mCT.clearDisconnected(); } - public boolean canTransfer() - { + public boolean canTransfer() { return mCT.canTransfer(); } - public void explicitCallTransfer() throws CallStateException - { + public void explicitCallTransfer() throws CallStateException { mCT.explicitCallTransfer(); } - public Call - getForegroundCall() - { + public GsmCall + getForegroundCall() { return mCT.foregroundCall; } - public Call - getBackgroundCall() - { + public GsmCall + getBackgroundCall() { return mCT.backgroundCall; } - public Call - getRingingCall() - { + public GsmCall + getRingingCall() { return mCT.ringingCall; } @@ -554,7 +531,7 @@ public class GSMPhone extends PhoneBase { return false; } - if (getRingingCall().getState() != Call.State.IDLE) { + if (getRingingCall().getState() != GsmCall.State.IDLE) { if (LOCAL_DEBUG) Log.d(LOG_TAG, "MmiCode 0: rejectCall"); try { mCT.rejectCall(); @@ -563,7 +540,7 @@ public class GSMPhone extends PhoneBase { "reject failed", e); notifySuppServiceFailed(Phone.SuppService.REJECT); } - } else if (getBackgroundCall().getState() != Call.State.IDLE) { + } else if (getBackgroundCall().getState() != GsmCall.State.IDLE) { if (LOCAL_DEBUG) Log.d(LOG_TAG, "MmiCode 0: hangupWaitingOrBackground"); mCT.hangupWaitingOrBackground(); @@ -580,21 +557,21 @@ public class GSMPhone extends PhoneBase { return false; } - GSMCall call = (GSMCall) getForegroundCall(); + GsmCall call = (GsmCall) getForegroundCall(); try { if (len > 1) { char ch = dialString.charAt(1); int callIndex = ch - '0'; - if (callIndex >= 1 && callIndex <= CallTracker.MAX_CONNECTIONS) { + if (callIndex >= 1 && callIndex <= GsmCallTracker.MAX_CONNECTIONS) { if (LOCAL_DEBUG) Log.d(LOG_TAG, "MmiCode 1: hangupConnectionByIndex " + callIndex); mCT.hangupConnectionByIndex(call, callIndex); } } else { - if (call.getState() != Call.State.IDLE) { + if (call.getState() != GsmCall.State.IDLE) { if (LOCAL_DEBUG) Log.d(LOG_TAG, "MmiCode 1: hangup foreground"); //mCT.hangupForegroundResumeBackground(); @@ -622,16 +599,16 @@ public class GSMPhone extends PhoneBase { return false; } - GSMCall call = (GSMCall) getForegroundCall(); + GsmCall call = (GsmCall) getForegroundCall(); if (len > 1) { try { char ch = dialString.charAt(1); int callIndex = ch - '0'; - GSMConnection conn = mCT.getConnectionByIndex(call, callIndex); - + GsmConnection conn = mCT.getConnectionByIndex(call, callIndex); + // gsm index starts at 1, up to 5 connections in a call, - if (conn != null && callIndex >= 1 && callIndex <= CallTracker.MAX_CONNECTIONS) { + if (conn != null && callIndex >= 1 && callIndex <= GsmCallTracker.MAX_CONNECTIONS) { if (LOCAL_DEBUG) Log.d(LOG_TAG, "MmiCode 2: separate call "+ callIndex); mCT.separate(conn); @@ -647,7 +624,7 @@ public class GSMPhone extends PhoneBase { } } else { try { - if (getRingingCall().getState() != Call.State.IDLE) { + if (getRingingCall().getState() != GsmCall.State.IDLE) { if (LOCAL_DEBUG) Log.d(LOG_TAG, "MmiCode 2: accept ringing call"); mCT.acceptCall(); @@ -756,9 +733,9 @@ public class GSMPhone extends PhoneBase { } boolean isInCall() { - Call.State foregroundCallState = getForegroundCall().getState(); - Call.State backgroundCallState = getBackgroundCall().getState(); - Call.State ringingCallState = getRingingCall().getState(); + GsmCall.State foregroundCallState = getForegroundCall().getState(); + GsmCall.State backgroundCallState = getBackgroundCall().getState(); + GsmCall.State ringingCallState = getRingingCall().getState(); return (foregroundCallState.isAlive() || backgroundCallState.isAlive() || @@ -797,15 +774,15 @@ public class GSMPhone extends PhoneBase { public boolean handlePinMmi(String dialString) { GsmMmiCode mmi = GsmMmiCode.newFromDialString(dialString, this); - + if (mmi != null && mmi.isPinCommand()) { mPendingMMIs.add(mmi); mMmiRegistrants.notifyRegistrants(new AsyncResult(null, mmi, null)); mmi.processCode(); return true; } - - return false; + + return false; } public void sendUssdResponse(String ussdMessge) { @@ -814,11 +791,11 @@ public class GSMPhone extends PhoneBase { mMmiRegistrants.notifyRegistrants(new AsyncResult(null, mmi, null)); mmi.sendUssd(ussdMessge); } - + public void sendDtmf(char c) { if (!PhoneNumberUtils.is12Key(c)) { - Log.e(LOG_TAG, + Log.e(LOG_TAG, "sendDtmf called with invalid character '" + c + "'"); } else { if (mCT.state == Phone.State.OFFHOOK) { @@ -887,7 +864,7 @@ public class GSMPhone extends PhoneBase { com.android.internal.R.string.defaultVoiceMailAlphaTag).toString(); } - return ret; + return ret; } public String getDeviceId() { @@ -898,11 +875,21 @@ public class GSMPhone extends PhoneBase { return mImeiSv; } + public String getEsn() { + Log.e(LOG_TAG, "[GSMPhone] getEsn() is a CDMA method"); + return "0"; + } + + public String getMeid() { + Log.e(LOG_TAG, "[GSMPhone] getMeid() is a CDMA method"); + return "0"; + } + public String getSubscriberId() { return mSIMRecords.imsi; } - public String getSimSerialNumber() { + public String getIccSerialNumber() { return mSIMRecords.iccid; } @@ -939,37 +926,35 @@ public class GSMPhone extends PhoneBase { private boolean isValidCommandInterfaceCFReason (int commandInterfaceCFReason) { switch (commandInterfaceCFReason) { - case CF_REASON_UNCONDITIONAL: - case CF_REASON_BUSY: - case CF_REASON_NO_REPLY: - case CF_REASON_NOT_REACHABLE: - case CF_REASON_ALL: - case CF_REASON_ALL_CONDITIONAL: - return true; - default: - return false; + case CF_REASON_UNCONDITIONAL: + case CF_REASON_BUSY: + case CF_REASON_NO_REPLY: + case CF_REASON_NOT_REACHABLE: + case CF_REASON_ALL: + case CF_REASON_ALL_CONDITIONAL: + return true; + default: + return false; } } private boolean isValidCommandInterfaceCFAction (int commandInterfaceCFAction) { switch (commandInterfaceCFAction) { - case CF_ACTION_DISABLE: - case CF_ACTION_ENABLE: - case CF_ACTION_REGISTRATION: - case CF_ACTION_ERASURE: - return true; - default: - return false; + case CF_ACTION_DISABLE: + case CF_ACTION_ENABLE: + case CF_ACTION_REGISTRATION: + case CF_ACTION_ERASURE: + return true; + default: + return false; } } - - private boolean isCfEnable(int action) { + + protected boolean isCfEnable(int action) { return (action == CF_ACTION_ENABLE) || (action == CF_ACTION_REGISTRATION); } - - public void getCallForwardingOption(int commandInterfaceCFReason, - Message onComplete) { - + + public void getCallForwardingOption(int commandInterfaceCFReason, Message onComplete) { if (isValidCommandInterfaceCFReason(commandInterfaceCFReason)) { if (LOCAL_DEBUG) Log.d(LOG_TAG, "requesting call forwarding query."); Message resp; @@ -983,14 +968,13 @@ public class GSMPhone extends PhoneBase { } public void setCallForwardingOption(int commandInterfaceCFAction, - int commandInterfaceCFReason, - String dialingNumber, - int timerSeconds, - Message onComplete) { - - if ((isValidCommandInterfaceCFAction(commandInterfaceCFAction)) && - (isValidCommandInterfaceCFReason(commandInterfaceCFReason))) { - + int commandInterfaceCFReason, + String dialingNumber, + int timerSeconds, + Message onComplete) { + if ( (isValidCommandInterfaceCFAction(commandInterfaceCFAction)) && + (isValidCommandInterfaceCFReason(commandInterfaceCFReason))) { + Message resp; if (commandInterfaceCFReason == CF_REASON_UNCONDITIONAL) { resp = h.obtainMessage(EVENT_SET_CALL_FORWARD_DONE, @@ -1006,12 +990,12 @@ public class GSMPhone extends PhoneBase { resp); } } - + public void getOutgoingCallerIdDisplay(Message onComplete) { mCM.getCLIR(onComplete); } - - public void setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode, + + public void setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode, Message onComplete) { mCM.setCLIR(commandInterfaceCLIRMode, h.obtainMessage(EVENT_SET_CLIR_COMPLETE, commandInterfaceCLIRMode, 0, onComplete)); @@ -1020,162 +1004,111 @@ public class GSMPhone extends PhoneBase { public void getCallWaiting(Message onComplete) { mCM.queryCallWaiting(CommandsInterface.SERVICE_CLASS_VOICE, onComplete); } - + public void setCallWaiting(boolean enable, Message onComplete) { mCM.setCallWaiting(enable, CommandsInterface.SERVICE_CLASS_VOICE, onComplete); } - + public boolean - getSimRecordsLoaded() { + getIccRecordsLoaded() { return mSIMRecords.getRecordsLoaded(); } - public SimCard - getSimCard() { + public IccCard getIccCard() { return mSimCard; } - public void + public void getAvailableNetworks(Message response) { mCM.getAvailableNetworks(response); } /** - * Small container class used to hold information relevant to + * Small container class used to hold information relevant to * the carrier selection process. operatorNumeric can be "" - * if we are looking for automatic selection. + * if we are looking for automatic selection. */ private static class NetworkSelectMessage { public Message message; public String operatorNumeric; } - - public void + + public void setNetworkSelectionModeAutomatic(Message response) { // wrap the response message in our own message along with - // an empty string (to indicate automatic selection) for the + // an empty string (to indicate automatic selection) for the // operator's id. NetworkSelectMessage nsm = new NetworkSelectMessage(); nsm.message = response; nsm.operatorNumeric = ""; - + // get the message Message msg = h.obtainMessage(EVENT_SET_NETWORK_AUTOMATIC_COMPLETE, nsm); - if (LOCAL_DEBUG) + if (LOCAL_DEBUG) Log.d(LOG_TAG, "wrapping and sending message to connect automatically"); mCM.setNetworkSelectionModeAutomatic(msg); } - public void + public void selectNetworkManually(com.android.internal.telephony.gsm.NetworkInfo network, - Message response) { + Message response) { // wrap the response message in our own message along with // the operator's id. NetworkSelectMessage nsm = new NetworkSelectMessage(); nsm.message = response; nsm.operatorNumeric = network.operatorNumeric; - + // get the message Message msg = h.obtainMessage(EVENT_SET_NETWORK_MANUAL_COMPLETE, nsm); mCM.setNetworkSelectionModeManual(network.operatorNumeric, msg); } - - /** - * Method to retrieve the saved operator id from the Shared Preferences - */ - private String getSavedNetworkSelection() { - // open the shared preferences and search with our key. - SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); - return sp.getString(NETWORK_SELECTION_KEY, ""); - } - - /** - * Method to restore the previously saved operator id, or reset to - * automatic selection, all depending upon the value in the shared - * preferences. - */ - void restoreSavedNetworkSelection(Message response) { - // retrieve the operator id - String networkSelection = getSavedNetworkSelection(); - - // set to auto if the id is empty, otherwise select the network. - if (TextUtils.isEmpty(networkSelection)) { - mCM.setNetworkSelectionModeAutomatic(response); - } else { - mCM.setNetworkSelectionModeManual(networkSelection, response); - } - } - - public void - setPreferredNetworkType(int networkType, Message response) { - mCM.setPreferredNetworkType(networkType, response); - } - - public void - getPreferredNetworkType(Message response) { - mCM.getPreferredNetworkType(response); - } public void getNeighboringCids(Message response) { mCM.getNeighboringCids(response); } - - public void setOnPostDialCharacter(Handler h, int what, Object obj) - { + + public void setOnPostDialCharacter(Handler h, int what, Object obj) { mPostDialHandler = new Registrant(h, what, obj); } - - public void setMute(boolean muted) - { + public void setMute(boolean muted) { mCT.setMute(muted); } - - public boolean getMute() - { - return mCT.getMute(); - } - - public void invokeOemRilRequestRaw(byte[] data, Message response) - { - mCM.invokeOemRilRequestRaw(data, response); - } - - public void invokeOemRilRequestStrings(String[] strings, Message response) - { - mCM.invokeOemRilRequestStrings(strings, response); + public boolean getMute() { + return mCT.getMute(); } + /** + * @deprecated + */ public void getPdpContextList(Message response) { - mCM.getPDPContextList(response); + getDataCallList(response); } - public List<PdpConnection> getCurrentPdpList () { - return mDataConnection.getAllPdps(); + public void getDataCallList(Message response) { + mCM.getDataCallList(response); } /** - * Disables the DNS check (i.e., allows "0.0.0.0"). - * Useful for lab testing environment. - * @param b true disables the check, false enables. + * @deprecated */ - public void disableDnsCheck(boolean b) { - mDnsCheckDisabled = b; - SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); - SharedPreferences.Editor editor = sp.edit(); - editor.putBoolean(DNS_SERVER_CHECK_DISABLED_KEY, b); - editor.commit(); + public List<PdpConnection> getCurrentPdpList() { + ArrayList<DataConnection> connections = new ArrayList<DataConnection>(); + ArrayList<PdpConnection> pdp_list = new ArrayList<PdpConnection>(); + + for(int n = 0; n < connections.size(); n++) { + pdp_list.add((PdpConnection) connections.get(n)); + } + + return pdp_list; } - /** - * Returns true if the DNS check is currently disabled. - */ - public boolean isDnsCheckDisabled() { - return mDnsCheckDisabled; + public List<DataConnection> getCurrentDataConnectionList () { + return mDataConnection.getAllDataConnections(); } public void updateServiceLocation(Message response) { @@ -1190,14 +1123,6 @@ public class GSMPhone extends PhoneBase { mSST.disableLocationUpdates(); } - public void setBandMode(int bandMode, Message response) { - mCM.setBandMode(bandMode, response); - } - - public void queryAvailableBandMode(Message response) { - mCM.queryAvailableBandMode(response); - } - public boolean getDataRoamingEnabled() { return mDataConnection.getDataOnRoamingEnabled(); } @@ -1254,7 +1179,7 @@ public class GSMPhone extends PhoneBase { // check for "default"? boolean noData = mDataConnection.getDataEnabled() && getDataConnectionState() == DataState.DISCONNECTED; - return !noData && getSimCard().getState() == SimCard.State.READY && + return !noData && getIccCard().getState() == SimCard.State.READY && getServiceState().getState() == ServiceState.STATE_IN_SERVICE && (mDataConnection.getDataOnRoamingEnabled() || !getServiceState().getRoaming()); } @@ -1265,9 +1190,8 @@ public class GSMPhone extends PhoneBase { * @param mmi MMI that is done */ /*package*/ void - onMMIDone(GsmMmiCode mmi) - { - /* Only notify complete if it's on the pending list. + onMMIDone(GsmMmiCode mmi) { + /* Only notify complete if it's on the pending list. * Otherwise, it's already been handled (eg, previously canceled). * The exception is cancellation of an incoming USSD-REQUEST, which is * not on the list. @@ -1279,9 +1203,8 @@ public class GSMPhone extends PhoneBase { } - private void - onNetworkInitiatedUssd(GsmMmiCode mmi) - { + private void + onNetworkInitiatedUssd(GsmMmiCode mmi) { mMmiCompleteRegistrants.notifyRegistrants( new AsyncResult(null, mmi, null)); } @@ -1289,18 +1212,17 @@ public class GSMPhone extends PhoneBase { /** ussdMode is one of CommandsInterface.USSD_MODE_* */ private void - onIncomingUSSD (int ussdMode, String ussdMessage) - { + onIncomingUSSD (int ussdMode, String ussdMessage) { boolean isUssdError; boolean isUssdRequest; - - isUssdRequest + + isUssdRequest = (ussdMode == CommandsInterface.USSD_MODE_REQUEST); - isUssdError + isUssdError = (ussdMode != CommandsInterface.USSD_MODE_NOTIFY && ussdMode != CommandsInterface.USSD_MODE_REQUEST); - + // See comments in GsmMmiCode.java // USSD requests aren't finished until one // of these two events happen @@ -1327,7 +1249,7 @@ public class GSMPhone extends PhoneBase { // also, discard if there is no message to present if (!isUssdError && ussdMessage != null) { GsmMmiCode mmi; - mmi = GsmMmiCode.newNetworkInitiatedUssd(ussdMessage, + mmi = GsmMmiCode.newNetworkInitiatedUssd(ussdMessage, isUssdRequest, GSMPhone.this); onNetworkInitiatedUssd(mmi); @@ -1338,7 +1260,7 @@ public class GSMPhone extends PhoneBase { /** * Make sure the network knows our preferred setting. */ - private void syncClirSetting() { + protected void syncClirSetting() { SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); int clirSetting = sp.getInt(CLIR_KEY, -1); if (clirSetting >= 0) { @@ -1348,20 +1270,16 @@ public class GSMPhone extends PhoneBase { //***** Inner Classes - class MyHandler extends Handler - { - MyHandler() - { + class MyHandler extends Handler { + MyHandler() { } - MyHandler(Looper l) - { + MyHandler(Looper l) { super(l); } public void - handleMessage (Message msg) - { + handleMessage (Message msg) { AsyncResult ar; Message onComplete; @@ -1422,11 +1340,10 @@ public class GSMPhone extends PhoneBase { if (ar.exception != null) { break; } - + mImeiSv = (String)ar.result; break; - case EVENT_USSD: ar = (AsyncResult)msg.obj; @@ -1441,7 +1358,7 @@ public class GSMPhone extends PhoneBase { } break; - case EVENT_RADIO_OFF_OR_NOT_AVAILABLE: + case EVENT_RADIO_OFF_OR_NOT_AVAILABLE: // Some MMI requests (eg USSD) are not completed // within the course of a CommandsInterface request // If the radio shuts off or resets while one of these @@ -1450,10 +1367,10 @@ public class GSMPhone extends PhoneBase { for (int i = 0, s = mPendingMMIs.size() ; i < s; i++) { if (mPendingMMIs.get(i).isPendingUSSD()) { mPendingMMIs.get(i).onUssdFinishedError(); - } + } } break; - + case EVENT_SSN: ar = (AsyncResult)msg.obj; SuppServiceNotification not = (SuppServiceNotification) ar.result; @@ -1474,7 +1391,7 @@ public class GSMPhone extends PhoneBase { case EVENT_SET_VM_NUMBER_DONE: ar = (AsyncResult)msg.obj; - if (SimVmNotSupportedException.class.isInstance(ar.exception)) { + if (IccVmNotSupportedException.class.isInstance(ar.exception)) { storeVoiceMailNumber(mVmNumber); ar.exception = null; } @@ -1497,15 +1414,15 @@ public class GSMPhone extends PhoneBase { onComplete.sendToTarget(); } break; - + case EVENT_CALL_RING: ar = (AsyncResult)msg.obj; if (ar.exception == null) { notifyIncomingRing(); } break; - - // handle the select network completion callbacks. + + // handle the select network completion callbacks. case EVENT_SET_NETWORK_MANUAL_COMPLETE: case EVENT_SET_NETWORK_AUTOMATIC_COMPLETE: handleSetSelectNetwork((AsyncResult) msg.obj); @@ -1550,29 +1467,29 @@ public class GSMPhone extends PhoneBase { * Used to track the settings upon completion of the network change. */ private void handleSetSelectNetwork(AsyncResult ar) { - // look for our wrapper within the asyncresult, skip the rest if it - // is null. + // look for our wrapper within the asyncresult, skip the rest if it + // is null. if (!(ar.userObj instanceof NetworkSelectMessage)) { if (LOCAL_DEBUG) Log.d(LOG_TAG, "unexpected result from user object."); return; } - + NetworkSelectMessage nsm = (NetworkSelectMessage) ar.userObj; - + // found the object, now we send off the message we had originally - // attached to the request. + // attached to the request. if (nsm.message != null) { if (LOCAL_DEBUG) Log.d(LOG_TAG, "sending original message to recipient"); AsyncResult.forMessage(nsm.message, ar.result, ar.exception); nsm.message.sendToTarget(); } - + // open the shared preferences editor, and write the value. // nsm.operatorNumeric is "" if we're in automatic.selection. SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); SharedPreferences.Editor editor = sp.edit(); editor.putString(NETWORK_SELECTION_KEY, nsm.operatorNumeric); - + // commit and log the result. if (! editor.commit()) { Log.e(LOG_TAG, "failed to commit network selection preference"); @@ -1584,17 +1501,16 @@ public class GSMPhone extends PhoneBase { * Saves CLIR setting so that we can re-apply it as necessary * (in case the RIL resets it across reboots). */ - /* package */ void saveClirSetting(int commandInterfaceCLIRMode) { + public void saveClirSetting(int commandInterfaceCLIRMode) { // open the shared preferences editor, and write the value. SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getContext()); SharedPreferences.Editor editor = sp.edit(); editor.putInt(CLIR_KEY, commandInterfaceCLIRMode); - + // commit and log the result. if (! editor.commit()) { Log.e(LOG_TAG, "failed to commit CLIR preference"); } - } private void handleCfuQueryResult(CallForwardInfo[] infos) { @@ -1618,7 +1534,7 @@ public class GSMPhone extends PhoneBase { * simulates various data connection states. This messes with * DataConnectionTracker's internal states, but doesn't actually change * the underlying radio connection states. - * + * * @param state Phone.DataState enum. */ public void simulateDataConnection(Phone.DataState state) { @@ -1642,4 +1558,52 @@ public class GSMPhone extends PhoneBase { mDataConnection.setState(dcState); notifyDataConnection(null); } + + /** + * Retrieves the PhoneSubInfo of the GSMPhone + */ + public PhoneSubInfo getPhoneSubInfo(){ + return mSubInfo; + } + + /** + * Retrieves the IccSmsInterfaceManager of the GSMPhone + */ + public IccSmsInterfaceManager getIccSmsInterfaceManager(){ + return mSimSmsIntManager; + } + + /** + * Retrieves the IccPhoneBookInterfaceManager of the GSMPhone + */ + public IccPhoneBookInterfaceManager getIccPhoneBookInterfaceManager(){ + return mSimPhoneBookIntManager; + } + + /** + * {@inheritDoc} + */ + public Handler getHandler(){ + return h; + } + + /** + * {@inheritDoc} + */ + public IccFileHandler getIccFileHandler(){ + return this.mIccFileHandler; + } + + public void activateCellBroadcastSms(int activate, Message response) { + Log.e(LOG_TAG, "Error! This functionality is not implemented for GSM."); + } + + public void getCellBroadcastSmsConfig(Message response) { + Log.e(LOG_TAG, "Error! This functionality is not implemented for GSM."); + } + + public void setCellBroadcastSmsConfig(int[] configValuesArray, Message response){ + Log.e(LOG_TAG, "Error! This functionality is not implemented for GSM."); + } + } diff --git a/telephony/java/com/android/internal/telephony/gsm/GSMCall.java b/telephony/java/com/android/internal/telephony/gsm/GsmCall.java index 4feaf21..a92e52d 100644 --- a/telephony/java/com/android/internal/telephony/gsm/GSMCall.java +++ b/telephony/java/com/android/internal/telephony/gsm/GsmCall.java @@ -15,26 +15,30 @@ */ package com.android.internal.telephony.gsm; -import com.android.internal.telephony.*; + +import com.android.internal.telephony.Call; +import com.android.internal.telephony.CallStateException; +import com.android.internal.telephony.Connection; +import com.android.internal.telephony.DriverCall; +import com.android.internal.telephony.Phone; + import java.util.ArrayList; import java.util.List; /** * {@hide} */ -class GSMCall extends Call -{ +class GsmCall extends Call { /*************************** Instance Variables **************************/ /*package*/ ArrayList<Connection> connections = new ArrayList<Connection>(); - /*package*/ State state = State.IDLE; - /*package*/ CallTracker owner; + /*package*/ GsmCallTracker owner; + /***************************** Class Methods *****************************/ static State - stateFromDCState (DriverCall.State dcState) - { + stateFromDCState (DriverCall.State dcState) { switch (dcState) { case ACTIVE: return State.ACTIVE; case HOLDING: return State.HOLDING; @@ -45,40 +49,33 @@ class GSMCall extends Call default: throw new RuntimeException ("illegal call state:" + dcState); } } - + /****************************** Constructors *****************************/ /*package*/ - GSMCall (CallTracker owner) - { + GsmCall (GsmCallTracker owner) { this.owner = owner; } + public void dispose() { + } + /************************** Overridden from Call *************************/ public List<Connection> - getConnections() - { + getConnections() { // FIXME should return Collections.unmodifiableList(); return connections; } - public State - getState() - { - return state; - } - - public Phone - getPhone() - { + public Phone + getPhone() { //TODO return null; } public boolean - isMultiparty() - { + isMultiparty() { return connections.size() > 1; } @@ -86,66 +83,60 @@ class GSMCall extends Call * background call exists, the background call will be resumed * because an AT+CHLD=1 will be sent */ - public void - hangup() throws CallStateException - { + public void + hangup() throws CallStateException { owner.hangup(this); } public String - toString() - { + toString() { return state.toString(); } - //***** Called from GSMConnection + //***** Called from GsmConnection /*package*/ void - attach(GSMConnection conn, DriverCall dc) - { + attach(Connection conn, DriverCall dc) { connections.add(conn); state = stateFromDCState (dc.state); } /*package*/ void - attachFake(GSMConnection conn, State state) - { + attachFake(Connection conn, State state) { connections.add(conn); this.state = state; } /** - * Called by GSMConnection when it has disconnected + * Called by GsmConnection when it has disconnected */ void - connectionDisconnected(GSMConnection conn) - { + connectionDisconnected(GsmConnection conn) { if (state != State.DISCONNECTED) { /* If only disconnected connections remain, we are disconnected*/ boolean hasOnlyDisconnectedConnections = true; - + for (int i = 0, s = connections.size() ; i < s; i ++) { - if (connections.get(i).getState() + if (connections.get(i).getState() != State.DISCONNECTED ) { hasOnlyDisconnectedConnections = false; break; - } + } } if (hasOnlyDisconnectedConnections) { - state = State.DISCONNECTED; + state = State.DISCONNECTED; } - } + } } /*package*/ void - detach(GSMConnection conn) - { + detach(GsmConnection conn) { connections.remove(conn); if (connections.size() == 0) { @@ -154,13 +145,12 @@ class GSMCall extends Call } /*package*/ boolean - update (GSMConnection conn, DriverCall dc) - { + update (GsmConnection conn, DriverCall dc) { State newState; boolean changed = false; - + newState = stateFromDCState(dc.state); - + if (newState != state) { state = newState; changed = true; @@ -174,44 +164,41 @@ class GSMCall extends Call * connections to be added via "conference" */ /*package*/ boolean - isFull() - { - return connections.size() == CallTracker.MAX_CONNECTIONS_PER_CALL; + isFull() { + return connections.size() == GsmCallTracker.MAX_CONNECTIONS_PER_CALL; } - //***** Called from CallTracker + //***** Called from GsmCallTracker - /** + /** * Called when this Call is being hung up locally (eg, user pressed "end") * Note that at this point, the hangup request has been dispatched to the radio * but no response has yet been received so update() has not yet been called */ void - onHangupLocal() - { + onHangupLocal() { for (int i = 0, s = connections.size() ; i < s; i++ ) { - GSMConnection cn = (GSMConnection)connections.get(i); + GsmConnection cn = (GsmConnection)connections.get(i); cn.onHangupLocal(); } } - + /** * Called when it's time to clean up disconnected Connection objects */ void - clearDisconnected() - { + clearDisconnected() { for (int i = connections.size() - 1 ; i >= 0 ; i--) { - GSMConnection cn = (GSMConnection)connections.get(i); - + GsmConnection cn = (GsmConnection)connections.get(i); + if (cn.getState() == State.DISCONNECTED) { connections.remove(i); } - } + } if (connections.size() == 0) { state = State.IDLE; diff --git a/telephony/java/com/android/internal/telephony/gsm/CallTracker.java b/telephony/java/com/android/internal/telephony/gsm/GsmCallTracker.java index 2d716bb..5c5090f 100644 --- a/telephony/java/com/android/internal/telephony/gsm/CallTracker.java +++ b/telephony/java/com/android/internal/telephony/gsm/GsmCallTracker.java @@ -16,37 +16,34 @@ package com.android.internal.telephony.gsm; -import static com.android.internal.telephony.TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE; -import static com.android.internal.telephony.gsm.ServiceStateTracker.DATA_ACCESS_EDGE; -import static com.android.internal.telephony.gsm.ServiceStateTracker.DATA_ACCESS_GPRS; -import static com.android.internal.telephony.gsm.ServiceStateTracker.DATA_ACCESS_UMTS; -import static com.android.internal.telephony.gsm.ServiceStateTracker.DATA_ACCESS_UNKNOWN; -import android.os.AsyncResult; -import android.os.Handler; -import android.os.Message; -import android.os.Registrant; -import android.os.RegistrantList; -import android.os.SystemProperties; +import android.os.*; +import android.telephony.gsm.GsmCellLocation; import android.telephony.PhoneNumberUtils; import android.telephony.ServiceState; import android.telephony.TelephonyManager; -import android.telephony.gsm.GsmCellLocation; import android.util.EventLog; import android.util.Log; -import com.android.internal.telephony.Call; import com.android.internal.telephony.CallStateException; +import com.android.internal.telephony.CallTracker; +import com.android.internal.telephony.CommandsInterface; import com.android.internal.telephony.Connection; +import com.android.internal.telephony.DriverCall; +import com.android.internal.telephony.gsm.CallFailCause; +import com.android.internal.telephony.gsm.GsmCall; +import com.android.internal.telephony.gsm.GsmConnection; +import com.android.internal.telephony.gsm.GSMPhone; import com.android.internal.telephony.Phone; +import com.android.internal.telephony.TelephonyEventLog; +import com.android.internal.telephony.*; -import java.util.ArrayList; import java.util.List; +import java.util.ArrayList; /** * {@hide} */ -public final class CallTracker extends Handler -{ +public final class GsmCallTracker extends CallTracker { static final String LOG_TAG = "GSM"; private static final boolean REPEAT_POLLING = false; @@ -54,59 +51,41 @@ public final class CallTracker extends Handler //***** Constants - static final int POLL_DELAY_MSEC = 250; static final int MAX_CONNECTIONS = 7; // only 7 connections allowed in GSM static final int MAX_CONNECTIONS_PER_CALL = 5; // only 5 connections allowed per call //***** Instance Variables - - GSMConnection connections[] = new GSMConnection[MAX_CONNECTIONS]; + GsmConnection connections[] = new GsmConnection[MAX_CONNECTIONS]; RegistrantList voiceCallEndedRegistrants = new RegistrantList(); RegistrantList voiceCallStartedRegistrants = new RegistrantList(); // connections dropped durin last poll - ArrayList<GSMConnection> droppedDuringPoll - = new ArrayList<GSMConnection>(MAX_CONNECTIONS); + ArrayList<GsmConnection> droppedDuringPoll + = new ArrayList<GsmConnection>(MAX_CONNECTIONS); - GSMCall ringingCall = new GSMCall(this); + GsmCall ringingCall = new GsmCall(this); // A call that is ringing or (call) waiting - GSMCall foregroundCall = new GSMCall(this); - GSMCall backgroundCall = new GSMCall(this); + GsmCall foregroundCall = new GsmCall(this); + GsmCall backgroundCall = new GsmCall(this); - GSMConnection pendingMO; + GsmConnection pendingMO; boolean hangupPendingMO; GSMPhone phone; - CommandsInterface cm; + boolean desiredMute = false; // false = mute off Phone.State state = Phone.State.IDLE; - int pendingOperations; - boolean needsPoll; - Message lastRelevantPoll; //***** Events - static final int EVENT_POLL_CALLS_RESULT = 1; - static final int EVENT_CALL_STATE_CHANGE = 2; - static final int EVENT_REPOLL_AFTER_DELAY = 3; - static final int EVENT_OPERATION_COMPLETE = 4; - static final int EVENT_GET_LAST_CALL_FAIL_CAUSE = 5; - - static final int EVENT_SWITCH_RESULT = 8; - static final int EVENT_RADIO_AVAILABLE = 9; - static final int EVENT_RADIO_NOT_AVAILABLE = 10; - static final int EVENT_CONFERENCE_RESULT = 11; - static final int EVENT_SEPARATE_RESULT = 12; - static final int EVENT_ECT_RESULT = 13; //***** Constructors - CallTracker (GSMPhone phone) - { + GsmCallTracker (GSMPhone phone) { this.phone = phone; cm = phone.mCM; @@ -116,24 +95,56 @@ public final class CallTracker extends Handler cm.registerForNotAvailable(this, EVENT_RADIO_NOT_AVAILABLE, null); } + public void dispose() { + //Unregister for all events + cm.unregisterForCallStateChanged(this); + cm.unregisterForOn(this); + cm.unregisterForNotAvailable(this); + + for(GsmConnection c : connections) { + try { + if(c != null) hangup(c); + } catch (CallStateException ex) { + Log.e(LOG_TAG, "unexpected error on hangup during dispose"); + } + } + + try { + if(pendingMO != null) hangup(pendingMO); + } catch (CallStateException ex) { + Log.e(LOG_TAG, "unexpected error on hangup during dispose"); + } + + clearDisconnected(); + } + + protected void finalize() { + Log.d(LOG_TAG, "GsmCallTracker finalized"); + } + //***** Instance Methods //***** Public Methods - public void registerForVoiceCallStarted(Handler h, int what, Object obj) - { + public void registerForVoiceCallStarted(Handler h, int what, Object obj) { Registrant r = new Registrant(h, what, obj); voiceCallStartedRegistrants.add(r); } - public void registerForVoiceCallEnded(Handler h, int what, Object obj) - { + public void unregisterForVoiceCallStarted(Handler h) { + voiceCallStartedRegistrants.remove(h); + } + + public void registerForVoiceCallEnded(Handler h, int what, Object obj) { Registrant r = new Registrant(h, what, obj); voiceCallEndedRegistrants.add(r); } + public void unregisterForVoiceCallEnded(Handler h) { + voiceCallEndedRegistrants.remove(h); + } + private void - fakeHoldForegroundBeforeDial() - { + fakeHoldForegroundBeforeDial() { List<Connection> connCopy; // We need to make a copy here, since fakeHoldBeforeDial() @@ -141,7 +152,7 @@ public final class CallTracker extends Handler connCopy = (List<Connection>) foregroundCall.connections.clone(); for (int i = 0, s = connCopy.size() ; i < s ; i++) { - GSMConnection conn = (GSMConnection)connCopy.get(i); + GsmConnection conn = (GsmConnection)connCopy.get(i); conn.fakeHoldBeforeDial(); } @@ -162,7 +173,7 @@ public final class CallTracker extends Handler // The new call must be assigned to the foreground call. // That call must be idle, so place anything that's // there on hold - if (foregroundCall.getState() == Call.State.ACTIVE) { + if (foregroundCall.getState() == GsmCall.State.ACTIVE) { // this will probably be done by the radio anyway // but the dial might fail before this happens // and we need to make sure the foreground call is clear @@ -176,12 +187,12 @@ public final class CallTracker extends Handler fakeHoldForegroundBeforeDial(); } - if (foregroundCall.getState() != Call.State.IDLE) { + if (foregroundCall.getState() != GsmCall.State.IDLE) { //we should have failed in !canDial() above before we get here throw new CallStateException("cannot dial in current state"); } - pendingMO = new GSMConnection(phone.getContext(), dialString, this, foregroundCall); + pendingMO = new GsmConnection(phone.getContext(), dialString, this, foregroundCall); hangupPendingMO = false; if (pendingMO.address == null || pendingMO.address.length() == 0 @@ -208,24 +219,22 @@ public final class CallTracker extends Handler Connection - dial (String dialString) throws CallStateException - { + dial (String dialString) throws CallStateException { return dial(dialString, CommandsInterface.CLIR_DEFAULT); } void - acceptCall () throws CallStateException - { + acceptCall () throws CallStateException { // FIXME if SWITCH fails, should retry with ANSWER // in case the active/holding call disappeared and this // is no longer call waiting - if (ringingCall.getState() == Call.State.INCOMING) { + if (ringingCall.getState() == GsmCall.State.INCOMING) { Log.i("phone", "acceptCall: incoming..."); // Always unmute when answering a new call setMute(false); cm.acceptCall(obtainCompleteMessage()); - } else if (ringingCall.getState() == Call.State.WAITING) { + } else if (ringingCall.getState() == GsmCall.State.WAITING) { setMute(false); switchWaitingOrHoldingAndActive(); } else { @@ -234,8 +243,7 @@ public final class CallTracker extends Handler } void - rejectCall () throws CallStateException - { + rejectCall () throws CallStateException { // AT+CHLD=0 means "release held or UDUB" // so if the phone isn't ringing, this could hang up held if (ringingCall.getState().isRinging()) { @@ -248,7 +256,7 @@ public final class CallTracker extends Handler void switchWaitingOrHoldingAndActive() throws CallStateException { // Should we bother with this check? - if (ringingCall.getState() == Call.State.INCOMING) { + if (ringingCall.getState() == GsmCall.State.INCOMING) { throw new CallStateException("cannot be in the incoming state"); } else { cm.switchWaitingOrHoldingAndActive( @@ -257,20 +265,17 @@ public final class CallTracker extends Handler } void - conference() throws CallStateException - { + conference() throws CallStateException { cm.conference(obtainCompleteMessage(EVENT_CONFERENCE_RESULT)); } void - explicitCallTransfer() throws CallStateException - { + explicitCallTransfer() throws CallStateException { cm.explicitCallTransfer(obtainCompleteMessage(EVENT_ECT_RESULT)); } void - clearDisconnected() - { + clearDisconnected() { internalClearDisconnected(); updatePhoneState(); @@ -278,17 +283,15 @@ public final class CallTracker extends Handler } boolean - canConference() - { - return foregroundCall.getState() == Call.State.ACTIVE - && backgroundCall.getState() == Call.State.HOLDING + canConference() { + return foregroundCall.getState() == GsmCall.State.ACTIVE + && backgroundCall.getState() == GsmCall.State.HOLDING && !backgroundCall.isFull() && !foregroundCall.isFull(); } boolean - canDial() - { + canDial() { boolean ret; int serviceState = phone.getServiceState().getState(); @@ -302,42 +305,26 @@ public final class CallTracker extends Handler } boolean - canTransfer() - { - return foregroundCall.getState() == Call.State.ACTIVE - && backgroundCall.getState() == Call.State.HOLDING; + canTransfer() { + return foregroundCall.getState() == GsmCall.State.ACTIVE + && backgroundCall.getState() == GsmCall.State.HOLDING; } //***** Private Instance Methods private void - internalClearDisconnected() - { + internalClearDisconnected() { ringingCall.clearDisconnected(); foregroundCall.clearDisconnected(); backgroundCall.clearDisconnected(); } /** - * @return true if we're idle or there's a call to getCurrentCalls() pending - * but nothing else - */ - private boolean - checkNoOperationsPending() - { - if (DBG_POLL) log("checkNoOperationsPending: pendingOperations=" + - pendingOperations); - return pendingOperations == 0; - } - - - /** * Obtain a message to use for signalling "invoke getCurrentCalls() when * this operation and all other pending operations are complete */ private Message - obtainCompleteMessage() - { + obtainCompleteMessage() { return obtainCompleteMessage(EVENT_OPERATION_COMPLETE); } @@ -346,8 +333,7 @@ public final class CallTracker extends Handler * this operation and all other pending operations are complete */ private Message - obtainCompleteMessage(int what) - { + obtainCompleteMessage(int what) { pendingOperations++; lastRelevantPoll = null; needsPoll = true; @@ -358,26 +344,8 @@ public final class CallTracker extends Handler return obtainMessage(what); } - /** - * Obtain a complete message that indicates that this operation - * does not require polling of getCurrentCalls(). However, if other - * operations that do need getCurrentCalls() are pending or are - * scheduled while this operation is pending, the invocatoin - * of getCurrentCalls() will be postponed until this - * operation is also complete. - */ - private Message - obtainNoPollCompleteMessage(int what) - { - pendingOperations++; - lastRelevantPoll = null; - return obtainMessage(what); - } - - private void - operationComplete() - { + operationComplete() { pendingOperations--; if (DBG_POLL) log("operationComplete: pendingOperations=" + @@ -388,42 +356,13 @@ public final class CallTracker extends Handler cm.getCurrentCalls(lastRelevantPoll); } else if (pendingOperations < 0) { // this should never happen - Log.e(LOG_TAG,"CallTracker.pendingOperations < 0"); + Log.e(LOG_TAG,"GsmCallTracker.pendingOperations < 0"); pendingOperations = 0; } } private void - pollCallsWhenSafe() - { - needsPoll = true; - - if (checkNoOperationsPending()) { - lastRelevantPoll = obtainMessage(EVENT_POLL_CALLS_RESULT); - cm.getCurrentCalls(lastRelevantPoll); - } - } - - private void - pollCallsAfterDelay() - { - Message msg = obtainMessage(); - - msg.what = EVENT_REPOLL_AFTER_DELAY; - sendMessageDelayed(msg, POLL_DELAY_MSEC); - } - - private boolean - isCommandExceptionRadioNotAvailable(Throwable e) - { - return e != null && e instanceof CommandException - && ((CommandException)e).getCommandError() - == CommandException.Error.RADIO_NOT_AVAILABLE; - } - - private void - updatePhoneState() - { + updatePhoneState() { Phone.State oldState = state; if (ringingCall.isRinging()) { @@ -448,9 +387,8 @@ public final class CallTracker extends Handler } } - private void - handlePollCalls(AsyncResult ar) - { + protected void + handlePollCalls(AsyncResult ar) { List polledCalls; if (ar.exception == null) { @@ -474,7 +412,7 @@ public final class CallTracker extends Handler for (int i = 0, curDC = 0, dcSize = polledCalls.size() ; i < connections.length; i++) { - GSMConnection conn = connections[i]; + GsmConnection conn = connections[i]; DriverCall dc = null; // polledCall list is sparse @@ -519,7 +457,7 @@ public final class CallTracker extends Handler return; } } else { - connections[i] = new GSMConnection(phone.getContext(), dc, this, i); + connections[i] = new GsmConnection(phone.getContext(), dc, this, i); // it's a ringing call if (connections[i].getCall() == ringingCall) { @@ -549,14 +487,14 @@ public final class CallTracker extends Handler // tracking. droppedDuringPoll.add(conn); // Dropped connections are removed from the CallTracker - // list but kept in the GSMCall list + // list but kept in the GsmCall list connections[i] = null; } else if (conn != null && dc != null && !conn.compareTo(dc)) { // Connection in CLCC response does not match what // we were tracking. Assume dropped call and new call droppedDuringPoll.add(conn); - connections[i] = new GSMConnection (phone.getContext(), dc, this, i); + connections[i] = new GsmConnection (phone.getContext(), dc, this, i); if (connections[i].getCall() == ringingCall) { newRinging = connections[i]; @@ -608,7 +546,7 @@ public final class CallTracker extends Handler // cases from the "dropped during poll" list // These cases need no "last call fail" reason for (int i = droppedDuringPoll.size() - 1; i >= 0 ; i--) { - GSMConnection conn = droppedDuringPoll.get(i); + GsmConnection conn = droppedDuringPoll.get(i); if (conn.isIncoming() && conn.getConnectTime() == 0) { // Missed or rejected call @@ -630,7 +568,7 @@ public final class CallTracker extends Handler droppedDuringPoll.remove(i); conn.onDisconnect(Connection.DisconnectCause.LOCAL); } else if (conn.cause == - Connection.DisconnectCause.INVALID_NUMBER) { + Connection.DisconnectCause.INVALID_NUMBER) { droppedDuringPoll.remove(i); conn.onDisconnect(Connection.DisconnectCause.INVALID_NUMBER); } @@ -669,14 +607,7 @@ public final class CallTracker extends Handler } private void - handleRadioAvailable() - { - pollCallsWhenSafe(); - } - - private void - handleRadioNotAvailable() - { + handleRadioNotAvailable() { // handlePollCalls will clear out its // call list when it gets the CommandException // error result from this @@ -684,8 +615,7 @@ public final class CallTracker extends Handler } private void - dumpState() - { + dumpState() { List l; Log.i(LOG_TAG,"Phone State:" + state); @@ -713,14 +643,13 @@ public final class CallTracker extends Handler } - //***** Called from GSMConnection + //***** Called from GsmConnection /*package*/ void - hangup (GSMConnection conn) throws CallStateException - { + hangup (GsmConnection conn) throws CallStateException { if (conn.owner != this) { - throw new CallStateException ("Connection " + conn - + "does not belong to CallTracker " + this); + throw new CallStateException ("GsmConnection " + conn + + "does not belong to GsmCallTracker " + this); } if (conn == pendingMO) { @@ -735,7 +664,7 @@ public final class CallTracker extends Handler } catch (CallStateException ex) { // Ignore "connection not found" // Call may have hung up already - Log.w(LOG_TAG,"CallTracker WARN: hangup() on absent connection " + Log.w(LOG_TAG,"GsmCallTracker WARN: hangup() on absent connection " + conn); } } @@ -744,11 +673,10 @@ public final class CallTracker extends Handler } /*package*/ void - separate (GSMConnection conn) throws CallStateException - { + separate (GsmConnection conn) throws CallStateException { if (conn.owner != this) { - throw new CallStateException ("Connection " + conn - + "does not belong to CallTracker " + this); + throw new CallStateException ("GsmConnection " + conn + + "does not belong to GsmCallTracker " + this); } try { cm.separateConnection (conn.getGSMIndex(), @@ -756,7 +684,7 @@ public final class CallTracker extends Handler } catch (CallStateException ex) { // Ignore "connection not found" // Call may have hung up already - Log.w(LOG_TAG,"CallTracker WARN: separate() on absent connection " + Log.w(LOG_TAG,"GsmCallTracker WARN: separate() on absent connection " + conn); } } @@ -764,24 +692,21 @@ public final class CallTracker extends Handler //***** Called from GSMPhone /*package*/ void - setMute(boolean mute) - { + setMute(boolean mute) { desiredMute = mute; cm.setMute(desiredMute, null); } /*package*/ boolean - getMute() - { + getMute() { return desiredMute; } - //***** Called from GSMCall + //***** Called from GsmCall /* package */ void - hangup (GSMCall call) throws CallStateException - { + hangup (GsmCall call) throws CallStateException { if (call.getConnections().size() == 0) { throw new CallStateException("no connections in call"); } @@ -794,7 +719,7 @@ public final class CallTracker extends Handler if (Phone.DEBUG_PHONE) { log("(foregnd) hangup dialing or alerting..."); } - hangup((GSMConnection)(call.getConnections().get(0))); + hangup((GsmConnection)(call.getConnections().get(0))); } else { hangupForegroundResumeBackground(); } @@ -808,8 +733,8 @@ public final class CallTracker extends Handler hangupWaitingOrBackground(); } } else { - throw new RuntimeException ("Call " + call + - "does not belong to CallTracker " + this); + throw new RuntimeException ("GsmCall " + call + + "does not belong to GsmCallTracker " + this); } call.onHangupLocal(); @@ -827,11 +752,11 @@ public final class CallTracker extends Handler cm.hangupForegroundResumeBackground(obtainCompleteMessage()); } - void hangupConnectionByIndex(GSMCall call, int index) + void hangupConnectionByIndex(GsmCall call, int index) throws CallStateException { int count = call.connections.size(); for (int i = 0; i < count; i++) { - GSMConnection cn = (GSMConnection)call.connections.get(i); + GsmConnection cn = (GsmConnection)call.connections.get(i); if (cn.getGSMIndex() == index) { cm.hangupConnection(index, obtainCompleteMessage()); return; @@ -841,11 +766,11 @@ public final class CallTracker extends Handler throw new CallStateException("no gsm index found"); } - void hangupAllConnections(GSMCall call) throws CallStateException{ + void hangupAllConnections(GsmCall call) throws CallStateException{ try { int count = call.connections.size(); for (int i = 0; i < count; i++) { - GSMConnection cn = (GSMConnection)call.connections.get(i); + GsmConnection cn = (GsmConnection)call.connections.get(i); cm.hangupConnection(cn.getGSMIndex(), obtainCompleteMessage()); } } catch (CallStateException ex) { @@ -854,11 +779,11 @@ public final class CallTracker extends Handler } /* package */ - GSMConnection getConnectionByIndex(GSMCall call, int index) + GsmConnection getConnectionByIndex(GsmCall call, int index) throws CallStateException { int count = call.connections.size(); for (int i = 0; i < count; i++) { - GSMConnection cn = (GSMConnection)call.connections.get(i); + GsmConnection cn = (GsmConnection)call.connections.get(i); if (cn.getGSMIndex() == index) { return cn; } @@ -884,8 +809,7 @@ public final class CallTracker extends Handler //****** Overridden from Handler public void - handleMessage (Message msg) - { + handleMessage (Message msg) { AsyncResult ar; switch (msg.what) { @@ -952,7 +876,7 @@ public final class CallTracker extends Handler for (int i = 0, s = droppedDuringPoll.size() ; i < s ; i++ ) { - GSMConnection conn = droppedDuringPoll.get(i); + GsmConnection conn = droppedDuringPoll.get(i); conn.onRemoteDisconnect(causeCode); } @@ -978,7 +902,7 @@ public final class CallTracker extends Handler } } - private void log(String msg) { - Log.d(LOG_TAG, "[CallTracker] " + msg); + protected void log(String msg) { + Log.d(LOG_TAG, "[GsmCallTracker] " + msg); } } diff --git a/telephony/java/com/android/internal/telephony/gsm/GSMConnection.java b/telephony/java/com/android/internal/telephony/gsm/GsmConnection.java index 4777892..2b2f077 100644 --- a/telephony/java/com/android/internal/telephony/gsm/GSMConnection.java +++ b/telephony/java/com/android/internal/telephony/gsm/GsmConnection.java @@ -15,39 +15,39 @@ */ package com.android.internal.telephony.gsm; -import com.android.internal.telephony.*; - import android.content.Context; +import android.os.AsyncResult; import android.os.Handler; -import android.os.PowerManager; -import android.os.Registrant; import android.os.Looper; import android.os.Message; -import android.os.AsyncResult; +import android.os.PowerManager; +import android.os.Registrant; import android.os.SystemClock; -import android.util.Log; import android.util.Config; +import android.util.Log; import android.telephony.PhoneNumberUtils; import android.telephony.ServiceState; +import com.android.internal.telephony.*; + /** * {@hide} */ -public class GSMConnection extends Connection { +public class GsmConnection extends Connection { static final String LOG_TAG = "GSM"; //***** Instance Variables - CallTracker owner; - GSMCall parent; + GsmCallTracker owner; + GsmCall parent; String address; // MAY BE NULL!!! String dialString; // outgoing calls only - String postDialString; // outgoing calls only + String postDialString; // outgoing calls only boolean isIncoming; - boolean disconnected; + boolean disconnected; - int index; // index in CallTracker.connections[], -1 if unassigned + int index; // index in GsmCallTracker.connections[], -1 if unassigned // The GSM index is 1 + this /* @@ -65,7 +65,7 @@ public class GSMConnection extends Connection { */ long connectTimeReal; long duration; - long holdingStartTime; // The time when the Connection last transitioned + long holdingStartTime; // The time when the Connection last transitioned // into HOLDING int nextPostDialChar; // index into postDialString @@ -95,8 +95,8 @@ public class GSMConnection extends Connection { MyHandler(Looper l) {super(l);} public void - handleMessage(Message msg) - { + handleMessage(Message msg) { + switch (msg.what) { case EVENT_NEXT_POST_DIAL: case EVENT_DTMF_DONE: @@ -114,11 +114,10 @@ public class GSMConnection extends Connection { /** This is probably an MT call that we first saw in a CLCC response */ /*package*/ - GSMConnection (Context context, DriverCall dc, CallTracker ct, int index) - { + GsmConnection (Context context, DriverCall dc, GsmCallTracker ct, int index) { createWakeLock(context); acquireWakeLock(); - + owner = ct; h = new MyHandler(owner.getLooper()); @@ -136,11 +135,10 @@ public class GSMConnection extends Connection { /** This is an MO call, created when dialing */ /*package*/ - GSMConnection (Context context, String dialString, CallTracker ct, GSMCall parent) - { + GsmConnection (Context context, String dialString, GsmCallTracker ct, GsmCall parent) { createWakeLock(context); acquireWakeLock(); - + owner = ct; h = new MyHandler(owner.getLooper()); @@ -155,18 +153,19 @@ public class GSMConnection extends Connection { createTime = System.currentTimeMillis(); this.parent = parent; - parent.attachFake(this, Call.State.DIALING); + parent.attachFake(this, GsmCall.State.DIALING); } - + + public void dispose() { + } + static boolean - equalsHandlesNulls (Object a, Object b) - { + equalsHandlesNulls (Object a, Object b) { return (a == null) ? (b == null) : a.equals (b); } /*package*/ boolean - compareTo(DriverCall c) - { + compareTo(DriverCall c) { // On mobile originated (MO) calls, the phone number may have changed // due to a SIM Toolkit call control modification. // @@ -178,43 +177,35 @@ public class GSMConnection extends Connection { // no control over when they begin, so we might as well String cAddress = PhoneNumberUtils.stringFromStringAndTOA(c.number, c.TOA); - return isIncoming == c.isMT && equalsHandlesNulls(address, cAddress); + return isIncoming == c.isMT && equalsHandlesNulls(address, cAddress); } public String - toString() - { + toString() { return (isIncoming ? "incoming" : "outgoing"); } - public String getAddress() - { - return address; + public String getAddress() { + return address; } - - public Call getCall() - { + public GsmCall getCall() { return parent; } - public long getCreateTime() - { + public long getCreateTime() { return createTime; } - public long getConnectTime() - { + public long getConnectTime() { return connectTime; } - public long getDisconnectTime() - { + public long getDisconnectTime() { return disconnectTime; } - public long getDurationMillis() - { + public long getDurationMillis() { if (connectTimeReal == 0) { return 0; } else if (duration == 0) { @@ -224,9 +215,8 @@ public class GSMConnection extends Connection { } } - public long getHoldDurationMillis() - { - if (getState() != Call.State.HOLDING) { + public long getHoldDurationMillis() { + if (getState() != GsmCall.State.HOLDING) { // If not holding, return 0 return 0; } else { @@ -234,52 +224,45 @@ public class GSMConnection extends Connection { } } - public DisconnectCause getDisconnectCause() - { + public DisconnectCause getDisconnectCause() { return cause; } - public boolean isIncoming() - { + public boolean isIncoming() { return isIncoming; } - public Call.State getState() - { + public GsmCall.State getState() { if (disconnected) { - return Call.State.DISCONNECTED; - } else { + return GsmCall.State.DISCONNECTED; + } else { return super.getState(); } } - public void hangup() throws CallStateException - { - if (!disconnected) { + public void hangup() throws CallStateException { + if (!disconnected) { owner.hangup(this); } else { throw new CallStateException ("disconnected"); } } - public void separate() throws CallStateException - { - if (!disconnected) { + public void separate() throws CallStateException { + if (!disconnected) { owner.separate(this); } else { throw new CallStateException ("disconnected"); } } - public PostDialState getPostDialState() - { + public PostDialState getPostDialState() { return postDialState; } - public void proceedAfterWaitChar() - { + public void proceedAfterWaitChar() { if (postDialState != PostDialState.WAIT) { - Log.w(LOG_TAG, "Connection.proceedAfterWaitChar(): Expected " + Log.w(LOG_TAG, "GsmConnection.proceedAfterWaitChar(): Expected " + "getPostDialState() to be WAIT but was " + postDialState); return; } @@ -288,10 +271,10 @@ public class GSMConnection extends Connection { processNextPostDialChar(); } - + public void proceedAfterWildChar(String str) { if (postDialState != PostDialState.WILD) { - Log.w(LOG_TAG, "Connection.proceedAfterWaitChar(): Expected " + Log.w(LOG_TAG, "GsmConnection.proceedAfterWaitChar(): Expected " + "getPostDialState() to be WILD but was " + postDialState); return; } @@ -328,38 +311,35 @@ public class GSMConnection extends Connection { postDialString = buf.toString(); nextPostDialChar = 0; if (Phone.DEBUG_PHONE) { - log("proceedAfterWildChar: new postDialString is " + + log("proceedAfterWildChar: new postDialString is " + postDialString); } processNextPostDialChar(); } } - - public void cancelPostDial() - { + + public void cancelPostDial() { setPostDialState(PostDialState.CANCELLED); } - /** + /** * Called when this Connection is being hung up locally (eg, user pressed "end") * Note that at this point, the hangup request has been dispatched to the radio - * but no response has yet been received so update() has not yet been called + * but no response has yet been received so update() has not yet been called */ void - onHangupLocal() - { + onHangupLocal() { cause = DisconnectCause.LOCAL; } DisconnectCause - disconnectCauseFromCode(int causeCode) - { + disconnectCauseFromCode(int causeCode) { /** * See 22.001 Annex F.4 for mapping of cause codes * to local tones */ - + switch (causeCode) { case CallFailCause.USER_BUSY: return DisconnectCause.BUSY; @@ -382,7 +362,7 @@ public class GSMConnection extends Connection { return DisconnectCause.FDN_BLOCKED; case CallFailCause.ERROR_UNSPECIFIED: - case CallFailCause.NORMAL_CLEARING: + case CallFailCause.NORMAL_CLEARING: default: GSMPhone phone = owner.phone; int serviceState = phone.getServiceState().getState(); @@ -391,8 +371,8 @@ public class GSMConnection extends Connection { } else if (serviceState == ServiceState.STATE_OUT_OF_SERVICE || serviceState == ServiceState.STATE_EMERGENCY_ONLY ) { return DisconnectCause.OUT_OF_SERVICE; - } else if (phone.getSimCard().getState() != GsmSimCard.State.READY) { - return DisconnectCause.SIM_ERROR; + } else if (phone.getIccCard().getState() != SimCard.State.READY) { + return DisconnectCause.ICC_ERROR; } else if (causeCode == CallFailCause.ERROR_UNSPECIFIED) { if (phone.mSST.rs.isCsRestricted()) { return DisconnectCause.CS_RESTRICTED; @@ -410,20 +390,18 @@ public class GSMConnection extends Connection { } /*package*/ void - onRemoteDisconnect(int causeCode) - { + onRemoteDisconnect(int causeCode) { onDisconnect(disconnectCauseFromCode(causeCode)); } /** Called when the radio indicates the connection has been disconnected */ /*package*/ void - onDisconnect(DisconnectCause cause) - { + onDisconnect(DisconnectCause cause) { this.cause = cause; - - if (!disconnected) { + + if (!disconnected) { index = -1; - + disconnectTime = System.currentTimeMillis(); duration = SystemClock.elapsedRealtime() - connectTimeReal; disconnected = true; @@ -434,7 +412,7 @@ public class GSMConnection extends Connection { owner.phone.notifyDisconnect(this); if (parent != null) { - parent.connectionDisconnected(this); + parent.connectionDisconnected(this); } } releaseWakeLock(); @@ -443,10 +421,10 @@ public class GSMConnection extends Connection { // Returns true if state has changed, false if nothing changed /*package*/ boolean update (DriverCall dc) { - GSMCall newParent; + GsmCall newParent; boolean changed = false; boolean wasConnectingInOrOut = isConnectingInOrOut(); - boolean wasHolding = (getState() == Call.State.HOLDING); + boolean wasHolding = (getState() == GsmCall.State.HOLDING); newParent = parentFromDCState(dc.state); @@ -484,7 +462,7 @@ public class GSMConnection extends Connection { onConnectedInOrOut(); } - if (changed && !wasHolding && (getState() == Call.State.HOLDING)) { + if (changed && !wasHolding && (getState() == GsmCall.State.HOLDING)) { // We've transitioned into HOLDING onStartedHolding(); } @@ -499,14 +477,13 @@ public class GSMConnection extends Connection { * HOLDING in the backgroundCall */ void - fakeHoldBeforeDial() - { + fakeHoldBeforeDial() { if (parent != null) { parent.detach(this); } parent = owner.backgroundCall; - parent.attachFake(this, Call.State.HOLDING); + parent.attachFake(this, GsmCall.State.HOLDING); onStartedHolding(); } @@ -552,28 +529,27 @@ public class GSMConnection extends Connection { * should be ignored */ private boolean - processPostDialChar(char c) - { + processPostDialChar(char c) { if (PhoneNumberUtils.is12Key(c)) { owner.cm.sendDtmf(c, h.obtainMessage(EVENT_DTMF_DONE)); } else if (c == PhoneNumberUtils.PAUSE) { // From TS 22.101: - // "The first occurrence of the "DTMF Control Digits Separator" - // shall be used by the ME to distinguish between the addressing + // "The first occurrence of the "DTMF Control Digits Separator" + // shall be used by the ME to distinguish between the addressing // digits (i.e. the phone number) and the DTMF digits...." if (nextPostDialChar == 1) { // The first occurrence. // We don't need to pause here, but wait for just a bit anyway - h.sendMessageDelayed(h.obtainMessage(EVENT_PAUSE_DONE), + h.sendMessageDelayed(h.obtainMessage(EVENT_PAUSE_DONE), PAUSE_DELAY_FIRST_MILLIS); } else { // It continues... - // "Upon subsequent occurrences of the separator, the UE shall - // pause again for 3 seconds (\u00B1 20 %) before sending any + // "Upon subsequent occurrences of the separator, the UE shall + // pause again for 3 seconds (\u00B1 20 %) before sending any // further DTMF digits." - h.sendMessageDelayed(h.obtainMessage(EVENT_PAUSE_DONE), + h.sendMessageDelayed(h.obtainMessage(EVENT_PAUSE_DONE), PAUSE_DELAY_MILLIS); } } else if (c == PhoneNumberUtils.WAIT) { @@ -588,9 +564,8 @@ public class GSMConnection extends Connection { } public String - getRemainingPostDialString() - { - if (postDialState == PostDialState.CANCELLED + getRemainingPostDialString() { + if (postDialState == PostDialState.CANCELLED || postDialState == PostDialState.COMPLETE || postDialString == null || postDialString.length() <= nextPostDialChar @@ -617,8 +592,7 @@ public class GSMConnection extends Connection { } private void - processNextPostDialChar() - { + processNextPostDialChar() { char c = 0; Registrant postDialHandler; @@ -655,7 +629,8 @@ public class GSMConnection extends Connection { Message notifyMessage; - if (postDialHandler != null && (notifyMessage = postDialHandler.messageForRegistrant()) != null) { + if (postDialHandler != null + && (notifyMessage = postDialHandler.messageForRegistrant()) != null) { // The AsyncResult.result is the Connection object PostDialState state = postDialState; AsyncResult ar = AsyncResult.forMessage(notifyMessage); @@ -668,14 +643,6 @@ public class GSMConnection extends Connection { //Log.v("GSM", "##### processNextPostDialChar: send msg to postDialHandler, arg1=" + c); notifyMessage.sendToTarget(); } - /* - else { - if (postDialHandler == null) - Log.v("GSM", "##### processNextPostDialChar: postDialHandler is NULL!"); - else - Log.v("GSM", "##### processNextPostDialChar: postDialHandler.messageForRegistrant() returned NULL!"); - } - */ } @@ -683,16 +650,14 @@ public class GSMConnection extends Connection { * and outgoing calls */ private boolean - isConnectingInOrOut() - { - return parent == null || parent == owner.ringingCall - || parent.state == Call.State.DIALING - || parent.state == Call.State.ALERTING; + isConnectingInOrOut() { + return parent == null || parent == owner.ringingCall + || parent.state == GsmCall.State.DIALING + || parent.state == GsmCall.State.ALERTING; } - private GSMCall - parentFromDCState (DriverCall.State state) - { + private GsmCall + parentFromDCState (DriverCall.State state) { switch (state) { case ACTIVE: case DIALING: diff --git a/telephony/java/com/android/internal/telephony/gsm/DataConnectionTracker.java b/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java index 02a6841..e2da7cb 100644 --- a/telephony/java/com/android/internal/telephony/gsm/DataConnectionTracker.java +++ b/telephony/java/com/android/internal/telephony/gsm/GsmDataConnectionTracker.java @@ -50,8 +50,12 @@ import android.text.TextUtils; import android.util.EventLog; import android.util.Log; +import com.android.internal.telephony.DataConnection; +import com.android.internal.telephony.DataConnection.FailCause; +import com.android.internal.telephony.DataConnectionTracker; import com.android.internal.telephony.Phone; -import com.android.internal.telephony.gsm.PdpConnection.PdpFailCause; +import com.android.internal.telephony.PhoneProxy; +import com.android.internal.telephony.TelephonyEventLog; import java.io.IOException; import java.util.ArrayList; @@ -59,45 +63,11 @@ import java.util.ArrayList; /** * {@hide} */ -final class DataConnectionTracker extends Handler -{ +public final class GsmDataConnectionTracker extends DataConnectionTracker { private static final String LOG_TAG = "GSM"; private static final boolean DBG = true; /** - * IDLE: ready to start data connection setup, default state - * INITING: state of issued setupDefaultPDP() but not finish yet - * CONNECTING: state of issued startPppd() but not finish yet - * SCANNING: data connection fails with one apn but other apns are available - * ready to start data connection on other apns (before INITING) - * CONNECTED: IP connection is setup - * DISCONNECTING: PdpConnection.disconnect() has been called, but PDP - * context is not yet deactivated - * FAILED: data connection fail for all apns settings - * - * getDataConnectionState() maps State to DataState - * FAILED or IDLE : DISCONNECTED - * INITING or CONNECTING or SCANNING: CONNECTING - * CONNECTED : CONNECTED or DISCONNECTING - */ - enum State { - IDLE, - INITING, - CONNECTING, - SCANNING, - CONNECTED, - DISCONNECTING, - FAILED - } - - enum Activity { - NONE, - DATAIN, - DATAOUT, - DATAINANDOUT - } - - /** * Handles changes to the APN db. */ private class ApnChangeObserver extends ContentObserver { @@ -113,20 +83,12 @@ final class DataConnectionTracker extends Handler //***** Instance Variables - GSMPhone phone; INetStatService netstat; - State state = State.IDLE; - Activity activity = Activity.NONE; - boolean netStatPollEnabled = false; // Indicates baseband will not auto-attach private boolean noAutoAttach = false; long nextReconnectDelay = RECONNECT_DELAY_INITIAL_MILLIS; - Handler mDataConnectionTracker = null; private ContentResolver mResolver; - long txPkts, rxPkts, sentSinceLastRecv; - int netStatPollPeriod; - private int mNoRecvPollCount = 0; private boolean mPingTestActive = false; // Count of PDP reset attempts; reset when we see incoming, // call reRegisterNetwork, or pingTest succeeds. @@ -156,10 +118,7 @@ final class DataConnectionTracker extends Handler /** * pdpList holds all the PDP connection, i.e. IP Link in GPRS */ - private ArrayList<PdpConnection> pdpList; - - /** CID of active PDP */ - int cidActive; + private ArrayList<DataConnection> pdpList; /** Currently requested APN type */ private String mRequestedApnType = Phone.APN_TYPE_DEFAULT; @@ -176,12 +135,6 @@ final class DataConnectionTracker extends Handler private boolean[] dataEnabled = new boolean[APN_NUM_TYPES]; - /** wifi connection status will be updated by sticky intent */ - private boolean mIsWifiConnected = false; - - /** Intent sent when the reconnect alarm fires. */ - private PendingIntent mReconnectIntent = null; - /** Is packet service restricted by network */ private boolean mIsPsRestricted = false; @@ -195,69 +148,17 @@ final class DataConnectionTracker extends Handler private static final int PDP_CONNECTION_POOL_SIZE = 1; private static final int POLL_PDP_MILLIS = 5 * 1000; - private static final int RECONNECT_DELAY_INITIAL_MILLIS = 5 * 1000; - /** Cap out with 1 hour retry interval. */ - private static final int RECONNECT_DELAY_MAX_MILLIS = 60 * 60 * 1000; - - /** Slow poll when attempting connection recovery. */ - private static final int POLL_NETSTAT_SLOW_MILLIS = 5000; - - /** Default ping deadline, in seconds. */ - private static final int DEFAULT_PING_DEADLINE = 5; - /** Default max failure count before attempting to network re-registration. */ - private static final int DEFAULT_MAX_PDP_RESET_FAIL = 3; - - /** - * After detecting a potential connection problem, this is the max number - * of subsequent polls before attempting a radio reset. At this point, - * poll interval is 5 seconds (POLL_NETSTAT_SLOW_MILLIS), so set this to - * poll for about 2 more minutes. - */ - private static final int NO_RECV_POLL_LIMIT = 24; - - // 1 sec. default polling interval when screen is on. - private static final int POLL_NETSTAT_MILLIS = 1000; - // 10 min. default polling interval when screen is off. - private static final int POLL_NETSTAT_SCREEN_OFF_MILLIS = 1000*60*10; - // 2 min for round trip time - private static final int POLL_LONGEST_RTT = 120 * 1000; - // 10 for packets without ack - private static final int NUMBER_SENT_PACKETS_OF_HANG = 10; - // how long to wait before switching back to default APN - private static final int RESTORE_DEFAULT_APN_DELAY = 1 * 60 * 1000; - // system property that can override the above value - private static final String APN_RESTORE_DELAY_PROP_NAME = "android.telephony.apn-restore"; - // represents an invalid IP address - private static final String NULL_IP = "0.0.0.0"; + //WINK:TODO: Teleca, is this really gsm specific, what about CDMA? private static final String INTENT_RECONNECT_ALARM = "com.android.internal.telephony.gprs-reconnect"; private static final String INTENT_RECONNECT_ALARM_EXTRA_REASON = "reason"; - - //***** Event Codes - static final int EVENT_DATA_SETUP_COMPLETE = 1; - static final int EVENT_RADIO_AVAILABLE = 3; - static final int EVENT_RECORDS_LOADED = 4; - static final int EVENT_TRY_SETUP_DATA = 5; - static final int EVENT_PDP_STATE_CHANGED = 6; - static final int EVENT_POLL_PDP = 7; - static final int EVENT_GET_PDP_LIST_COMPLETE = 11; - static final int EVENT_RADIO_OFF_OR_NOT_AVAILABLE = 12; - static final int EVENT_VOICE_CALL_STARTED = 14; - static final int EVENT_VOICE_CALL_ENDED = 15; - static final int EVENT_GPRS_DETACHED = 19; - static final int EVENT_LINK_STATE_CHANGED = 20; - static final int EVENT_ROAMING_ON = 21; - static final int EVENT_ROAMING_OFF = 22; - static final int EVENT_ENABLE_NEW_APN = 23; - static final int EVENT_RESTORE_DEFAULT_APN = 24; - static final int EVENT_DISCONNECT_DONE = 25; - static final int EVENT_GPRS_ATTACHED = 26; - static final int EVENT_START_NETSTAT_POLL = 27; - static final int EVENT_START_RECOVERY = 28; - static final int EVENT_APN_CHANGED = 29; - static final int EVENT_PS_RESTRICT_ENABLED = 30; - static final int EVENT_PS_RESTRICT_DISABLED = 31; + //***** Tag IDs for EventLog + private static final int EVENT_LOG_RADIO_RESET_COUNTDOWN_TRIGGERED = 50101; + private static final int EVENT_LOG_RADIO_RESET = 50102; + private static final int EVENT_LOG_PDP_RESET = 50103; + private static final int EVENT_LOG_REREGISTER_NETWORK = 50104; + private static final int EVENT_LOG_RADIO_PDP_SETUP_FAIL = 50105; static final Uri PREFERAPN_URI = Uri.parse("content://telephony/carriers/preferapn"); static final String APN_ID = "apn_id"; @@ -307,21 +208,21 @@ final class DataConnectionTracker extends Handler //***** Constructor - DataConnectionTracker(GSMPhone phone) - { - this.phone = phone; - phone.mCM.registerForAvailable (this, EVENT_RADIO_AVAILABLE, null); - phone.mCM.registerForOffOrNotAvailable(this, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null); - phone.mSIMRecords.registerForRecordsLoaded(this, EVENT_RECORDS_LOADED, null); - phone.mCM.registerForPDPStateChanged (this, EVENT_PDP_STATE_CHANGED, null); - phone.mCT.registerForVoiceCallEnded (this, EVENT_VOICE_CALL_ENDED, null); - phone.mCT.registerForVoiceCallStarted (this, EVENT_VOICE_CALL_STARTED, null); - phone.mSST.registerForGprsAttached(this, EVENT_GPRS_ATTACHED, null); - phone.mSST.registerForGprsDetached(this, EVENT_GPRS_DETACHED, null); - phone.mSST.registerForRoamingOn(this, EVENT_ROAMING_ON, null); - phone.mSST.registerForRoamingOff(this, EVENT_ROAMING_OFF, null); - phone.mSST.registerForPsRestrictedEnabled(this, EVENT_PS_RESTRICT_ENABLED, null); - phone.mSST.registerForPsRestrictedDisabled(this, EVENT_PS_RESTRICT_DISABLED, null); + GsmDataConnectionTracker(GSMPhone p) { + super(p); + + p.mCM.registerForAvailable (this, EVENT_RADIO_AVAILABLE, null); + p.mCM.registerForOffOrNotAvailable(this, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null); + p.mSIMRecords.registerForRecordsLoaded(this, EVENT_RECORDS_LOADED, null); + p.mCM.registerForDataStateChanged (this, EVENT_DATA_STATE_CHANGED, null); + p.mCT.registerForVoiceCallEnded (this, EVENT_VOICE_CALL_ENDED, null); + p.mCT.registerForVoiceCallStarted (this, EVENT_VOICE_CALL_STARTED, null); + p.mSST.registerForGprsAttached(this, EVENT_GPRS_ATTACHED, null); + p.mSST.registerForGprsDetached(this, EVENT_GPRS_DETACHED, null); + p.mSST.registerForRoamingOn(this, EVENT_ROAMING_ON, null); + p.mSST.registerForRoamingOff(this, EVENT_ROAMING_OFF, null); + p.mSST.registerForPsRestrictedEnabled(this, EVENT_PS_RESTRICT_ENABLED, null); + p.mSST.registerForPsRestrictedDisabled(this, EVENT_PS_RESTRICT_DISABLED, null); this.netstat = INetStatService.Stub.asInterface(ServiceManager.getService("netstat")); @@ -332,14 +233,14 @@ final class DataConnectionTracker extends Handler filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION); filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); - phone.getContext().registerReceiver(mIntentReceiver, filter, null, phone.h); + p.getContext().registerReceiver(mIntentReceiver, filter, null, p.h); mDataConnectionTracker = this; mResolver = phone.getContext().getContentResolver(); apnObserver = new ApnChangeObserver(); - phone.getContext().getContentResolver().registerContentObserver( + p.getContext().getContentResolver().registerContentObserver( Telephony.Carriers.CONTENT_URI, true, apnObserver); createAllPdpList(); @@ -351,6 +252,31 @@ final class DataConnectionTracker extends Handler noAutoAttach = !dataEnabled[APN_DEFAULT_ID]; } + public void dispose() { + //Unregister for all events + phone.mCM.unregisterForAvailable(this); + phone.mCM.unregisterForOffOrNotAvailable(this); + ((GSMPhone) phone).mSIMRecords.unregisterForRecordsLoaded(this); + phone.mCM.unregisterForDataStateChanged(this); + ((GSMPhone) phone).mCT.unregisterForVoiceCallEnded(this); + ((GSMPhone) phone).mCT.unregisterForVoiceCallStarted(this); + ((GSMPhone) phone).mSST.unregisterForGprsAttached(this); + ((GSMPhone) phone).mSST.unregisterForGprsDetached(this); + ((GSMPhone) phone).mSST.unregisterForRoamingOn(this); + ((GSMPhone) phone).mSST.unregisterForRoamingOff(this); + ((GSMPhone) phone).mSST.unregisterForPsRestrictedEnabled(this); + ((GSMPhone) phone).mSST.unregisterForPsRestrictedDisabled(this); + + phone.getContext().unregisterReceiver(this.mIntentReceiver); + phone.getContext().getContentResolver().unregisterContentObserver(this.apnObserver); + + destroyAllPdpList(); + } + + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "GsmDataConnectionTracker finalized"); + } + void setState(State s) { if (DBG) log ("setState: " + s); if (state != s) { @@ -375,19 +301,6 @@ final class DataConnectionTracker extends Handler } } - String getStateInString() { - switch (state) { - case IDLE: return "IDLE"; - case INITING: return "INIT"; - case CONNECTING: return "CING"; - case SCANNING: return "SCAN"; - case CONNECTED: return "CNTD"; - case DISCONNECTING: return "DING"; - case FAILED: return "FAIL"; - default: return "ERRO"; - } - } - String[] getActiveApnTypes() { String[] result; if (mActiveApn != null) { @@ -399,7 +312,7 @@ final class DataConnectionTracker extends Handler return result; } - String getActiveApnString() { + protected String getActiveApnString() { String result = null; if (mActiveApn != null) { result = mActiveApn.apn; @@ -417,7 +330,7 @@ final class DataConnectionTracker extends Handler * will be sent by the ConnectivityManager when a connection to * the APN has been established. */ - int enableApnType(String type) { + protected int enableApnType(String type) { if (!TextUtils.equals(type, Phone.APN_TYPE_MMS)) { return Phone.APN_REQUEST_FAILED; } @@ -456,7 +369,7 @@ final class DataConnectionTracker extends Handler * @param type the APN type. The only valid value currently is {@link Phone#APN_TYPE_MMS}. * @return */ - int disableApnType(String type) { + protected int disableApnType(String type) { Log.d(LOG_TAG, "disableApnType("+type+")"); if (TextUtils.equals(type, Phone.APN_TYPE_MMS)) { removeMessages(EVENT_RESTORE_DEFAULT_APN); @@ -489,16 +402,15 @@ final class DataConnectionTracker extends Handler * 2. registered to gprs service * 3. user doesn't explicitly disable data service * 4. wifi is not on - * 5. packet service is not restricted * * @return false while no data connection if all above requirements are met. */ - boolean isDataConnectionAsDesired() { + public boolean isDataConnectionAsDesired() { boolean roaming = phone.getServiceState().getRoaming(); - if (phone.mSIMRecords.getRecordsLoaded() && - phone.mSST.getCurrentGprsState() == ServiceState.STATE_IN_SERVICE && - (!roaming || getDataOnRoamingEnabled()) && + if (((GSMPhone) phone).mSIMRecords.getRecordsLoaded() && + ((GSMPhone) phone).mSST.getCurrentGprsState() == ServiceState.STATE_IN_SERVICE && + (!roaming || getDataOnRoamingEnabled()) && !mIsWifiConnected && !mIsPsRestricted ) { return (state == State.CONNECTED); @@ -571,10 +483,12 @@ final class DataConnectionTracker extends Handler return true; } return false; - } else // isEnabled && enable + } else { + // isEnabled && enable return true; + } } - + /** * Simply tear down data connections due to radio off * and don't setup again. @@ -582,7 +496,7 @@ final class DataConnectionTracker extends Handler public void cleanConnectionBeforeRadioOff() { cleanUpConnection(true, Phone.REASON_RADIO_TURNED_OFF); } - + /** * Report the current state of data connectivity (enabled or disabled) for * the default APN. @@ -602,31 +516,11 @@ final class DataConnectionTracker extends Handler return dataEnabled[APN_DEFAULT_ID] || dataEnabled[APN_MMS_ID]; } - //The data roaming setting is now located in the shared preferences. - // See if the requested preference value is the same as that stored in - // the shared values. If it is not, then update it. - public void setDataOnRoamingEnabled(boolean enabled) { - if (getDataOnRoamingEnabled() != enabled) { - Settings.Secure.putInt(phone.getContext().getContentResolver(), - Settings.Secure.DATA_ROAMING, enabled ? 1 : 0); - } - Message roamingMsg = phone.getServiceState().getRoaming() ? - obtainMessage(EVENT_ROAMING_ON) : obtainMessage(EVENT_ROAMING_OFF); - sendMessage(roamingMsg); - } - - //Retrieve the data roaming setting from the shared preferences. - public boolean getDataOnRoamingEnabled() { - try { - return Settings.Secure.getInt(phone.getContext().getContentResolver(), - Settings.Secure.DATA_ROAMING) > 0; - } catch (SettingNotFoundException snfe) { - return false; - } - } - - public ArrayList<PdpConnection> getAllPdps() { - ArrayList<PdpConnection> pdps = (ArrayList<PdpConnection>)pdpList.clone(); + /** + * Formerly this method was ArrayList<PdpConnection> getAllPdps() + */ + public ArrayList<DataConnection> getAllDataConnections() { + ArrayList<DataConnection> pdps = (ArrayList<DataConnection>)pdpList.clone(); return pdps; } @@ -640,8 +534,7 @@ final class DataConnectionTracker extends Handler * Invoked when ServiceStateTracker observes a transition from GPRS * attach to detach. */ - private void onGprsDetached() - { + protected void onGprsDetached() { /* * We presently believe it is unnecessary to tear down the PDP context * when GPRS detaches, but we should stop the network polling. @@ -663,8 +556,7 @@ final class DataConnectionTracker extends Handler } } - private boolean trySetupData(String reason) - { + private boolean trySetupData(String reason) { if (DBG) log("***trySetupData due to " + (reason == null ? "(unspecified)" : reason)); Log.d(LOG_TAG, "[DSAC DEB] " + "trySetupData with mIsPsRestricted=" + mIsPsRestricted); @@ -679,13 +571,14 @@ final class DataConnectionTracker extends Handler return true; } - int gprsState = phone.mSST.getCurrentGprsState(); + int gprsState = ((GSMPhone) phone).mSST.getCurrentGprsState(); boolean roaming = phone.getServiceState().getRoaming(); if ((state == State.IDLE || state == State.SCANNING) && (gprsState == ServiceState.STATE_IN_SERVICE || noAutoAttach) - && phone.mSIMRecords.getRecordsLoaded() - && phone.getState() == Phone.State.IDLE + && ((GSMPhone) phone).mSIMRecords.getRecordsLoaded() + && ( ((GSMPhone) phone).mSST.isConcurrentVoiceAndData() || + phone.getState() == Phone.State.IDLE ) && isDataAllowed() && !mIsPsRestricted ) { @@ -693,7 +586,7 @@ final class DataConnectionTracker extends Handler waitingApns = buildWaitingApns(); if (waitingApns.isEmpty()) { if (DBG) log("No APN found"); - notifyNoData(PdpConnection.PdpFailCause.BAD_APN); + notifyNoData(PdpConnection.FailCause.BAD_APN); return false; } else { log ("Create from allApns : " + apnListToString(allApns)); @@ -709,8 +602,8 @@ final class DataConnectionTracker extends Handler log("trySetupData: Not ready for data: " + " dataState=" + state + " gprsState=" + gprsState + - " sim=" + phone.mSIMRecords.getRecordsLoaded() + - " UMTS=" + phone.mSST.isConcurrentVoiceAndData() + + " sim=" + ((GSMPhone) phone).mSIMRecords.getRecordsLoaded() + + " UMTS=" + ((GSMPhone) phone).mSST.isConcurrentVoiceAndData() + " phoneState=" + phone.getState() + " dataEnabled=" + getAnyDataEnabled() + " roaming=" + roaming + @@ -740,7 +633,8 @@ final class DataConnectionTracker extends Handler mReconnectIntent = null; } - for (PdpConnection pdp : pdpList) { + for (DataConnection conn : pdpList) { + PdpConnection pdp = (PdpConnection) conn; if (tearDown) { Message msg = obtainMessage(EVENT_DISCONNECT_DONE, reason); pdp.disconnect(msg); @@ -762,7 +656,7 @@ final class DataConnectionTracker extends Handler * IDLE before the code below runs. If we didn't check * for that, future calls to trySetupData would fail, * and we would never get out of the DISCONNECTING state. - */ + */ if (!tearDown) { setState(State.IDLE); phone.notifyDataConnection(reason); @@ -814,8 +708,9 @@ final class DataConnectionTracker extends Handler } private PdpConnection findFreePdp() { - for (PdpConnection pdp : pdpList) { - if (pdp.getState() == PdpConnection.PdpState.INACTIVE) { + for (DataConnection conn : pdpList) { + PdpConnection pdp = (PdpConnection) conn; + if (pdp.getState() == DataConnection.State.INACTIVE) { return pdp; } } @@ -854,7 +749,7 @@ final class DataConnectionTracker extends Handler return null; } - String getIpAddress(String apnType) { + protected String getIpAddress(String apnType) { if (mActivePdp != null && (apnType == null || mActiveApn.canHandleType(apnType))) { return mActivePdp.getIpAddress(); @@ -870,7 +765,7 @@ final class DataConnectionTracker extends Handler return null; } - String[] getDnsServers(String apnType) { + protected String[] getDnsServers(String apnType) { if (mActivePdp != null && (apnType == null || mActiveApn.canHandleType(apnType))) { return mActivePdp.getDnsServers(); @@ -879,8 +774,7 @@ final class DataConnectionTracker extends Handler } private boolean - pdpStatesHasCID (ArrayList<PDPContextState> states, int cid) - { + pdpStatesHasCID (ArrayList<PDPContextState> states, int cid) { for (int i = 0, s = states.size() ; i < s ; i++) { if (states.get(i).cid == cid) return true; } @@ -889,8 +783,7 @@ final class DataConnectionTracker extends Handler } private boolean - pdpStatesHasActiveCID (ArrayList<PDPContextState> states, int cid) - { + pdpStatesHasActiveCID (ArrayList<PDPContextState> states, int cid) { for (int i = 0, s = states.size() ; i < s ; i++) { if (states.get(i).cid == cid) return states.get(i).active; } @@ -907,7 +800,7 @@ final class DataConnectionTracker extends Handler isConnected = (state != State.IDLE && state != State.FAILED); // The "current" may no longer be valid. MMS depends on this to send properly. - phone.updateCurrentCarrierInProvider(); + ((GSMPhone) phone).updateCurrentCarrierInProvider(); // TODO: It'd be nice to only do this if the changed entrie(s) // match the current operator. @@ -926,9 +819,7 @@ final class DataConnectionTracker extends Handler * via an unsolicited response (which could have happened at any * previous state */ - private void - onPdpStateChanged (AsyncResult ar, boolean explicitPoll) - { + protected void onPdpStateChanged (AsyncResult ar, boolean explicitPoll) { ArrayList<PDPContextState> pdpStates; pdpStates = (ArrayList<PDPContextState>)(ar.result); @@ -1062,9 +953,7 @@ final class DataConnectionTracker extends Handler * with certain RIL impl's/basebands * */ - private void - startPeriodicPdpPoll() - { + private void startPeriodicPdpPoll() { removeMessages(EVENT_POLL_PDP); sendMessageDelayed(obtainMessage(EVENT_POLL_PDP), POLL_PDP_MILLIS); @@ -1074,6 +963,7 @@ final class DataConnectionTracker extends Handler txPkts = -1; rxPkts = -1; sentSinceLastRecv = 0; + netStatPollPeriod = POLL_NETSTAT_MILLIS; mNoRecvPollCount = 0; } @@ -1089,16 +979,14 @@ final class DataConnectionTracker extends Handler } else { mPdpResetCount = 0; EventLog.writeEvent(TelephonyEventLog.EVENT_LOG_REREGISTER_NETWORK, sentSinceLastRecv); - phone.mSST.reRegisterNetwork(null); + ((GSMPhone) phone).mSST.reRegisterNetwork(null); } // TODO: Add increasingly drastic recovery steps, eg, // reset the radio, reset the device. } } - private void - startNetStatPoll() - { + protected void startNetStatPoll() { if (state == State.CONNECTED && mPingTestActive == false && netStatPollEnabled == false) { Log.d(LOG_TAG, "[DataConnection] Start poll NetStat"); resetPollStats(); @@ -1107,17 +995,13 @@ final class DataConnectionTracker extends Handler } } - private void - stopNetStatPoll() - { + protected void stopNetStatPoll() { netStatPollEnabled = false; removeCallbacks(mPollNetStat); Log.d(LOG_TAG, "[DataConnection] Stop poll NetStat"); } - private void - restartRadio() - { + protected void restartRadio() { Log.d(LOG_TAG, "************TURN OFF RADIO**************"); cleanUpConnection(true, Phone.REASON_RADIO_TURNED_OFF); phone.mCM.setRadioPower(false, null); @@ -1133,7 +1017,7 @@ final class DataConnectionTracker extends Handler SystemProperties.set("net.ppp.reset-by-timeout", String.valueOf(reset+1)); } - Runnable mPollNetStat = new Runnable() + private Runnable mPollNetStat = new Runnable() { public void run() { @@ -1164,7 +1048,7 @@ final class DataConnectionTracker extends Handler newActivity = Activity.DATAINANDOUT; mPdpResetCount = 0; } else if (sent > 0 && received == 0) { - if (phone.mCT.state == Phone.State.IDLE) { + if (phone.getState() == Phone.State.IDLE) { sentSinceLastRecv += sent; } else { sentSinceLastRecv = 0; @@ -1188,7 +1072,8 @@ final class DataConnectionTracker extends Handler } int watchdogTrigger = Settings.Gservices.getInt(mResolver, - Settings.Gservices.PDP_WATCHDOG_TRIGGER_PACKET_COUNT, NUMBER_SENT_PACKETS_OF_HANG); + Settings.Gservices.PDP_WATCHDOG_TRIGGER_PACKET_COUNT, + NUMBER_SENT_PACKETS_OF_HANG); if (sentSinceLastRecv >= watchdogTrigger) { // we already have NUMBER_SENT_PACKETS sent without ack @@ -1204,13 +1089,14 @@ final class DataConnectionTracker extends Handler // It's possible the PDP context went down and we weren't notified. // Start polling the context list in an attempt to recover. if (DBG) log("no DATAIN in a while; polling PDP"); - phone.mCM.getPDPContextList(obtainMessage(EVENT_GET_PDP_LIST_COMPLETE)); + phone.mCM.getDataCallList(obtainMessage(EVENT_GET_PDP_LIST_COMPLETE)); mNoRecvPollCount++; // Slow down the poll interval to let things happen netStatPollPeriod = Settings.Gservices.getInt(mResolver, - Settings.Gservices.PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS, POLL_NETSTAT_SLOW_MILLIS); + Settings.Gservices.PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS, + POLL_NETSTAT_SLOW_MILLIS); } else { if (DBG) log("Sent " + String.valueOf(sentSinceLastRecv) + " pkts since last received"); @@ -1242,7 +1128,7 @@ final class DataConnectionTracker extends Handler } } }; - + private void runPingTest () { int status = -1; try { @@ -1279,15 +1165,13 @@ final class DataConnectionTracker extends Handler * seems like it deserves an error notification. * Transient errors are ignored */ - private boolean - shouldPostNotification(PdpConnection.PdpFailCause cause) - { + private boolean shouldPostNotification(PdpConnection.FailCause cause) { boolean shouldPost = true; // TODO CHECK // if (dataLink != null) { // shouldPost = dataLink.getLastLinkExitCode() != DataLink.EXIT_OPEN_FAILED; //} - return (shouldPost && cause != PdpConnection.PdpFailCause.UNKNOWN); + return (shouldPost && cause != PdpConnection.FailCause.UNKNOWN); } /** @@ -1301,14 +1185,13 @@ final class DataConnectionTracker extends Handler boolean retry = true; if ( Phone.REASON_RADIO_TURNED_OFF.equals(reason) || - Phone.REASON_DATA_DISABLED.equals(reason) || - Phone.REASON_PS_RESTRICT_ENABLED.equals(reason)) { + Phone.REASON_DATA_DISABLED.equals(reason) ) { retry = false; } return retry; - } - - private void reconnectAfterFail(PdpFailCause lastFailCauseCode, String reason) { + } + + private void reconnectAfterFail(FailCause lastFailCauseCode, String reason) { if (state == State.FAILED) { Log.d(LOG_TAG, "PDP activate failed. Scheduling next attempt for " + (nextReconnectDelay / 1000) + "s"); @@ -1338,314 +1221,215 @@ final class DataConnectionTracker extends Handler } } - private void notifyNoData(PdpConnection.PdpFailCause lastFailCauseCode) { + private void notifyNoData(PdpConnection.FailCause lastFailCauseCode) { setState(State.FAILED); } - - private void log(String s) { - Log.d(LOG_TAG, "[DataConnectionTracker] " + s); + protected void onRecordsLoaded() { + createAllApnList(); + if (state == State.FAILED) { + cleanUpConnection(false, null); + } + sendMessage(obtainMessage(EVENT_TRY_SETUP_DATA)); } - //***** Overridden from Handler - public void - handleMessage (Message msg) - { - AsyncResult ar; - String reason = null; - - switch (msg.what) { - case EVENT_RECORDS_LOADED: - createAllApnList(); - if (state == State.FAILED) { - cleanUpConnection(false, null); - } - sendMessage(obtainMessage(EVENT_TRY_SETUP_DATA, Phone.REASON_SIM_LOADED)); - break; - - case EVENT_ENABLE_NEW_APN: - // TODO: To support simultaneous PDP contexts, this should really only call - // cleanUpConnection if it needs to free up a PdpConnection. - reason = Phone.REASON_APN_SWITCHED; - cleanUpConnection(true, reason); - break; - - case EVENT_TRY_SETUP_DATA: - if (msg.obj instanceof String) { - reason = (String)msg.obj; - } - - trySetupData(reason); - break; - - case EVENT_RESTORE_DEFAULT_APN: - if (DBG) Log.d(LOG_TAG, "Restore default APN"); - setEnabled(Phone.APN_TYPE_MMS, false); - if (!isApnTypeActive(Phone.APN_TYPE_DEFAULT)) { - cleanUpConnection(true, Phone.REASON_RESTORE_DEFAULT_APN); - mRequestedApnType = Phone.APN_TYPE_DEFAULT; - } - break; - - case EVENT_ROAMING_OFF: - trySetupData(Phone.REASON_ROAMING_OFF); - break; + protected void onEnableNewApn() { + // TODO: To support simultaneous PDP contexts, this should really only call + // cleanUpConnection if it needs to free up a PdpConnection. + cleanUpConnection(true, Phone.REASON_APN_SWITCHED); + } - case EVENT_GPRS_DETACHED: - onGprsDetached(); - break; + protected void onTrySetupData() { + trySetupData(null); + } - case EVENT_GPRS_ATTACHED: - onGprsAttached(); - break; + protected void onRestoreDefaultApn() { + if (DBG) Log.d(LOG_TAG, "Restore default APN"); + setEnabled(Phone.APN_TYPE_MMS, false); - case EVENT_ROAMING_ON: - if (getDataOnRoamingEnabled()) { - trySetupData(Phone.REASON_ROAMING_ON); - } else { - if (DBG) log("Tear down data connection on roaming."); - cleanUpConnection(true, Phone.REASON_ROAMING_ON); - } - break; + if (!isApnTypeActive(Phone.APN_TYPE_DEFAULT)) { + cleanUpConnection(true, Phone.REASON_RESTORE_DEFAULT_APN); + mRequestedApnType = Phone.APN_TYPE_DEFAULT; + } + } - case EVENT_RADIO_AVAILABLE: - if (phone.getSimulatedRadioControl() != null) { - // Assume data is connected on the simulator - // FIXME this can be improved - setState(State.CONNECTED); - phone.notifyDataConnection(null); + protected void onRoamingOff() { + trySetupData(Phone.REASON_ROAMING_OFF); + } + protected void onRoamingOn() { + if (getDataOnRoamingEnabled()) { + trySetupData(Phone.REASON_ROAMING_ON); + } else { + if (DBG) log("Tear down data connection on roaming."); + cleanUpConnection(true, Phone.REASON_ROAMING_ON); + } + } - Log.i(LOG_TAG, "We're on the simulator; assuming data is connected"); - } + protected void onRadioAvailable() { + if (phone.getSimulatedRadioControl() != null) { + // Assume data is connected on the simulator + // FIXME this can be improved + setState(State.CONNECTED); + phone.notifyDataConnection(null); - if (state != State.IDLE) { - cleanUpConnection(true, null); - } - break; + Log.i(LOG_TAG, "We're on the simulator; assuming data is connected"); + } - case EVENT_RADIO_OFF_OR_NOT_AVAILABLE: - // Make sure our reconnect delay starts at the initial value - // next time the radio comes on - nextReconnectDelay = RECONNECT_DELAY_INITIAL_MILLIS; + if (state != State.IDLE) { + cleanUpConnection(true, null); + } + } - if (phone.getSimulatedRadioControl() != null) { - // Assume data is connected on the simulator - // FIXME this can be improved - Log.i(LOG_TAG, "We're on the simulator; assuming radio off is meaningless"); - } else { - if (DBG) log("Radio is off and clean up all connection"); - // TODO: Should we reset mRequestedApnType to "default"? - cleanUpConnection(false, Phone.REASON_RADIO_TURNED_OFF); - } - break; + protected void onRadioOffOrNotAvailable() { + // Make sure our reconnect delay starts at the initial value + // next time the radio comes on + nextReconnectDelay = RECONNECT_DELAY_INITIAL_MILLIS; - case EVENT_DATA_SETUP_COMPLETE: - ar = (AsyncResult) msg.obj; - if (ar.userObj instanceof String) { - reason = (String) ar.userObj; - } + if (phone.getSimulatedRadioControl() != null) { + // Assume data is connected on the simulator + // FIXME this can be improved + Log.i(LOG_TAG, "We're on the simulator; assuming radio off is meaningless"); + } else { + if (DBG) log("Radio is off and clean up all connection"); + // TODO: Should we reset mRequestedApnType to "default"? + cleanUpConnection(false, Phone.REASON_RADIO_TURNED_OFF); + } + } - if (ar.exception == null) { - // everything is setup - - // arg1 contains CID for this PDP context - cidActive = msg.arg1; - /* - * We may have switched away from the default PDP context - * in order to enable a "special" APN (e.g., for MMS - * traffic). Set a timer to switch back and/or disable the - * special APN, so that a negligient application doesn't - * permanently prevent data connectivity. What we are - * protecting against here is not malicious apps, but - * rather an app that inadvertantly fails to reset to the - * default APN, or that dies before doing so. - */ - if (dataEnabled[APN_MMS_ID]) { - removeMessages(EVENT_RESTORE_DEFAULT_APN); - sendMessageDelayed( - obtainMessage(EVENT_RESTORE_DEFAULT_APN), - getRestoreDefaultApnDelay()); - } - if (isApnTypeActive(Phone.APN_TYPE_DEFAULT)) { - SystemProperties.set("gsm.defaultpdpcontext.active", "true"); + protected void onDataSetupComplete(AsyncResult ar) { + String reason = null; + if (ar.userObj instanceof String) { + reason = (String) ar.userObj; + } + + if (ar.exception == null) { + // everything is setup + + /* + * We may have switched away from the default PDP context + * in order to enable a "special" APN (e.g., for MMS + * traffic). Set a timer to switch back and/or disable the + * special APN, so that a negligient application doesn't + * permanently prevent data connectivity. What we are + * protecting against here is not malicious apps, but + * rather an app that inadvertantly fails to reset to the + * default APN, or that dies before doing so. + */ + if (dataEnabled[APN_MMS_ID]) { + removeMessages(EVENT_RESTORE_DEFAULT_APN); + sendMessageDelayed(obtainMessage(EVENT_RESTORE_DEFAULT_APN), + getRestoreDefaultApnDelay()); + } + if (isApnTypeActive(Phone.APN_TYPE_DEFAULT)) { + SystemProperties.set("gsm.defaultpdpcontext.active", "true"); if (canSetPreferApn && preferredApn == null) { Log.d(LOG_TAG, "PREFERED APN is null"); preferredApn = mActiveApn; setPreferredApn(preferredApn.id); } - } else { - SystemProperties.set("gsm.defaultpdpcontext.active", "false"); - } - notifyDefaultData(reason); + } else { + SystemProperties.set("gsm.defaultpdpcontext.active", "false"); + } + notifyDefaultData(reason); - // TODO: For simultaneous PDP support, we need to build another - // trigger another TRY_SETUP_DATA for the next APN type. (Note - // that the existing connection may service that type, in which - // case we should try the next type, etc. - } else { - PdpConnection.PdpFailCause cause; - cause = (PdpConnection.PdpFailCause) (ar.result); - if(DBG) - log("PDP setup failed " + cause); + // TODO: For simultaneous PDP support, we need to build another + // trigger another TRY_SETUP_DATA for the next APN type. (Note + // that the existing connection may service that type, in which + // case we should try the next type, etc. + } else { + PdpConnection.FailCause cause; + cause = (PdpConnection.FailCause) (ar.result); + if(DBG) log("PDP setup failed " + cause); // Log this failure to the Event Logs. - if (cause == PdpConnection.PdpFailCause.BAD_APN || - cause == PdpConnection.PdpFailCause.BAD_PAP_SECRET || - cause == PdpConnection.PdpFailCause.BARRED || - cause == PdpConnection.PdpFailCause.RADIO_ERROR_RETRY || - cause == PdpConnection.PdpFailCause.SUSPENED_TEMPORARY || - cause == PdpConnection.PdpFailCause.UNKNOWN || - cause == PdpConnection.PdpFailCause.USER_AUTHENTICATION) { - int cid = -1; - GsmCellLocation loc = ((GsmCellLocation)phone.getCellLocation()); - if (loc != null) cid = loc.getCid(); - - EventLog.List val = new EventLog.List( - cause.ordinal(), cid, - TelephonyManager.getDefault().getNetworkType()); - EventLog.writeEvent(TelephonyEventLog.EVENT_LOG_RADIO_PDP_SETUP_FAIL, val); - } - // No try for permanent failure - if (cause.isPermanentFail()) { - notifyNoData(cause); - } + if (cause == PdpConnection.FailCause.BAD_APN || + cause == PdpConnection.FailCause.BAD_PAP_SECRET || + cause == PdpConnection.FailCause.BARRED || + cause == PdpConnection.FailCause.RADIO_ERROR_RETRY || + cause == PdpConnection.FailCause.SUSPENED_TEMPORARY || + cause == PdpConnection.FailCause.UNKNOWN || + cause == PdpConnection.FailCause.USER_AUTHENTICATION) { + int cid = -1; + GsmCellLocation loc = ((GsmCellLocation)phone.getCellLocation()); + if (loc != null) cid = loc.getCid(); + + EventLog.List val = new EventLog.List( + cause.ordinal(), cid, + TelephonyManager.getDefault().getNetworkType()); + EventLog.writeEvent(TelephonyEventLog.EVENT_LOG_RADIO_PDP_SETUP_FAIL, val); + } - if (tryNextApn(cause)) { - waitingApns.remove(0); - if (waitingApns.isEmpty()) { - // No more to try, start delayed retry - startDelayedRetry(cause, reason); - } else { - // we still have more apns to try - setState(State.SCANNING); - // Wait a bit before trying the next APN, so that - // we're not tying up the RIL command channel - sendMessageDelayed(obtainMessage(EVENT_TRY_SETUP_DATA, reason), - RECONNECT_DELAY_INITIAL_MILLIS); - } - } else { - startDelayedRetry(cause, reason); - } - } - break; + // No try for permanent failure + if (cause.isPermanentFail()) { + notifyNoData(cause); + } - case EVENT_DISCONNECT_DONE: - if(DBG) log("EVENT_DISCONNECT_DONE"); - ar = (AsyncResult) msg.obj; - if (ar.userObj instanceof String) { - reason = (String) ar.userObj; - } - setState(State.IDLE); - phone.notifyDataConnection(reason); - mActiveApn = null; - if ( retryAfterDisconnected(reason) ) { + if (tryNextApn(cause)) { + waitingApns.remove(0); + if (waitingApns.isEmpty()) { + // No more to try, start delayed retry + startDelayedRetry(cause, reason); + } else { + // we still have more apns to try + setState(State.SCANNING); trySetupData(reason); } - break; - - case EVENT_PDP_STATE_CHANGED: - ar = (AsyncResult) msg.obj; - - onPdpStateChanged(ar, false); - break; - - case EVENT_GET_PDP_LIST_COMPLETE: - ar = (AsyncResult) msg.obj; - - onPdpStateChanged(ar, true); - break; - - case EVENT_POLL_PDP: - /* See comment in startPeriodicPdpPoll */ - ar = (AsyncResult) msg.obj; - - if (!(state == State.CONNECTED)) { - // not connected; don't poll anymore - break; - } - - phone.mCM.getPDPContextList(this.obtainMessage(EVENT_GET_PDP_LIST_COMPLETE)); + } else { + startDelayedRetry(cause, reason); + } + } + } - sendMessageDelayed(obtainMessage(EVENT_POLL_PDP), - POLL_PDP_MILLIS); - break; + protected void onDisconnectDone(AsyncResult ar) { + String reason = null; + if(DBG) log("EVENT_DISCONNECT_DONE"); + if (ar.userObj instanceof String) { + reason = (String) ar.userObj; + } + setState(State.IDLE); + phone.notifyDataConnection(reason); + mActiveApn = null; + if (retryAfterDisconnected(reason)) { + trySetupData(reason); + } + } - case EVENT_VOICE_CALL_STARTED: - if (state == State.CONNECTED && - !phone.mSST.isConcurrentVoiceAndData()) { - stopNetStatPoll(); - phone.notifyDataConnection(Phone.REASON_VOICE_CALL_STARTED); - } - break; + protected void onPollPdp() { + if (state == State.CONNECTED) { + // only poll when connected + phone.mCM.getPDPContextList(this.obtainMessage(EVENT_GET_PDP_LIST_COMPLETE)); + sendMessageDelayed(obtainMessage(EVENT_POLL_PDP), POLL_PDP_MILLIS); + } + } - case EVENT_VOICE_CALL_ENDED: - if (state == State.CONNECTED) { - if (!phone.mSST.isConcurrentVoiceAndData()) { - startNetStatPoll(); - phone.notifyDataConnection(Phone.REASON_VOICE_CALL_ENDED); - } else { - // clean slate after call end. - resetPollStats(); - } - } else { - // in case data setup was attempted when we were on a voice call - trySetupData(Phone.REASON_VOICE_CALL_ENDED); - } - break; + protected void onVoiceCallStarted() { + if (state == State.CONNECTED && !((GSMPhone) phone).mSST.isConcurrentVoiceAndData()) { + stopNetStatPoll(); + phone.notifyDataConnection(Phone.REASON_VOICE_CALL_STARTED); + } + } - case EVENT_START_NETSTAT_POLL: - mPingTestActive = false; + protected void onVoiceCallEnded() { + if (state == State.CONNECTED) { + if (!((GSMPhone) phone).mSST.isConcurrentVoiceAndData()) { startNetStatPoll(); - break; - - case EVENT_START_RECOVERY: - mPingTestActive = false; - doRecovery(); - break; - - case EVENT_APN_CHANGED: - onApnChanged(); - break; - - case EVENT_PS_RESTRICT_ENABLED: - /** - * We don't need to explicitly to tear down the PDP context - * when PS restricted is enabled. The base band will deactive - * PDP context and notify us with PDP_CONTEXT_CHANGED. - * But we should stop the network polling and prevent reset PDP. - */ - Log.d(LOG_TAG, "[DSAC DEB] " + "EVENT_PS_RESTRICT_ENABLED " + mIsPsRestricted); - stopNetStatPoll(); - mIsPsRestricted = true; - break; - - case EVENT_PS_RESTRICT_DISABLED: - /** - * When PS restrict is removed, we need setup PDP connection if - * PDP connection is down. - */ - Log.d(LOG_TAG, "[DSAC DEB] " + "EVENT_PS_RESTRICT_DISABLED " + mIsPsRestricted); - mIsPsRestricted = false; - if (state == State.CONNECTED) { - startNetStatPoll(); - } else { - if (state == State.FAILED) { - cleanUpConnection(false, Phone.REASON_PS_RESTRICT_ENABLED); - nextReconnectDelay = RECONNECT_DELAY_INITIAL_MILLIS; - } - trySetupData(Phone.REASON_PS_RESTRICT_ENABLED); - } - break; - + phone.notifyDataConnection(Phone.REASON_VOICE_CALL_ENDED); + } else { + // clean slate after call end. + resetPollStats(); + } + } else { + // in case data setup was attempted when we were on a voice call + trySetupData(Phone.REASON_VOICE_CALL_ENDED); } } - private boolean tryNextApn(PdpFailCause cause) { - return (cause != PdpFailCause.RADIO_NOT_AVIALABLE) - && (cause != PdpFailCause.RADIO_OFF) - && (cause != PdpFailCause.RADIO_ERROR_RETRY) - && (cause != PdpFailCause.NO_SIGNAL) - && (cause != PdpFailCause.SIM_LOCKED); + private boolean tryNextApn(FailCause cause) { + return (cause != FailCause.RADIO_NOT_AVAILABLE) + && (cause != FailCause.RADIO_OFF) + && (cause != FailCause.RADIO_ERROR_RETRY) + && (cause != FailCause.NO_SIGNAL) + && (cause != FailCause.SIM_LOCKED); } private int getRestoreDefaultApnDelay() { @@ -1668,7 +1452,7 @@ final class DataConnectionTracker extends Handler */ private void createAllApnList() { allApns = new ArrayList<ApnSetting>(); - String operator = phone.mSIMRecords.getSIMOperatorNumeric(); + String operator = ((GSMPhone) phone).mSIMRecords.getSIMOperatorNumeric(); if (operator != null) { String selection = "numeric = '" + operator + "'"; @@ -1694,7 +1478,7 @@ final class DataConnectionTracker extends Handler if (allApns.isEmpty()) { if (DBG) log("No APN found for carrier: " + operator); preferredApn = null; - notifyNoData(PdpConnection.PdpFailCause.BAD_APN); + notifyNoData(PdpConnection.FailCause.BAD_APN); } else { preferredApn = getPreferredApn(); Log.d(LOG_TAG, "Get PreferredAPN"); @@ -1706,15 +1490,22 @@ final class DataConnectionTracker extends Handler } private void createAllPdpList() { - pdpList = new ArrayList<PdpConnection>(); - PdpConnection pdp; + pdpList = new ArrayList<DataConnection>(); + DataConnection pdp; for (int i = 0; i < PDP_CONNECTION_POOL_SIZE; i++) { - pdp = new PdpConnection(phone); + pdp = new PdpConnection((GSMPhone) phone); pdpList.add(pdp); } } + private void destroyAllPdpList() { + if(pdpList != null) { + PdpConnection pdp; + pdpList.removeAll(pdpList); + } + } + /** * * @return waitingApns list to be used to create PDP @@ -1722,7 +1513,7 @@ final class DataConnectionTracker extends Handler */ private ArrayList<ApnSetting> buildWaitingApns() { ArrayList<ApnSetting> apnList = new ArrayList<ApnSetting>(); - String operator = phone.mSIMRecords.getSIMOperatorNumeric(); + String operator = ((GSMPhone )phone).mSIMRecords.getSIMOperatorNumeric(); if (mRequestedApnType.equals(Phone.APN_TYPE_DEFAULT)) { if (canSetPreferApn && preferredApn != null) { @@ -1775,7 +1566,7 @@ final class DataConnectionTracker extends Handler return result.toString(); } - private void startDelayedRetry(PdpConnection.PdpFailCause cause, String reason) { + private void startDelayedRetry(PdpConnection.FailCause cause, String reason) { notifyNoData(cause); if (mRequestedApnType != Phone.APN_TYPE_DEFAULT) { sendMessage(obtainMessage(EVENT_RESTORE_DEFAULT_APN)); @@ -1833,4 +1624,95 @@ final class DataConnectionTracker extends Handler return null; } + + public void handleMessage (Message msg) { + + switch (msg.what) { + case EVENT_RECORDS_LOADED: + onRecordsLoaded(); + break; + + case EVENT_ENABLE_NEW_APN: + onEnableNewApn(); + break; + + case EVENT_RESTORE_DEFAULT_APN: + onRestoreDefaultApn(); + break; + + case EVENT_GPRS_DETACHED: + onGprsDetached(); + break; + + case EVENT_GPRS_ATTACHED: + onGprsAttached(); + break; + + case EVENT_DATA_STATE_CHANGED: + onPdpStateChanged((AsyncResult) msg.obj, false); + break; + + case EVENT_GET_PDP_LIST_COMPLETE: + onPdpStateChanged((AsyncResult) msg.obj, true); + break; + + case EVENT_POLL_PDP: + onPollPdp(); + break; + + case EVENT_START_NETSTAT_POLL: + mPingTestActive = false; + startNetStatPoll(); + break; + + case EVENT_START_RECOVERY: + mPingTestActive = false; + doRecovery(); + break; + + case EVENT_APN_CHANGED: + onApnChanged(); + break; + + case EVENT_PS_RESTRICT_ENABLED: + /** + * We don't need to explicitly to tear down the PDP context + * when PS restricted is enabled. The base band will deactive + * PDP context and notify us with PDP_CONTEXT_CHANGED. + * But we should stop the network polling and prevent reset PDP. + */ + Log.d(LOG_TAG, "[DSAC DEB] " + "EVENT_PS_RESTRICT_ENABLED " + mIsPsRestricted); + stopNetStatPoll(); + mIsPsRestricted = true; + break; + + case EVENT_PS_RESTRICT_DISABLED: + /** + * When PS restrict is removed, we need setup PDP connection if + * PDP connection is down. + */ + Log.d(LOG_TAG, "[DSAC DEB] " + "EVENT_PS_RESTRICT_DISABLED " + mIsPsRestricted); + mIsPsRestricted = false; + if (state == State.CONNECTED) { + startNetStatPoll(); + } else { + if (state == State.FAILED) { + cleanUpConnection(false, Phone.REASON_PS_RESTRICT_ENABLED); + nextReconnectDelay = RECONNECT_DELAY_INITIAL_MILLIS; + } + trySetupData(Phone.REASON_PS_RESTRICT_ENABLED); + } + break; + + default: + // handle the message in the super class DataConnectionTracker + super.handleMessage(msg); + break; + } + } + + protected void log(String s) { + Log.d(LOG_TAG, "[GsmDataConnectionTracker] " + s); + } + } diff --git a/telephony/java/com/android/internal/telephony/gsm/GsmMmiCode.java b/telephony/java/com/android/internal/telephony/gsm/GsmMmiCode.java index 04f8332..4db8fc6 100644 --- a/telephony/java/com/android/internal/telephony/gsm/GsmMmiCode.java +++ b/telephony/java/com/android/internal/telephony/gsm/GsmMmiCode.java @@ -18,39 +18,40 @@ package com.android.internal.telephony.gsm; import android.content.Context; import com.android.internal.telephony.*; + import android.os.*; -import android.os.AsyncResult; +import android.telephony.PhoneNumberUtils; +import android.text.SpannableStringBuilder; +import android.text.TextUtils; import android.util.Log; + +import static com.android.internal.telephony.CommandsInterface.*; + import java.util.regex.Pattern; import java.util.regex.Matcher; -import android.text.SpannableStringBuilder; -import android.text.TextUtils; -import android.telephony.PhoneNumberUtils; -import static com.android.internal.telephony.gsm.CommandsInterface.*; /** * The motto for this file is: * - * "NOTE: By using the # as a separator, most cases are expected to be unambiguous." + * "NOTE: By using the # as a separator, most cases are expected to be unambiguous." * -- TS 22.030 6.5.2 * * {@hide} * */ -public final class GsmMmiCode extends Handler implements MmiCode -{ +public final class GsmMmiCode extends Handler implements MmiCode { static final String LOG_TAG = "GSM"; //***** Constants - + // From TS 22.030 6.5.2 static final String ACTION_ACTIVATE = "*"; static final String ACTION_DEACTIVATE = "#"; static final String ACTION_INTERROGATE = "*#"; static final String ACTION_REGISTER = "**"; static final String ACTION_ERASURE = "##"; - - // Supp Service cocdes from TS 22.030 Annex B + + // Supp Service cocdes from TS 22.030 Annex B //Called line presentation static final String SC_CLIP = "30"; @@ -102,25 +103,24 @@ public final class GsmMmiCode extends Handler implements MmiCode GSMPhone phone; Context context; - + String action; // One of ACTION_* String sc; // Service Code String sia, sib, sic; // Service Info a,b,c String poundString; // Entire MMI string up to and including # String dialingNumber; String pwd; // For password registration - - /** Set to true in processCode, not at newFromDialString time */ + /** Set to true in processCode, not at newFromDialString time */ private boolean isPendingUSSD; private boolean isUssdRequest; - State state = State.PENDING; + State state = State.PENDING; CharSequence message; - + //***** Class Variables - + // See TS 22.030 6.5.2 "Structure of the MMI" @@ -137,9 +137,9 @@ public final class GsmMmiCode extends Handler implements MmiCode 10 = dialing number */ - static final int MATCH_GROUP_POUND_STRING = 1; + static final int MATCH_GROUP_POUND_STRING = 1; - static final int MATCH_GROUP_ACTION = 2; + static final int MATCH_GROUP_ACTION = 2; //(activation/interrogation/registration/erasure) static final int MATCH_GROUP_SERVICE_CODE = 3; @@ -151,7 +151,7 @@ public final class GsmMmiCode extends Handler implements MmiCode //***** Public Class methods - + /** * Some dial strings in GSM are defined to do non-call setup * things, such as modify or query supplementry service settings (eg, call @@ -165,9 +165,8 @@ public final class GsmMmiCode extends Handler implements MmiCode * Please see flow chart in TS 22.030 6.5.3.2 */ - static GsmMmiCode - newFromDialString(String dialString, GSMPhone phone) - { + static GsmMmiCode + newFromDialString(String dialString, GSMPhone phone) { Matcher m; GsmMmiCode ret = null; @@ -187,7 +186,7 @@ public final class GsmMmiCode extends Handler implements MmiCode } else if (dialString.endsWith("#")) { // TS 22.030 sec 6.5.3.2 - // "Entry of any characters defined in the 3GPP TS 23.038 [8] Default Alphabet + // "Entry of any characters defined in the 3GPP TS 23.038 [8] Default Alphabet // (up to the maximum defined in 3GPP TS 24.080 [10]), followed by #SEND". ret = new GsmMmiCode(phone); @@ -202,16 +201,15 @@ public final class GsmMmiCode extends Handler implements MmiCode } static GsmMmiCode - newNetworkInitiatedUssd (String ussdMessage, - boolean isUssdRequest, GSMPhone phone) - { + newNetworkInitiatedUssd (String ussdMessage, + boolean isUssdRequest, GSMPhone phone) { GsmMmiCode ret; ret = new GsmMmiCode(phone); ret.message = ussdMessage; ret.isUssdRequest = isUssdRequest; - + // If it's a request, set to PENDING so that it's cancelable. if (isUssdRequest) { ret.isPendingUSSD = true; @@ -225,42 +223,39 @@ public final class GsmMmiCode extends Handler implements MmiCode static GsmMmiCode newFromUssdUserInput(String ussdMessge, GSMPhone phone) { GsmMmiCode ret = new GsmMmiCode(phone); - + ret.message = ussdMessge; ret.state = State.PENDING; ret.isPendingUSSD = true; - + return ret; } //***** Private Class methods - /** make empty strings be null. - * Regexp returns empty strings for empty groups + /** make empty strings be null. + * Regexp returns empty strings for empty groups */ private static String - makeEmptyNull (String s) - { + makeEmptyNull (String s) { if (s != null && s.length() == 0) return null; return s; } /** returns true of the string is empty or null */ - private static boolean - isEmptyOrNull(CharSequence s) - { + private static boolean + isEmptyOrNull(CharSequence s) { return s == null || (s.length() == 0); } private static int - scToCallForwardReason(String sc) - { - if (sc == null) { + scToCallForwardReason(String sc) { + if (sc == null) { throw new RuntimeException ("invalid call forward sc"); } - + if (sc.equals(SC_CF_All)) { return CommandsInterface.CF_REASON_ALL; } else if (sc.equals(SC_CFU)) { @@ -279,8 +274,7 @@ public final class GsmMmiCode extends Handler implements MmiCode } private static int - siToServiceClass(String si) - { + siToServiceClass(String si) { if (si == null || si.length() == 0) { return SERVICE_CLASS_NONE; } else { @@ -299,7 +293,7 @@ public final class GsmMmiCode extends Handler implements MmiCode /* Note for code 20: From TS 22.030 Annex C: - "All GPRS bearer services" are not included in "All tele and bearer services" + "All GPRS bearer services" are not included in "All tele and bearer services" and "All bearer services"." ....so SERVICE_CLASS_DATA, which (according to 27.007) includes GPRS */ @@ -319,8 +313,7 @@ public final class GsmMmiCode extends Handler implements MmiCode } private static int - siToTime (String si) - { + siToTime (String si) { if (si == null || si.length() == 0) { return 0; } else { @@ -330,33 +323,30 @@ public final class GsmMmiCode extends Handler implements MmiCode } static boolean - isServiceCodeCallForwarding(String sc) - { - return sc != null && - (sc.equals(SC_CFU) - || sc.equals(SC_CFB) || sc.equals(SC_CFNRy) - || sc.equals(SC_CFNR) || sc.equals(SC_CF_All) + isServiceCodeCallForwarding(String sc) { + return sc != null && + (sc.equals(SC_CFU) + || sc.equals(SC_CFB) || sc.equals(SC_CFNRy) + || sc.equals(SC_CFNR) || sc.equals(SC_CF_All) || sc.equals(SC_CF_All_Conditional)); } static boolean - isServiceCodeCallBarring(String sc) - { + isServiceCodeCallBarring(String sc) { return sc != null && - (sc.equals(SC_BAOC) + (sc.equals(SC_BAOC) || sc.equals(SC_BAOIC) || sc.equals(SC_BAOICxH) || sc.equals(SC_BAIC) || sc.equals(SC_BAICr) || sc.equals(SC_BA_ALL) || sc.equals(SC_BA_MO) - || sc.equals(SC_BA_MT)); + || sc.equals(SC_BA_MT)); } static String - scToBarringFacility(String sc) - { - if (sc == null) { + scToBarringFacility(String sc) { + if (sc == null) { throw new RuntimeException ("invalid call barring sc"); } @@ -383,11 +373,10 @@ public final class GsmMmiCode extends Handler implements MmiCode //***** Constructor - GsmMmiCode (GSMPhone phone) - { + GsmMmiCode (GSMPhone phone) { // The telephony unit-test cases may create GsmMmiCode's // in secondary threads - super(phone.h.getLooper()); + super(phone.getHandler().getLooper()); this.phone = phone; this.context = phone.getContext(); } @@ -395,21 +384,18 @@ public final class GsmMmiCode extends Handler implements MmiCode //***** MmiCode implementation public State - getState() - { + getState() { return state; } public CharSequence - getMessage() - { + getMessage() { return message; } // inherited javadoc suffices public void - cancel() - { + cancel() { // Complete or failed cannot be cancelled if (state == State.COMPLETE || state == State.FAILED) { return; @@ -423,7 +409,7 @@ public final class GsmMmiCode extends Handler implements MmiCode * cancel it. */ phone.mCM.cancelPendingUssd(obtainMessage(EVENT_USSD_CANCEL_COMPLETE, this)); - + /* * Don't call phone.onMMIDone here; wait for CANCEL_COMPLETE notice * from RIL. @@ -436,7 +422,6 @@ public final class GsmMmiCode extends Handler implements MmiCode phone.onMMIDone (this); } - } public boolean isCancelable() { @@ -445,20 +430,17 @@ public final class GsmMmiCode extends Handler implements MmiCode } //***** Instance Methods - /** Does this dial string contain a structured or unstructured MMI code? */ boolean - isMMI() - { + isMMI() { return poundString != null; } /* Is this a 1 or 2 digit "short code" as defined in TS 22.030 sec 6.5.3.2? */ boolean - isShortCode() - { - return poundString == null + isShortCode() { + return poundString == null && dialingNumber != null && dialingNumber.length() <= 2; } @@ -479,7 +461,7 @@ public final class GsmMmiCode extends Handler implements MmiCode * for treating "0" and "00" as call setup strings. */ || dialString.equals("0") - || dialString.equals("00")))); + || dialString.equals("00")))); } /** * @return true if the Service Code is PIN/PIN2/PUK/PUK2-related @@ -489,17 +471,16 @@ public final class GsmMmiCode extends Handler implements MmiCode || sc.equals(SC_PUK) || sc.equals(SC_PUK2)); } - /** + /** * *See TS 22.030 Annex B - * In temporary mode, to suppress CLIR for a single call, enter: + * In temporary mode, to suppress CLIR for a single call, enter: * " * 31 # <called number> SEND " - * In temporary mode, to invoke CLIR for a single call enter: + * In temporary mode, to invoke CLIR for a single call enter: * " # 31 # <called number> SEND " */ - - boolean - isTemporaryModeCLIR() - { + + boolean + isTemporaryModeCLIR() { return sc != null && sc.equals(SC_CLIR) && dialingNumber != null && (isActivate() || isDeactivate()); } @@ -509,50 +490,43 @@ public final class GsmMmiCode extends Handler implements MmiCode * See also isTemporaryModeCLIR() */ int - getCLIRMode() - { + getCLIRMode() { if (sc != null && sc.equals(SC_CLIR)) { if (isActivate()) { return CommandsInterface.CLIR_SUPPRESSION; } else if (isDeactivate()) { - return CommandsInterface.CLIR_INVOCATION; + return CommandsInterface.CLIR_INVOCATION; } } - + return CommandsInterface.CLIR_DEFAULT; } - - boolean isActivate() - { + + boolean isActivate() { return action != null && action.equals(ACTION_ACTIVATE); } - boolean isDeactivate() - { + boolean isDeactivate() { return action != null && action.equals(ACTION_DEACTIVATE); } - - boolean isInterrogate() - { + + boolean isInterrogate() { return action != null && action.equals(ACTION_INTERROGATE); } - boolean isRegister() - { + boolean isRegister() { return action != null && action.equals(ACTION_REGISTER); } - boolean isErasure() - { + boolean isErasure() { return action != null && action.equals(ACTION_ERASURE); } - /** + /** * Returns true if this is a USSD code that's been submitted to the * network...eg, after processCode() is called */ - public boolean isPendingUSSD() - { + public boolean isPendingUSSD() { return isPendingUSSD; } @@ -562,8 +536,7 @@ public final class GsmMmiCode extends Handler implements MmiCode /** Process a MMI code or short code...anything that isn't a dialing number */ void - processCode () - { + processCode () { try { if (isShortCode()) { Log.d(LOG_TAG, "isShortCode"); @@ -573,7 +546,7 @@ public final class GsmMmiCode extends Handler implements MmiCode // We should have no dialing numbers here throw new RuntimeException ("Invalid or Unsupported MMI Code"); } else if (sc != null && sc.equals(SC_CLIP)) { - Log.d(LOG_TAG, "is CLIP"); + Log.d(LOG_TAG, "is CLIP"); if (isInterrogate()) { phone.mCM.queryCLIP( obtainMessage(EVENT_QUERY_COMPLETE, this)); @@ -581,7 +554,7 @@ public final class GsmMmiCode extends Handler implements MmiCode throw new RuntimeException ("Invalid or Unsupported MMI Code"); } } else if (sc != null && sc.equals(SC_CLIR)) { - Log.d(LOG_TAG, "is CLIR"); + Log.d(LOG_TAG, "is CLIR"); if (isActivate()) { phone.mCM.setCLIR(CommandsInterface.CLIR_INVOCATION, obtainMessage(EVENT_SET_COMPLETE, this)); @@ -688,13 +661,13 @@ public final class GsmMmiCode extends Handler implements MmiCode // sia = basic service group int serviceClass = siToServiceClass(sia); - if (isActivate() || isDeactivate()) { + if (isActivate() || isDeactivate()) { phone.mCM.setCallWaiting(isActivate(), serviceClass, obtainMessage(EVENT_SET_COMPLETE, this)); - } else if (isInterrogate()) { + } else if (isInterrogate()) { phone.mCM.queryCallWaiting(serviceClass, obtainMessage(EVENT_QUERY_COMPLETE, this)); - } else { + } else { throw new RuntimeException ("Invalid or Unsupported MMI Code"); } } else if (isPinCommand()) { @@ -718,16 +691,16 @@ public final class GsmMmiCode extends Handler implements MmiCode } else { // pre-checks OK if (sc.equals(SC_PIN)) { - phone.mCM.changeSimPin(oldPinOrPuk, newPin, + phone.mCM.changeIccPin(oldPinOrPuk, newPin, obtainMessage(EVENT_SET_COMPLETE, this)); } else if (sc.equals(SC_PIN2)) { - phone.mCM.changeSimPin2(oldPinOrPuk, newPin, + phone.mCM.changeIccPin2(oldPinOrPuk, newPin, obtainMessage(EVENT_SET_COMPLETE, this)); } else if (sc.equals(SC_PUK)) { - phone.mCM.supplySimPuk(oldPinOrPuk, newPin, + phone.mCM.supplyIccPuk(oldPinOrPuk, newPin, obtainMessage(EVENT_SET_COMPLETE, this)); } else if (sc.equals(SC_PUK2)) { - phone.mCM.supplySimPuk2(oldPinOrPuk, newPin, + phone.mCM.supplyIccPuk2(oldPinOrPuk, newPin, obtainMessage(EVENT_SET_COMPLETE, this)); } } @@ -743,7 +716,7 @@ public final class GsmMmiCode extends Handler implements MmiCode state = State.FAILED; message = context.getText(com.android.internal.R.string.mmiError); phone.onMMIDone(this); - } + } } private void handlePasswordError(int res) { @@ -755,8 +728,8 @@ public final class GsmMmiCode extends Handler implements MmiCode phone.onMMIDone(this); } - /** - * Called from GSMPhone + /** + * Called from GSMPhone * * An unsolicited USSD NOTIFY or REQUEST has come in matching * up with this pending USSD request @@ -765,8 +738,7 @@ public final class GsmMmiCode extends Handler implements MmiCode * active (ie, the network expects user input). */ void - onUssdFinished(String ussdMessage, boolean isUssdRequest) - { + onUssdFinished(String ussdMessage, boolean isUssdRequest) { if (state == State.PENDING) { if (ussdMessage == null) { message = context.getText(com.android.internal.R.string.mmiComplete); @@ -783,15 +755,14 @@ public final class GsmMmiCode extends Handler implements MmiCode } } - /** - * Called from GSMPhone + /** + * Called from GSMPhone * * The radio has reset, and this is still pending */ void - onUssdFinishedError() - { + onUssdFinishedError() { if (state == State.PENDING) { state = State.FAILED; message = context.getText(com.android.internal.R.string.mmiError); @@ -808,15 +779,14 @@ public final class GsmMmiCode extends Handler implements MmiCode // response does not complete this MMI code...we wait for // an unsolicited USSD "Notify" or "Request". // The matching up of this is doene in GSMPhone. - - phone.mCM.sendUSSD(ussdMessage, + + phone.mCM.sendUSSD(ussdMessage, obtainMessage(EVENT_USSD_COMPLETE, this)); } /** Called from GSMPhone.handleMessage; not a Handler subclass */ public void - handleMessage (Message msg) - { + handleMessage (Message msg) { AsyncResult ar; switch (msg.what) { @@ -865,13 +835,13 @@ public final class GsmMmiCode extends Handler implements MmiCode com.android.internal.R.string.mmiError); phone.onMMIDone(this); - } + } // Note that unlike most everything else, the USSD complete // response does not complete this MMI code...we wait for // an unsolicited USSD "Notify" or "Request". // The matching up of this is done in GSMPhone. - + break; case EVENT_USSD_CANCEL_COMPLETE: @@ -976,8 +946,7 @@ public final class GsmMmiCode extends Handler implements MmiCode } private void - onGetClirComplete(AsyncResult ar) - { + onGetClirComplete(AsyncResult ar) { StringBuilder sb = new StringBuilder(getScString()); sb.append("\n"); @@ -996,35 +965,35 @@ public final class GsmMmiCode extends Handler implements MmiCode com.android.internal.R.string.serviceNotProvisioned)); state = State.COMPLETE; break; - + case 1: // CLIR provisioned in permanent mode sb.append(context.getText( com.android.internal.R.string.CLIRPermanent)); state = State.COMPLETE; break; - case 2: // unknown (e.g. no network, etc.) + case 2: // unknown (e.g. no network, etc.) sb.append(context.getText( com.android.internal.R.string.mmiError)); state = State.FAILED; break; - case 3: // CLIR temporary mode presentation restricted + case 3: // CLIR temporary mode presentation restricted // the 'n' parameter from TS 27.007 7.7 switch (clirArgs[0]) { default: case 0: // Default sb.append(context.getText( - com.android.internal.R.string.CLIRDefaultOnNextCallOn)); + com.android.internal.R.string.CLIRDefaultOnNextCallOn)); break; case 1: // CLIR invocation sb.append(context.getText( - com.android.internal.R.string.CLIRDefaultOnNextCallOn)); + com.android.internal.R.string.CLIRDefaultOnNextCallOn)); break; case 2: // CLIR suppression sb.append(context.getText( - com.android.internal.R.string.CLIRDefaultOnNextCallOff)); + com.android.internal.R.string.CLIRDefaultOnNextCallOff)); break; } state = State.COMPLETE; @@ -1036,21 +1005,21 @@ public final class GsmMmiCode extends Handler implements MmiCode default: case 0: // Default sb.append(context.getText( - com.android.internal.R.string.CLIRDefaultOffNextCallOff)); + com.android.internal.R.string.CLIRDefaultOffNextCallOff)); break; case 1: // CLIR invocation sb.append(context.getText( - com.android.internal.R.string.CLIRDefaultOffNextCallOn)); + com.android.internal.R.string.CLIRDefaultOffNextCallOn)); break; case 2: // CLIR suppression sb.append(context.getText( - com.android.internal.R.string.CLIRDefaultOffNextCallOff)); + com.android.internal.R.string.CLIRDefaultOffNextCallOff)); break; } state = State.COMPLETE; break; - } + } } message = sb; @@ -1059,23 +1028,29 @@ public final class GsmMmiCode extends Handler implements MmiCode /** * @param serviceClass 1 bit of the service class bit vectory - * @return String to be used for call forward query MMI response text. + * @return String to be used for call forward query MMI response text. * Returns null if unrecognized */ private CharSequence - serviceClassToCFString (int serviceClass) - { + serviceClassToCFString (int serviceClass) { switch (serviceClass) { - case SERVICE_CLASS_VOICE: return context.getText(com.android.internal.R.string.serviceClassVoice); - case SERVICE_CLASS_DATA: return context.getText(com.android.internal.R.string.serviceClassData); - case SERVICE_CLASS_FAX: return context.getText(com.android.internal.R.string.serviceClassFAX); - case SERVICE_CLASS_SMS: return context.getText(com.android.internal.R.string.serviceClassSMS); - case SERVICE_CLASS_DATA_SYNC: return context.getText(com.android.internal.R.string.serviceClassDataSync); - case SERVICE_CLASS_DATA_ASYNC: return context.getText(com.android.internal.R.string.serviceClassDataAsync); - case SERVICE_CLASS_PACKET: return context.getText(com.android.internal.R.string.serviceClassPacket); - case SERVICE_CLASS_PAD: return context.getText(com.android.internal.R.string.serviceClassPAD); - + case SERVICE_CLASS_VOICE: + return context.getText(com.android.internal.R.string.serviceClassVoice); + case SERVICE_CLASS_DATA: + return context.getText(com.android.internal.R.string.serviceClassData); + case SERVICE_CLASS_FAX: + return context.getText(com.android.internal.R.string.serviceClassFAX); + case SERVICE_CLASS_SMS: + return context.getText(com.android.internal.R.string.serviceClassSMS); + case SERVICE_CLASS_DATA_SYNC: + return context.getText(com.android.internal.R.string.serviceClassDataSync); + case SERVICE_CLASS_DATA_ASYNC: + return context.getText(com.android.internal.R.string.serviceClassDataAsync); + case SERVICE_CLASS_PACKET: + return context.getText(com.android.internal.R.string.serviceClassPacket); + case SERVICE_CLASS_PAD: + return context.getText(com.android.internal.R.string.serviceClassPAD); default: return null; } @@ -1084,8 +1059,7 @@ public final class GsmMmiCode extends Handler implements MmiCode /** one CallForwardInfo + serviceClassMask -> one line of text */ private CharSequence - makeCFQueryResultMessage(CallForwardInfo info, int serviceClassMask) - { + makeCFQueryResultMessage(CallForwardInfo info, int serviceClassMask) { CharSequence template; String sources[] = {"{0}", "{1}", "{2}"}; CharSequence destinations[] = new CharSequence[3]; @@ -1094,7 +1068,7 @@ public final class GsmMmiCode extends Handler implements MmiCode // CF_REASON_NO_REPLY also has a time value associated with // it. All others don't. - needTimeTemplate = + needTimeTemplate = (info.reason == CommandsInterface.CF_REASON_NO_REPLY); if (info.status == 1) { @@ -1122,8 +1096,8 @@ public final class GsmMmiCode extends Handler implements MmiCode } // In the template (from strings.xmls) - // {0} is one of "bearerServiceCode*" - // {1} is dialing number + // {0} is one of "bearerServiceCode*" + // {1} is dialing number // {2} is time in seconds destinations[0] = serviceClassToCFString(info.serviceClass & serviceClassMask); @@ -1142,8 +1116,7 @@ public final class GsmMmiCode extends Handler implements MmiCode private void - onQueryCfComplete(AsyncResult ar) - { + onQueryCfComplete(AsyncResult ar) { StringBuilder sb = new StringBuilder(getScString()); sb.append("\n"); @@ -1152,7 +1125,7 @@ public final class GsmMmiCode extends Handler implements MmiCode sb.append(context.getText(com.android.internal.R.string.mmiError)); } else { CallForwardInfo infos[]; - + infos = (CallForwardInfo[]) ar.result; if (infos.length == 0) { @@ -1166,18 +1139,18 @@ public final class GsmMmiCode extends Handler implements MmiCode SpannableStringBuilder tb = new SpannableStringBuilder(); // Each bit in the service class gets its own result line - // The service classes may be split up over multiple + // The service classes may be split up over multiple // CallForwardInfos. So, for each service classs, find out // which CallForwardInfo represents it and then build // the response text based on that - for (int serviceClassMask = 1 + for (int serviceClassMask = 1 ; serviceClassMask <= SERVICE_CLASS_MAX - ; serviceClassMask <<= 1 + ; serviceClassMask <<= 1 ) { for (int i = 0, s = infos.length; i < s ; i++) { if ((serviceClassMask & infos[i].serviceClass) != 0) { - tb.append(makeCFQueryResultMessage(infos[i], + tb.append(makeCFQueryResultMessage(infos[i], serviceClassMask)); tb.append("\n"); } @@ -1191,12 +1164,11 @@ public final class GsmMmiCode extends Handler implements MmiCode message = sb; phone.onMMIDone(this); - + } private void - onQueryComplete(AsyncResult ar) - { + onQueryComplete(AsyncResult ar) { StringBuilder sb = new StringBuilder(getScString()); sb.append("\n"); @@ -1230,15 +1202,15 @@ public final class GsmMmiCode extends Handler implements MmiCode message = sb; phone.onMMIDone(this); } - + private CharSequence - createQueryCallWaitingResultMessage(int serviceClass) - { - StringBuilder sb = new StringBuilder(context.getText(com.android.internal.R.string.serviceEnabledFor)); + createQueryCallWaitingResultMessage(int serviceClass) { + StringBuilder sb = + new StringBuilder(context.getText(com.android.internal.R.string.serviceEnabledFor)); - for (int classMask = 1 + for (int classMask = 1 ; classMask <= SERVICE_CLASS_MAX - ; classMask <<= 1 + ; classMask <<= 1 ) { if ((classMask & serviceClass) != 0) { sb.append("\n"); @@ -1267,8 +1239,8 @@ public final class GsmMmiCode extends Handler implements MmiCode /*** * TODO: It would be nice to have a method here that can take in a dialstring and * figure out if there is an MMI code embedded within it. This code would replace - * some of the string parsing functionality in the Phone App's - * SpecialCharSequenceMgr class. + * some of the string parsing functionality in the Phone App's + * SpecialCharSequenceMgr class. */ } diff --git a/telephony/java/com/android/internal/telephony/gsm/GsmSMSDispatcher.java b/telephony/java/com/android/internal/telephony/gsm/GsmSMSDispatcher.java new file mode 100644 index 0000000..3e73caf --- /dev/null +++ b/telephony/java/com/android/internal/telephony/gsm/GsmSMSDispatcher.java @@ -0,0 +1,379 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.gsm; + +import android.app.Activity; +import android.app.PendingIntent; +import android.app.PendingIntent.CanceledException; +import android.content.Intent; +import android.os.AsyncResult; +import android.os.Message; +import android.telephony.ServiceState; +import android.util.Config; +import android.util.Log; + +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.gsm.SmsMessage; +import com.android.internal.telephony.SMSDispatcher; +import com.android.internal.telephony.SmsHeader; +import com.android.internal.telephony.SmsMessageBase; + +import java.util.ArrayList; +import java.util.HashMap; + + +final class GsmSMSDispatcher extends SMSDispatcher { + private static final String TAG = "GSM"; + + GsmSMSDispatcher(GSMPhone phone) { + super(phone); + } + + /** + * Called when a status report is received. This should correspond to + * a previously successful SEND. + * + * @param ar AsyncResult passed into the message handler. ar.result should + * be a String representing the status report PDU, as ASCII hex. + */ + protected void handleStatusReport(AsyncResult ar) { + String pduString = (String) ar.result; + SmsMessage sms = SmsMessage.newFromCDS(pduString); + + if (sms != null) { + int messageRef = sms.messageRef; + for (int i = 0, count = deliveryPendingList.size(); i < count; i++) { + SmsTracker tracker = deliveryPendingList.get(i); + if (tracker.mMessageRef == messageRef) { + // Found it. Remove from list and broadcast. + deliveryPendingList.remove(i); + PendingIntent intent = tracker.mDeliveryIntent; + Intent fillIn = new Intent(); + fillIn.putExtra("pdu", IccUtils.hexStringToBytes(pduString)); + try { + intent.send(mContext, Activity.RESULT_OK, fillIn); + } catch (CanceledException ex) {} + + // Only expect to see one tracker matching this messageref + break; + } + } + } + + if (mCm != null) { + mCm.acknowledgeLastIncomingSMS(true, null); + } + } + + + /** + * Dispatches an incoming SMS messages. + * + * @param sms the incoming message from the phone + */ + protected void dispatchMessage(SmsMessageBase smsb) { + + // If sms is null, means there was a parsing error. + // TODO: Should NAK this. + if (smsb == null) { + return; + } + SmsMessage sms = (SmsMessage) smsb; + boolean handled = false; + + // Special case the message waiting indicator messages + if (sms.isMWISetMessage()) { + ((GSMPhone) mPhone).updateMessageWaitingIndicator(true); + + if (sms.isMwiDontStore()) { + handled = true; + } + + if (Config.LOGD) { + Log.d(TAG, + "Received voice mail indicator set SMS shouldStore=" + + !handled); + } + } else if (sms.isMWIClearMessage()) { + ((GSMPhone) mPhone).updateMessageWaitingIndicator(false); + + if (sms.isMwiDontStore()) { + handled = true; + } + + if (Config.LOGD) { + Log.d(TAG, + "Received voice mail indicator clear SMS shouldStore=" + + !handled); + } + } + + if (handled) { + return; + } + + // Parse the headers to see if this is partial, or port addressed + int referenceNumber = -1; + int count = 0; + int sequence = 0; + int destPort = -1; + + SmsHeader header = sms.getUserDataHeader(); + if (header != null) { + for (SmsHeader.Element element : header.getElements()) { + try { + switch (element.getID()) { + case SmsHeader.CONCATENATED_8_BIT_REFERENCE: { + byte[] data = element.getData(); + + referenceNumber = data[0] & 0xff; + count = data[1] & 0xff; + sequence = data[2] & 0xff; + + // Per TS 23.040, 9.2.3.24.1: If the count is zero, sequence + // is zero, or sequence > count, ignore the entire element + if (count == 0 || sequence == 0 || sequence > count) { + referenceNumber = -1; + } + break; + } + + case SmsHeader.CONCATENATED_16_BIT_REFERENCE: { + byte[] data = element.getData(); + + referenceNumber = (data[0] & 0xff) * 256 + (data[1] & 0xff); + count = data[2] & 0xff; + sequence = data[3] & 0xff; + + // Per TS 23.040, 9.2.3.24.8: If the count is zero, sequence + // is zero, or sequence > count, ignore the entire element + if (count == 0 || sequence == 0 || sequence > count) { + referenceNumber = -1; + } + break; + } + + case SmsHeader.APPLICATION_PORT_ADDRESSING_16_BIT: { + byte[] data = element.getData(); + + destPort = (data[0] & 0xff) << 8; + destPort |= (data[1] & 0xff); + + break; + } + } + } catch (ArrayIndexOutOfBoundsException e) { + Log.e(TAG, "Bad element in header", e); + return; // TODO: NACK the message or something, don't just discard. + } + } + } + + if (referenceNumber == -1) { + // notify everyone of the message if it isn't partial + byte[][] pdus = new byte[1][]; + pdus[0] = sms.getPdu(); + + if (destPort != -1) { + if (destPort == SmsHeader.PORT_WAP_PUSH) { + mWapPush.dispatchWapPdu(sms.getUserData()); + } + // The message was sent to a port, so concoct a URI for it + dispatchPortAddressedPdus(pdus, destPort); + } else { + // It's a normal message, dispatch it + dispatchPdus(pdus); + } + } else { + // Process the message part + processMessagePart(sms, referenceNumber, sequence, count, destPort); + } + } + + /** {@inheritDoc} */ + protected void sendMultipartText(String destinationAddress, String scAddress, + ArrayList<String> parts, ArrayList<PendingIntent> sentIntents, + ArrayList<PendingIntent> deliveryIntents) { + int ref = ++sConcatenatedRef & 0xff; + + for (int i = 0, count = parts.size(); i < count; i++) { + // build SmsHeader + byte[] data = new byte[3]; + data[0] = (byte) ref; // reference #, unique per message + data[1] = (byte) count; // total part count + data[2] = (byte) (i + 1); // 1-based sequence + SmsHeader header = new SmsHeader(); + header.add(new SmsHeader.Element(SmsHeader.CONCATENATED_8_BIT_REFERENCE, data)); + PendingIntent sentIntent = null; + PendingIntent deliveryIntent = null; + + if (sentIntents != null && sentIntents.size() > i) { + sentIntent = sentIntents.get(i); + } + if (deliveryIntents != null && deliveryIntents.size() > i) { + deliveryIntent = deliveryIntents.get(i); + } + + SmsMessage.SubmitPdu pdus = SmsMessage.getSubmitPdu(scAddress, destinationAddress, + parts.get(i), deliveryIntent != null, header.toByteArray()); + + sendRawPdu(pdus.encodedScAddress, pdus.encodedMessage, sentIntent, deliveryIntent); + } + } + + /** + * Send a multi-part text based SMS which already passed SMS control check. + * + * It is the working function for sendMultipartText(). + * + * @param destinationAddress the address to send the message to + * @param scAddress is the service center address or null to use + * the current default SMSC + * @param parts an <code>ArrayList</code> of strings that, in order, + * comprise the original message + * @param sentIntents if not null, an <code>ArrayList</code> of + * <code>PendingIntent</code>s (one for each message part) that is + * broadcast when the corresponding message part has been sent. + * The result code will be <code>Activity.RESULT_OK<code> for success, + * or one of these errors: + * <code>RESULT_ERROR_GENERIC_FAILURE</code> + * <code>RESULT_ERROR_RADIO_OFF</code> + * <code>RESULT_ERROR_NULL_PDU</code>. + * @param deliveryIntents if not null, an <code>ArrayList</code> of + * <code>PendingIntent</code>s (one for each message part) that is + * broadcast when the corresponding message part has been delivered + * to the recipient. The raw pdu of the status report is in the + * extended data ("pdu"). + */ + private void sendMultipartTextWithPermit(String destinationAddress, + String scAddress, ArrayList<String> parts, + ArrayList<PendingIntent> sentIntents, + ArrayList<PendingIntent> deliveryIntents) { + + PendingIntent sentIntent = null; + PendingIntent deliveryIntent = null; + + // check if in service + int ss = mPhone.getServiceState().getState(); + if (ss != ServiceState.STATE_IN_SERVICE) { + for (int i = 0, count = parts.size(); i < count; i++) { + if (sentIntents != null && sentIntents.size() > i) { + sentIntent = sentIntents.get(i); + } + SmsTracker tracker = SmsTrackerFactory(null, sentIntent, null); + handleNotInService(ss, tracker); + } + return; + } + + int ref = ++sConcatenatedRef & 0xff; + + for (int i = 0, count = parts.size(); i < count; i++) { + // build SmsHeader + byte[] data = new byte[3]; + data[0] = (byte) ref; // reference #, unique per message + data[1] = (byte) count; // total part count + data[2] = (byte) (i + 1); // 1-based sequence + SmsHeader header = new SmsHeader(); + header.add(new SmsHeader.Element(SmsHeader.CONCATENATED_8_BIT_REFERENCE, data)); + + if (sentIntents != null && sentIntents.size() > i) { + sentIntent = sentIntents.get(i); + } + if (deliveryIntents != null && deliveryIntents.size() > i) { + deliveryIntent = deliveryIntents.get(i); + } + + SmsMessage.SubmitPdu pdus = SmsMessage.getSubmitPdu(scAddress, destinationAddress, + parts.get(i), deliveryIntent != null, header.toByteArray()); + + HashMap<String, Object> map = new HashMap<String, Object>(); + map.put("smsc", pdus.encodedScAddress); + map.put("pdu", pdus.encodedMessage); + + SmsTracker tracker = SmsTrackerFactory(map, sentIntent, deliveryIntent); + sendSms(tracker); + } + } + + /** {@inheritDoc} */ + protected void sendSms(SmsTracker tracker) { + HashMap map = tracker.mData; + + byte smsc[] = (byte[]) map.get("smsc"); + byte pdu[] = (byte[]) map.get("pdu"); + + Message reply = obtainMessage(EVENT_SEND_SMS_COMPLETE, tracker); + mCm.sendSMS(IccUtils.bytesToHexString(smsc), + IccUtils.bytesToHexString(pdu), reply); + } + + /** + * Send the multi-part SMS based on multipart Sms tracker + * + * @param tracker holds the multipart Sms tracker ready to be sent + */ + protected void sendMultipartSms (SmsTracker tracker) { + ArrayList<String> parts; + ArrayList<PendingIntent> sentIntents; + ArrayList<PendingIntent> deliveryIntents; + + HashMap map = tracker.mData; + + String destinationAddress = (String) map.get("destination"); + String scAddress = (String) map.get("scaddress"); + + parts = (ArrayList<String>) map.get("parts"); + sentIntents = (ArrayList<PendingIntent>) map.get("sentIntents"); + deliveryIntents = (ArrayList<PendingIntent>) map.get("deliveryIntents"); + + sendMultipartTextWithPermit(destinationAddress, + scAddress, parts, sentIntents, deliveryIntents); + + } + + /** {@inheritDoc} */ + protected void acknowledgeLastIncomingSms(boolean success, Message response){ + // FIXME unit test leaves cm == null. this should change + if (mCm != null) { + mCm.acknowledgeLastIncomingSMS(success, response); + } + } + + /** {@inheritDoc} */ + protected void activateCellBroadcastSms(int activate, Message response) { + // Unless CBS is implemented for GSM, this point should be unreachable. + Log.e(TAG, "Error! The functionality cell broadcast sms is not implemented for GSM."); + response.recycle(); + } + + /** {@inheritDoc} */ + protected void getCellBroadcastSmsConfig(Message response){ + // Unless CBS is implemented for GSM, this point should be unreachable. + Log.e(TAG, "Error! The functionality cell broadcast sms is not implemented for GSM."); + response.recycle(); + } + + /** {@inheritDoc} */ + protected void setCellBroadcastConfig(int[] configValuesArray, Message response) { + // Unless CBS is implemented for GSM, this point should be unreachable. + Log.e(TAG, "Error! The functionality cell broadcast sms is not implemented for GSM."); + response.recycle(); + } + +} + diff --git a/telephony/java/com/android/internal/telephony/gsm/ServiceStateTracker.java b/telephony/java/com/android/internal/telephony/gsm/GsmServiceStateTracker.java index e336d7d..3c0b603 100644 --- a/telephony/java/com/android/internal/telephony/gsm/ServiceStateTracker.java +++ b/telephony/java/com/android/internal/telephony/gsm/GsmServiceStateTracker.java @@ -16,19 +16,7 @@ package com.android.internal.telephony.gsm; -import static com.android.internal.telephony.TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE; -import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ALPHA; -import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY; -import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ISROAMING; -import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_NUMERIC; -import static com.android.internal.telephony.TelephonyProperties.PROPERTY_SIM_OPERATOR_ALPHA; -import static com.android.internal.telephony.TelephonyProperties.PROPERTY_SIM_OPERATOR_NUMERIC; - -import com.android.internal.telephony.SimCard; -import com.android.internal.telephony.TelephonyIntents; import com.android.internal.telephony.Phone; -import com.android.internal.telephony.gsm.DataConnectionTracker.State; - import android.app.AlarmManager; import android.app.Notification; import android.app.NotificationManager; @@ -49,13 +37,32 @@ import android.provider.Checkin; import android.provider.Settings; import android.provider.Settings.SettingNotFoundException; import android.provider.Telephony.Intents; -import android.telephony.gsm.GsmCellLocation; import android.telephony.ServiceState; +import android.telephony.gsm.GsmCellLocation; import android.text.TextUtils; import android.util.Config; +import android.util.EventLog; import android.util.Log; import android.util.TimeUtils; -import android.util.EventLog; + +import com.android.internal.telephony.CommandException; +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.DataConnectionTracker; +import com.android.internal.telephony.IccCard; +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneProxy; +import com.android.internal.telephony.RILConstants; +import com.android.internal.telephony.ServiceStateTracker; +import com.android.internal.telephony.TelephonyEventLog; +import com.android.internal.telephony.TelephonyIntents; + +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_ICC_OPERATOR_ALPHA; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_ICC_OPERATOR_NUMERIC; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ALPHA; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ISO_COUNTRY; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_ISROAMING; +import static com.android.internal.telephony.TelephonyProperties.PROPERTY_OPERATOR_NUMERIC; import java.util.Arrays; import java.util.Calendar; @@ -65,30 +72,9 @@ import java.util.TimeZone; /** * {@hide} */ -final class ServiceStateTracker extends Handler -{ - /** - * The access technology currently in use: - * 0 = unknown - * 1 = GPRS only - * 2 = EDGE - * 3 = UMTS - */ - static final int DATA_ACCESS_UNKNOWN = 0; - static final int DATA_ACCESS_GPRS = 1; - static final int DATA_ACCESS_EDGE = 2; - static final int DATA_ACCESS_UMTS = 3; - - static final int MAX_NUM_DATA_STATE_READS = 15; - static final int DATA_STATE_POLL_SLEEP_MS = 100; - +final class GsmServiceStateTracker extends ServiceStateTracker { //***** Instance Variables - GSMPhone phone; - CommandsInterface cm; - - ServiceState ss; - ServiceState newSS; GsmCellLocation cellLoc; GsmCellLocation newCellLoc; int mPreferredNetworkType; @@ -97,18 +83,6 @@ final class ServiceStateTracker extends Handler int rssi = 99; // signal strength 0-31, 99=unknown // That's "received signal strength indication" fyi - int[] pollingContext; // Used as a unique identifier to - // track requests associated with a poll - // and ignore stale responses. - // The value is a count-down of expected responses - // in this pollingContext - - boolean mDesiredPowerState; - - boolean dontPollSignalStrength = false; // Default is to poll strength - // If we're getting unsolicited signal strength updates from the radio, - // set value to true and don't bother polling any more - private int gprsState = ServiceState.STATE_OUT_OF_SERVICE; private int newGPRSState = ServiceState.STATE_OUT_OF_SERVICE; @@ -120,14 +94,10 @@ final class ServiceStateTracker extends Handler /* gsm roaming status solely based on TS 27.007 7.2 CREG */ private boolean mGsmRoaming = false; - private RegistrantList networkAttachedRegistrants = new RegistrantList(); private RegistrantList gprsAttachedRegistrants = new RegistrantList(); private RegistrantList gprsDetachedRegistrants = new RegistrantList(); - private RegistrantList roamingOnRegistrants = new RegistrantList(); - private RegistrantList roamingOffRegistrants = new RegistrantList(); private RegistrantList psRestrictEnabledRegistrants = new RegistrantList(); private RegistrantList psRestrictDisabledRegistrants = new RegistrantList(); - // Sometimes we get the NITZ time before we know what country we are in. // Keep the time zone information from the NITZ string so we can fix @@ -137,6 +107,7 @@ final class ServiceStateTracker extends Handler private boolean mZoneDst; private long mZoneTime; private boolean mGotCountryCode = false; + private ContentResolver cr; String mSavedTimeZone; long mSavedTime; @@ -170,13 +141,10 @@ final class ServiceStateTracker extends Handler static final boolean DBG = true; static final String LOG_TAG = "GSM"; - // signal strength poll rate - static final int POLL_PERIOD_MILLIS = 20 * 1000; - // waiting period before recheck gprs and voice registration static final int DEFAULT_GPRS_CHECK_PERIOD_MILLIS = 60 * 1000; - // restricted state type + // notification type static final int PS_ENABLED = 1001; // Access Control blocks data service static final int PS_DISABLED = 1002; // Access Control enables data service static final int CS_ENABLED = 1003; // Access Control blocks all voice/sms service @@ -187,72 +155,21 @@ final class ServiceStateTracker extends Handler // notification id static final int PS_NOTIFICATION = 888; //id to update and cancel PS restricted static final int CS_NOTIFICATION = 999; //id to update and cancel CS restricted - - //***** Events - static final int EVENT_RADIO_STATE_CHANGED = 1; - static final int EVENT_NETWORK_STATE_CHANGED = 2; - static final int EVENT_GET_SIGNAL_STRENGTH = 3; - static final int EVENT_POLL_STATE_REGISTRATION = 4; - static final int EVENT_POLL_STATE_GPRS = 5; - static final int EVENT_POLL_STATE_OPERATOR = 6; - static final int EVENT_POLL_SIGNAL_STRENGTH = 10; - static final int EVENT_NITZ_TIME = 11; - static final int EVENT_SIGNAL_STRENGTH_UPDATE = 12; - static final int EVENT_RADIO_AVAILABLE = 13; - static final int EVENT_POLL_STATE_NETWORK_SELECTION_MODE = 14; - static final int EVENT_GET_LOC_DONE = 15; - static final int EVENT_SIM_RECORDS_LOADED = 16; - static final int EVENT_SIM_READY = 17; - static final int EVENT_LOCATION_UPDATES_ENABLED = 18; - static final int EVENT_GET_PREFERRED_NETWORK_TYPE = 19; - static final int EVENT_SET_PREFERRED_NETWORK_TYPE = 20; - static final int EVENT_RESET_PREFERRED_NETWORK_TYPE = 21; - static final int EVENT_CHECK_REPORT_GPRS = 22; - static final int EVENT_RESTRICTED_STATE_CHANGED = 23; - - //***** Time Zones - - private static final String TIMEZONE_PROPERTY = "persist.sys.timezone"; - - // List of ISO codes for countries that can have an offset of GMT+0 - // when not in daylight savings time. This ignores some small places - // such as the Canary Islands (Spain) and Danmarkshavn (Denmark). - // The list must be sorted by code. - private static final String[] GMT_COUNTRY_CODES = { - "bf", // Burkina Faso - "ci", // Cote d'Ivoire - "eh", // Western Sahara - "fo", // Faroe Islands, Denmark - "gh", // Ghana - "gm", // Gambia - "gn", // Guinea - "gw", // Guinea Bissau - "ie", // Ireland - "lr", // Liberia - "is", // Iceland - "ma", // Morocco - "ml", // Mali - "mr", // Mauritania - "pt", // Portugal - "sl", // Sierra Leone - "sn", // Senegal - "st", // Sao Tome and Principe - "tg", // Togo - "uk", // U.K - }; private ContentObserver mAutoTimeObserver = new ContentObserver(new Handler()) { @Override public void onChange(boolean selfChange) { - Log.i("ServiceStateTracker", "Auto time state changed"); + Log.i("GsmServiceStateTracker", "Auto time state changed"); revertToNitz(); } }; - + + //***** Constructors - ServiceStateTracker(GSMPhone phone) - { + public GsmServiceStateTracker(GSMPhone phone) { + super(); + this.phone = phone; cm = phone.mCM; ss = new ServiceState(); @@ -265,13 +182,13 @@ final class ServiceStateTracker extends Handler (PowerManager)phone.getContext().getSystemService(Context.POWER_SERVICE); mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_TAG); - cm.registerForAvailable(this, EVENT_RADIO_AVAILABLE, null); + cm.registerForAvailable(this, EVENT_RADIO_AVAILABLE, null); cm.registerForRadioStateChanged(this, EVENT_RADIO_STATE_CHANGED, null); cm.registerForNetworkStateChanged(this, EVENT_NETWORK_STATE_CHANGED, null); cm.setOnNITZTime(this, EVENT_NITZ_TIME, null); cm.setOnSignalStrengthUpdate(this, EVENT_SIGNAL_STRENGTH_UPDATE, null); - cm.setOnRestrictedStateChanged(this, EVENT_RESTRICTED_STATE_CHANGED, null); + cm.setOnRestrictedStateChanged(this, EVENT_RESTRICTED_STATE_CHANGED, null); cm.registerForSIMReady(this, EVENT_SIM_READY, null); // system setting property AIRPLANE_MODE_ON is set in Settings. @@ -280,7 +197,7 @@ final class ServiceStateTracker extends Handler Settings.System.AIRPLANE_MODE_ON, 0); mDesiredPowerState = ! (airplaneMode > 0); - ContentResolver cr = phone.getContext().getContentResolver(); + cr = phone.getContext().getContentResolver(); cr.registerContentObserver( Settings.System.getUriFor(Settings.System.AUTO_TIME), true, mAutoTimeObserver); @@ -288,6 +205,24 @@ final class ServiceStateTracker extends Handler mNeedToRegForSimLoaded = true; } + public void dispose() { + //Unregister for all events + cm.unregisterForAvailable(this); + cm.unregisterForRadioStateChanged(this); + cm.unregisterForNetworkStateChanged(this); + cm.unregisterForSIMReady(this); + + phone.mSIMRecords.unregisterForRecordsLoaded(this); + cm.unSetOnSignalStrengthUpdate(this); + cm.unSetOnRestrictedStateChanged(this); + cm.unSetOnNITZTime(this); + cr.unregisterContentObserver(this.mAutoTimeObserver); + } + + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "GsmServiceStateTracker finalized"); + } + /** * Registration point for transition into GPRS attached. * @param h handler to notify @@ -303,7 +238,11 @@ final class ServiceStateTracker extends Handler } } - void registerForNetworkAttach(Handler h, int what, Object obj) { + /*protected*/ void unregisterForGprsAttached(Handler h) { + gprsAttachedRegistrants.remove(h); + } + + /*protected*/ void registerForNetworkAttach(Handler h, int what, Object obj) { Registrant r = new Registrant(h, what, obj); networkAttachedRegistrants.add(r); @@ -311,6 +250,10 @@ final class ServiceStateTracker extends Handler r.notifyRegistrant(); } } + + /*protected*/ void unregisterForNetworkAttach(Handler h) { + networkAttachedRegistrants.remove(h); + } /** * Registration point for transition into GPRS detached. * @param h handler to notify @@ -326,52 +269,8 @@ final class ServiceStateTracker extends Handler } } - /** - * Registration point for combined roaming on - * combined roaming is true when roaming is true and ONS differs SPN - * - * @param h handler to notify - * @param what what code of message when delivered - * @param obj placed in Message.obj - */ - void registerForRoamingOn(Handler h, int what, Object obj) { - Registrant r = new Registrant(h, what, obj); - roamingOnRegistrants.add(r); - - if (ss.getRoaming()) { - r.notifyRegistrant(); - } - } - - /** - * Registration point for combined roaming off - * combined roaming is true when roaming is true and ONS differs SPN - * - * @param h handler to notify - * @param what what code of message when delivered - * @param obj placed in Message.obj - */ - void registerForRoamingOff(Handler h, int what, Object obj) { - Registrant r = new Registrant(h, what, obj); - roamingOffRegistrants.add(r); - - if (!ss.getRoaming()) { - r.notifyRegistrant(); - } - } - - /** - * Reregister network through toggle perferred network type - * This is a work aorund to deregister and register network since there is - * no ril api to set COPS=2 (deregister) only. - * - * @param onComplete is dispatched when this is complete. it will be - * an AsyncResult, and onComplete.obj.exception will be non-null - * on failure. - */ - void reRegisterNetwork(Message onComplete) { - cm.getPreferredNetworkType( - obtainMessage(EVENT_GET_PREFERRED_NETWORK_TYPE, onComplete)); + /*protected*/ void unregisterForGprsDetached(Handler h) { + gprsDetachedRegistrants.remove(h); } /** @@ -380,7 +279,7 @@ final class ServiceStateTracker extends Handler * @param what what code of message when delivered * @param obj placed in Message.obj */ - void registerForPsRestrictedEnabled(Handler h, int what, Object obj) { + /*protected*/ void registerForPsRestrictedEnabled(Handler h, int what, Object obj) { Log.d(LOG_TAG, "[DSAC DEB] " + "registerForPsRestrictedEnabled "); Registrant r = new Registrant(h, what, obj); psRestrictEnabledRegistrants.add(r); @@ -389,14 +288,18 @@ final class ServiceStateTracker extends Handler r.notifyRegistrant(); } } - + + /*protected*/ void unregisterForPsRestrictedEnabled(Handler h) { + psRestrictEnabledRegistrants.remove(h); + } + /** * Registration point for transition out of packet service restricted zone. * @param h handler to notify * @param what what code of message when delivered * @param obj placed in Message.obj */ - void registerForPsRestrictedDisabled(Handler h, int what, Object obj) { + /*protected*/ void registerForPsRestrictedDisabled(Handler h, int what, Object obj) { Log.d(LOG_TAG, "[DSAC DEB] " + "registerForPsRestrictedDisabled "); Registrant r = new Registrant(h, what, obj); psRestrictDisabledRegistrants.add(r); @@ -406,34 +309,21 @@ final class ServiceStateTracker extends Handler } } - //***** Called from GSMPhone - - public void - setRadioPower(boolean power) - { - mDesiredPowerState = power; - - setPowerStateToDesired(); + /*protected*/ void unregisterForPsRestrictedDisabled(Handler h) { + psRestrictDisabledRegistrants.remove(h); } + //***** Called from GSMPhone public void getLacAndCid(Message onComplete) { cm.getRegistrationState(obtainMessage( EVENT_GET_LOC_DONE, onComplete)); } - /*package*/ void enableLocationUpdates() { - cm.setLocationUpdates(true, obtainMessage(EVENT_LOCATION_UPDATES_ENABLED)); - } - - /*package*/ void disableLocationUpdates() { - cm.setLocationUpdates(false, null); - } - //***** Overridden from Handler + //***** Overridden from ServiceStateTracker public void - handleMessage (Message msg) - { + handleMessage (Message msg) { AsyncResult ar; int[] ints; String[] strings; @@ -476,8 +366,8 @@ final class ServiceStateTracker extends Handler // This callback is called when signal strength is polled // all by itself - if (!(cm.getRadioState().isOn())) { - // Polling will continue when radio turns back on + if (!(cm.getRadioState().isOn()) || (cm.getRadioState().isCdma())) { + // Polling will continue when radio turns back on and not CDMA return; } ar = (AsyncResult) msg.obj; @@ -591,13 +481,11 @@ final class ServiceStateTracker extends Handler if (ar.exception == null) { mPreferredNetworkType = ((int[])ar.result)[0]; } else { - mPreferredNetworkType = Phone.NT_AUTO_TYPE; + mPreferredNetworkType = RILConstants.NETWORK_MODE_GLOBAL; } message = obtainMessage(EVENT_SET_PREFERRED_NETWORK_TYPE, ar.userObj); - int toggledNetworkType = - (mPreferredNetworkType == Phone.NT_AUTO_TYPE) ? - Phone.NT_GSM_TYPE : Phone.NT_AUTO_TYPE; + int toggledNetworkType = RILConstants.NETWORK_MODE_GLOBAL; cm.setPreferredNetworkType(toggledNetworkType, message); break; @@ -630,42 +518,19 @@ final class ServiceStateTracker extends Handler onRestrictedStateChanged(ar); break; + default: + Log.e(LOG_TAG, "Unhandled message with number: " + msg.what); + break; } } //***** Private Instance Methods - private void updateSpnDisplay() { - int rule = phone.mSIMRecords.getDisplayRule(ss.getOperatorNumeric()); - String spn = phone.mSIMRecords.getServiceProviderName(); - String plmn = ss.getOperatorAlphaLong(); - - if (rule != curSpnRule - || !TextUtils.equals(spn, curSpn) - || !TextUtils.equals(plmn, curPlmn)) { - boolean showSpn = - (rule & SIMRecords.SPN_RULE_SHOW_SPN) == SIMRecords.SPN_RULE_SHOW_SPN; - boolean showPlmn = - (rule & SIMRecords.SPN_RULE_SHOW_PLMN) == SIMRecords.SPN_RULE_SHOW_PLMN; - Intent intent = new Intent(Intents.SPN_STRINGS_UPDATED_ACTION); - intent.putExtra(Intents.EXTRA_SHOW_SPN, showSpn); - intent.putExtra(Intents.EXTRA_SPN, spn); - intent.putExtra(Intents.EXTRA_SHOW_PLMN, showPlmn); - intent.putExtra(Intents.EXTRA_PLMN, plmn); - phone.getContext().sendStickyBroadcast(intent); - } - curSpnRule = rule; - curSpn = spn; - curPlmn = plmn; - } - - private void - setPowerStateToDesired() + protected void setPowerStateToDesired() { // If we want it on and it's off, turn it on if (mDesiredPowerState - && cm.getRadioState() == CommandsInterface.RadioState.RADIO_OFF - ) { + && cm.getRadioState() == CommandsInterface.RadioState.RADIO_OFF) { cm.setRadioPower(true, null); } else if (!mDesiredPowerState && cm.getRadioState().isOn()) { DataConnectionTracker dcTracker = phone.mDataConnection; @@ -681,8 +546,8 @@ final class ServiceStateTracker extends Handler // poll data state up to 15 times, with a 100ms delay // totaling 1.5 sec. Normal data disable action will finish in 100ms. for (int i = 0; i < MAX_NUM_DATA_STATE_READS; i++) { - if (dcTracker.state != State.CONNECTED - && dcTracker.state != State.DISCONNECTING) { + if (dcTracker.getState() != DataConnectionTracker.State.CONNECTED + && dcTracker.getState() != DataConnectionTracker.State.DISCONNECTING) { Log.d(LOG_TAG, "Data shutdown complete."); break; } @@ -692,22 +557,37 @@ final class ServiceStateTracker extends Handler cm.setRadioPower(false, null); } // Otherwise, we're in the desired state } + + protected void updateSpnDisplay() { + int rule = phone.mSIMRecords.getDisplayRule(ss.getOperatorNumeric()); + String spn = phone.mSIMRecords.getServiceProviderName(); + String plmn = ss.getOperatorAlphaLong(); - /** Cancel a pending (if any) pollState() operation */ - private void - cancelPollState() - { - // This will effectively cancel the rest of the poll requests - pollingContext = new int[1]; + if (rule != curSpnRule + || !TextUtils.equals(spn, curSpn) + || !TextUtils.equals(plmn, curPlmn)) { + boolean showSpn = + (rule & SIMRecords.SPN_RULE_SHOW_SPN) == SIMRecords.SPN_RULE_SHOW_SPN; + boolean showPlmn = + (rule & SIMRecords.SPN_RULE_SHOW_PLMN) == SIMRecords.SPN_RULE_SHOW_PLMN; + Intent intent = new Intent(Intents.SPN_STRINGS_UPDATED_ACTION); + intent.putExtra(Intents.EXTRA_SHOW_SPN, showSpn); + intent.putExtra(Intents.EXTRA_SPN, spn); + intent.putExtra(Intents.EXTRA_SHOW_PLMN, showPlmn); + intent.putExtra(Intents.EXTRA_PLMN, plmn); + phone.getContext().sendStickyBroadcast(intent); + } + curSpnRule = rule; + curSpn = spn; + curPlmn = plmn; } /** * Handle the result of one of the pollState()-related requests */ - private void - handlePollStateResult (int what, AsyncResult ar) - { + protected void + handlePollStateResult (int what, AsyncResult ar) { int ints[]; String states[]; @@ -820,8 +700,7 @@ final class ServiceStateTracker extends Handler } private void - setRssiDefaultValues() - { + setRssiDefaultValues() { rssi = 99; } @@ -835,8 +714,7 @@ final class ServiceStateTracker extends Handler */ private void - pollState() - { + pollState() { pollingContext = new int[1]; pollingContext[0] = 0; @@ -850,7 +728,6 @@ final class ServiceStateTracker extends Handler pollStateDone(); break; - case RADIO_OFF: newSS.setStateOff(); newCellLoc.setStateInvalid(); @@ -860,6 +737,20 @@ final class ServiceStateTracker extends Handler pollStateDone(); break; + case RUIM_NOT_READY: + case RUIM_READY: + case RUIM_LOCKED_OR_ABSENT: + case NV_NOT_READY: + case NV_READY: + Log.d(LOG_TAG, "Radio Technology Change ongoing, setting SS to off"); + newSS.setStateOff(); + newCellLoc.setStateInvalid(); + setRssiDefaultValues(); + mGotCountryCode = false; + + pollStateDone(); + break; + default: // Issue all poll-related commands at once // then count down the responses, which @@ -889,6 +780,7 @@ final class ServiceStateTracker extends Handler } private static String networkTypeToString(int type) { + //Network Type from GPRS_REGISTRATION_STATE String ret = "unknown"; switch (type) { @@ -901,14 +793,16 @@ final class ServiceStateTracker extends Handler case DATA_ACCESS_UMTS: ret = "UMTS"; break; + default: + Log.e(LOG_TAG, "Wrong network type: " + Integer.toString(type)); + break; } return ret; } private void - pollStateDone() - { + pollStateDone() { if (DBG) { Log.d(LOG_TAG, "Poll ServiceState done: " + " oldSS=[" + ss + "] newSS=[" + newSS + @@ -1131,9 +1025,8 @@ final class ServiceStateTracker extends Handler } private void - queueNextSignalStrengthPoll() - { - if (dontPollSignalStrength) { + queueNextSignalStrengthPoll() { + if (dontPollSignalStrength || (cm.getRadioState().isCdma())) { // The radio is telling us about signal strength changes // we don't have to ask it return; @@ -1155,8 +1048,7 @@ final class ServiceStateTracker extends Handler * Called both for solicited and unsolicited signal stength updates */ private void - onSignalStrengthResult(AsyncResult ar) - { + onSignalStrengthResult(AsyncResult ar) { int oldRSSI = rssi; if (ar.exception != null) { @@ -1176,15 +1068,21 @@ final class ServiceStateTracker extends Handler } if (rssi != oldRSSI) { - phone.notifySignalStrength(); + try { // This takes care of delayed EVENT_POLL_SIGNAL_STRENGTH (scheduled after + // POLL_PERIOD_MILLIS) during Radio Technology Change) + phone.notifySignalStrength(); + } catch (NullPointerException ex) { + Log.d(LOG_TAG, "onSignalStrengthResult() Phone already destroyed: " + ex + + "Signal Stranth not notified"); + } } } - + /** * Set restricted state based on the OnRestrictedStateChanged notification * If any voice or packet restricted state changes, trigger a UI * notification and notify registrants when sim is ready. - * + * * @param ar an int value of RIL_RESTRICTED_STATE_* */ private void onRestrictedStateChanged(AsyncResult ar) @@ -1201,10 +1099,8 @@ final class ServiceStateTracker extends Handler newRs.setCsEmergencyRestricted( ((state & RILConstants.RIL_RESTRICTED_STATE_CS_EMERGENCY) != 0) || ((state & RILConstants.RIL_RESTRICTED_STATE_CS_ALL) != 0) ); - - //ignore the normal call and data restricted state before SIM READY - if (phone.getSimCard().getState() == SimCard.State.READY){ + if (phone.getIccCard().getState() == IccCard.State.READY) { newRs.setCsNormalRestricted( ((state & RILConstants.RIL_RESTRICTED_STATE_CS_NORMAL) != 0) || ((state & RILConstants.RIL_RESTRICTED_STATE_CS_ALL) != 0) ); @@ -1272,7 +1168,7 @@ final class ServiceStateTracker extends Handler setNotification(CS_NORMAL_ENABLED); } } - + rs = newRs; } Log.d(LOG_TAG, "[DSAC DEB] " + "current rs at return "+ rs); @@ -1280,8 +1176,7 @@ final class ServiceStateTracker extends Handler /** code is registration state 0-5 from TS 27.007 7.2 */ private int - regCodeToServiceState(int code) - { + regCodeToServiceState(int code) { switch (code) { case 0: case 2: // 2 is "searching" @@ -1308,8 +1203,7 @@ final class ServiceStateTracker extends Handler * returns true if registered roam, false otherwise */ private boolean - regCodeIsRoaming (int code) - { + regCodeIsRoaming (int code) { // 5 is "in service -- roam" return 5 == code; } @@ -1323,7 +1217,7 @@ final class ServiceStateTracker extends Handler */ private boolean isRoamingBetweenOperators(boolean gsmRoaming, ServiceState s) { - String spn = SystemProperties.get(PROPERTY_SIM_OPERATOR_ALPHA, "empty"); + String spn = SystemProperties.get(PROPERTY_ICC_OPERATOR_ALPHA, "empty"); String onsl = s.getOperatorAlphaLong(); String onss = s.getOperatorAlphaShort(); @@ -1331,7 +1225,7 @@ final class ServiceStateTracker extends Handler boolean equalsOnsl = onsl != null && spn.equals(onsl); boolean equalsOnss = onss != null && spn.equals(onss); - String simNumeric = SystemProperties.get(PROPERTY_SIM_OPERATOR_NUMERIC, ""); + String simNumeric = SystemProperties.get(PROPERTY_ICC_OPERATOR_NUMERIC, ""); String operatorNumeric = s.getOperatorNumeric(); boolean equalsMcc = true; @@ -1345,8 +1239,7 @@ final class ServiceStateTracker extends Handler } private static - int twoDigitsAt(String s, int offset) - { + int twoDigitsAt(String s, int offset) { int a, b; a = Character.digit(s.charAt(offset), 10); @@ -1631,7 +1524,7 @@ final class ServiceStateTracker extends Handler + (SystemClock.elapsedRealtime() - mSavedAtTime)); } } - + /** * Post a notification to NotificationManager for restricted state * @@ -1640,7 +1533,6 @@ final class ServiceStateTracker extends Handler private void setNotification(int notifyType) { Log.d(LOG_TAG, "[DSAC DEB] " + "create notification " + notifyType); - Context context = phone.getContext(); mNotification = new Notification(); diff --git a/telephony/java/com/android/internal/telephony/gsm/GsmSmsAddress.java b/telephony/java/com/android/internal/telephony/gsm/GsmSmsAddress.java new file mode 100644 index 0000000..c163803 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/gsm/GsmSmsAddress.java @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.gsm; + +import android.telephony.PhoneNumberUtils; + +import com.android.internal.telephony.GsmAlphabet; +import com.android.internal.telephony.SmsAddress; + +public class GsmSmsAddress extends SmsAddress { + + static final int OFFSET_ADDRESS_LENGTH = 0; + + static final int OFFSET_TOA = 1; + + static final int OFFSET_ADDRESS_VALUE = 2; + + /** + * New GsmSmsAddress from TS 23.040 9.1.2.5 Address Field + * + * @param offset the offset of the Address-Length byte + * @param length the length in bytes rounded up, e.g. "2 + + * (addressLength + 1) / 2" + */ + + public GsmSmsAddress(byte[] data, int offset, int length) { + origBytes = new byte[length]; + System.arraycopy(data, offset, origBytes, 0, length); + + // addressLength is the count of semi-octets, not bytes + int addressLength = origBytes[OFFSET_ADDRESS_LENGTH] & 0xff; + + int toa = origBytes[OFFSET_TOA] & 0xff; + ton = 0x7 & (toa >> 4); + + // TOA must have its high bit set + if ((toa & 0x80) != 0x80) { + throw new RuntimeException("Invalid TOA - high bit must be set"); + } + + if (isAlphanumeric()) { + // An alphanumeric address + int countSeptets = addressLength * 4 / 7; + + address = GsmAlphabet.gsm7BitPackedToString(origBytes, + OFFSET_ADDRESS_VALUE, countSeptets); + } else { + // TS 23.040 9.1.2.5 says + // that "the MS shall interpret reserved values as 'Unknown' + // but shall store them exactly as received" + + byte lastByte = origBytes[length - 1]; + + if ((addressLength & 1) == 1) { + // Make sure the final unused BCD digit is 0xf + origBytes[length - 1] |= 0xf0; + } + address = PhoneNumberUtils.calledPartyBCDToString(origBytes, + OFFSET_TOA, length - OFFSET_TOA); + + // And restore origBytes + origBytes[length - 1] = lastByte; + } + } + + public String getAddressString() { + return address; + } + + /** + * Returns true if this is an alphanumeric address + */ + public boolean isAlphanumeric() { + return ton == TON_ALPHANUMERIC; + } + + public boolean isNetworkSpecific() { + return ton == TON_NETWORK; + } + + /** + * Returns true of this is a valid CPHS voice message waiting indicator + * address + */ + public boolean isCphsVoiceMessageIndicatorAddress() { + // CPHS-style MWI message + // See CPHS 4.7 B.4.2.1 + // + // Basically: + // + // - Originating address should be 4 bytes long and alphanumeric + // - Decode will result with two chars: + // - Char 1 + // 76543210 + // ^ set/clear indicator (0 = clear) + // ^^^ type of indicator (000 = voice) + // ^^^^ must be equal to 0001 + // - Char 2: + // 76543210 + // ^ line number (0 = line 1) + // ^^^^^^^ set to 0 + // + // Remember, since the alpha address is stored in 7-bit compact form, + // the "line number" is really the top bit of the first address value + // byte + + return (origBytes[OFFSET_ADDRESS_LENGTH] & 0xff) == 4 + && isAlphanumeric() && (origBytes[OFFSET_TOA] & 0x0f) == 0; + } + + /** + * Returns true if this is a valid CPHS voice message waiting indicator + * address indicating a "set" of "indicator 1" of type "voice message + * waiting" + */ + public boolean isCphsVoiceMessageSet() { + // 0x11 means "set" "voice message waiting" "indicator 1" + return isCphsVoiceMessageIndicatorAddress() + && (origBytes[OFFSET_ADDRESS_VALUE] & 0xff) == 0x11; + + } + + /** + * Returns true if this is a valid CPHS voice message waiting indicator + * address indicating a "clear" of "indicator 1" of type "voice message + * waiting" + */ + public boolean isCphsVoiceMessageClear() { + // 0x10 means "clear" "voice message waiting" "indicator 1" + return isCphsVoiceMessageIndicatorAddress() + && (origBytes[OFFSET_ADDRESS_VALUE] & 0xff) == 0x10; + + } +} diff --git a/telephony/java/com/android/internal/telephony/gsm/MccTable.java b/telephony/java/com/android/internal/telephony/gsm/MccTable.java index bb17cc4..8473a21 100644 --- a/telephony/java/com/android/internal/telephony/gsm/MccTable.java +++ b/telephony/java/com/android/internal/telephony/gsm/MccTable.java @@ -62,11 +62,11 @@ public final class MccTable entryForMcc(int mcc) { int index; - + MccEntry m; m = new MccEntry(mcc, null, 0); - + index = Collections.binarySearch(table, m); if (index < 0) { @@ -154,7 +154,7 @@ public final class MccTable /* * The table below is built from two resources: - * + * * 1) ITU "Mobile Network Code (MNC) for the international * identification plan for mobile terminals and mobile users" * which is available as an annex to the ITU operational bulletin diff --git a/telephony/java/com/android/internal/telephony/gsm/NetworkInfo.aidl b/telephony/java/com/android/internal/telephony/gsm/NetworkInfo.aidl index c600530..d88d0b7 100644 --- a/telephony/java/com/android/internal/telephony/gsm/NetworkInfo.aidl +++ b/telephony/java/com/android/internal/telephony/gsm/NetworkInfo.aidl @@ -16,11 +16,11 @@ package com.android.internal.telephony.gsm; -/** +/** * Used to indicate that the NetworkInfo object is parcelable to aidl. * This is a simple effort to make NetworkInfo parcelable rather than * trying to make the conventional containing object (AsyncResult), - * implement parcelable. This functionality is needed for the + * implement parcelable. This functionality is needed for the * NetworkQueryService to fix 1128695 */ parcelable NetworkInfo; diff --git a/telephony/java/com/android/internal/telephony/gsm/NetworkInfo.java b/telephony/java/com/android/internal/telephony/gsm/NetworkInfo.java index bebf9ba..04fd13e 100644 --- a/telephony/java/com/android/internal/telephony/gsm/NetworkInfo.java +++ b/telephony/java/com/android/internal/telephony/gsm/NetworkInfo.java @@ -22,8 +22,7 @@ import android.os.Parcelable; /** * {@hide} */ -public class NetworkInfo implements Parcelable -{ +public class NetworkInfo implements Parcelable { public enum State { UNKNOWN, AVAILABLE, @@ -39,34 +38,29 @@ public class NetworkInfo implements Parcelable public String - getOperatorAlphaLong() - { + getOperatorAlphaLong() { return operatorAlphaLong; } public String - getOperatorAlphaShort() - { + getOperatorAlphaShort() { return operatorAlphaShort; } public String - getOperatorNumeric() - { + getOperatorNumeric() { return operatorNumeric; } public State - getState() - { + getState() { return state; } - NetworkInfo(String operatorAlphaLong, - String operatorAlphaShort, - String operatorNumeric, - State state) - { + NetworkInfo(String operatorAlphaLong, + String operatorAlphaShort, + String operatorNumeric, + State state) { this.operatorAlphaLong = operatorAlphaLong; this.operatorAlphaShort = operatorAlphaShort; @@ -76,20 +70,18 @@ public class NetworkInfo implements Parcelable } - NetworkInfo(String operatorAlphaLong, - String operatorAlphaShort, - String operatorNumeric, - String stateString) - { - this (operatorAlphaLong, operatorAlphaShort, + public NetworkInfo(String operatorAlphaLong, + String operatorAlphaShort, + String operatorNumeric, + String stateString) { + this (operatorAlphaLong, operatorAlphaShort, operatorNumeric, rilStateToState(stateString)); } /** * See state strings defined in ril.h RIL_REQUEST_QUERY_AVAILABLE_NETWORKS */ - private static State rilStateToState(String s) - { + private static State rilStateToState(String s) { if (s.equals("unknown")) { return State.UNKNOWN; } else if (s.equals("available")) { @@ -105,29 +97,28 @@ public class NetworkInfo implements Parcelable } - public String toString() - { - return "NetworkInfo " + operatorAlphaLong - + "/" + operatorAlphaShort - + "/" + operatorNumeric + public String toString() { + return "NetworkInfo " + operatorAlphaLong + + "/" + operatorAlphaShort + + "/" + operatorNumeric + "/" + state; } - - /** + + /** * Parcelable interface implemented below. * This is a simple effort to make NetworkInfo parcelable rather than * trying to make the conventional containing object (AsyncResult), - * implement parcelable. This functionality is needed for the + * implement parcelable. This functionality is needed for the * NetworkQueryService to fix 1128695. */ - + public int describeContents() { return 0; } - /** + /** * Implement the Parcelable interface. - * Method to serialize a NetworkInfo object. + * Method to serialize a NetworkInfo object. */ public void writeToParcel(Parcel dest, int flags) { dest.writeString(operatorAlphaLong); @@ -136,9 +127,9 @@ public class NetworkInfo implements Parcelable dest.writeSerializable(state); } - /** + /** * Implement the Parcelable interface - * Method to deserialize a NetworkInfo object, or an array thereof. + * Method to deserialize a NetworkInfo object, or an array thereof. */ public static final Creator<NetworkInfo> CREATOR = new Creator<NetworkInfo>() { diff --git a/telephony/java/com/android/internal/telephony/gsm/PDPContextState.java b/telephony/java/com/android/internal/telephony/gsm/PDPContextState.java index d5d481a..feb78f8 100644 --- a/telephony/java/com/android/internal/telephony/gsm/PDPContextState.java +++ b/telephony/java/com/android/internal/telephony/gsm/PDPContextState.java @@ -19,8 +19,7 @@ package com.android.internal.telephony.gsm; /** * {@hide} */ -public class PDPContextState -{ +public class PDPContextState { public int cid; public boolean active; public String type; diff --git a/telephony/java/com/android/internal/telephony/gsm/PdpConnection.java b/telephony/java/com/android/internal/telephony/gsm/PdpConnection.java index 66f8b72..88acb1b 100644 --- a/telephony/java/com/android/internal/telephony/gsm/PdpConnection.java +++ b/telephony/java/com/android/internal/telephony/gsm/PdpConnection.java @@ -17,88 +17,26 @@ package com.android.internal.telephony.gsm; import android.os.*; -import android.database.Cursor; -import android.provider.Telephony; import android.text.util.Regex; import android.util.EventLog; import android.util.Log; -import java.util.ArrayList; +import com.android.internal.telephony.CommandException; +import com.android.internal.telephony.DataConnection; +import com.android.internal.telephony.DataLink; import com.android.internal.telephony.Phone; +import com.android.internal.telephony.RILConstants; +import com.android.internal.telephony.TelephonyEventLog; /** * {@hide} */ -public class PdpConnection extends Handler { +public class PdpConnection extends DataConnection { private static final String LOG_TAG = "GSM"; private static final boolean DBG = true; private static final boolean FAKE_FAIL = false; - public enum PdpState { - ACTIVE, /* has active pdp context */ - ACTIVATING, /* during connecting process */ - INACTIVE; /* has empty pdp context */ - - public String toString() { - switch (this) { - case ACTIVE: return "active"; - case ACTIVATING: return "setting up"; - default: return "inactive"; - } - } - - public boolean isActive() { - return this == ACTIVE; - } - - public boolean isInactive() { - return this == INACTIVE; - } - } - - public enum PdpFailCause { - NONE, - BAD_APN, - BAD_PAP_SECRET, - BARRED, - USER_AUTHENTICATION, - SERVICE_OPTION_NOT_SUPPORTED, - SERVICE_OPTION_NOT_SUBSCRIBED, - SIM_LOCKED, - RADIO_OFF, - NO_SIGNAL, - NO_DATA_PLAN, - RADIO_NOT_AVIALABLE, - SUSPENED_TEMPORARY, - RADIO_ERROR_RETRY, - UNKNOWN; - - public boolean isPermanentFail() { - return (this == RADIO_OFF); - } - - public String toString() { - switch (this) { - case NONE: return "no error"; - case BAD_APN: return "bad apn"; - case BAD_PAP_SECRET:return "bad pap secret"; - case BARRED: return "barred"; - case USER_AUTHENTICATION: return "error user autentication"; - case SERVICE_OPTION_NOT_SUPPORTED: return "data not supported"; - case SERVICE_OPTION_NOT_SUBSCRIBED: return "datt not subcribed"; - case SIM_LOCKED: return "sim locked"; - case RADIO_OFF: return "radio is off"; - case NO_SIGNAL: return "no signal"; - case NO_DATA_PLAN: return "no data plan"; - case RADIO_NOT_AVIALABLE: return "radio not available"; - case SUSPENED_TEMPORARY: return "suspend temporary"; - case RADIO_ERROR_RETRY: return "transient radio error"; - default: return "unknown data error"; - } - } - } - /** Fail cause of last PDP activate, from RIL_LastPDPActivateFailCause */ private static final int PDP_FAIL_RIL_BARRED = 8; private static final int PDP_FAIL_RIL_BAD_APN = 27; @@ -107,54 +45,20 @@ public class PdpConnection extends Handler { private static final int PDP_FAIL_RIL_SERVICE_OPTION_NOT_SUBSCRIBED = 33; private static final int PDP_FAIL_RIL_ERROR_UNSPECIFIED = 0xffff; - //***** Event codes - private static final int EVENT_SETUP_PDP_DONE = 1; - private static final int EVENT_GET_LAST_FAIL_DONE = 2; - private static final int EVENT_LINK_STATE_CHANGED = 3; - private static final int EVENT_DEACTIVATE_DONE = 4; - private static final int EVENT_FORCE_RETRY = 5; - //***** Instance Variables - private GSMPhone phone; private String pdp_name; - private PdpState state; - private Message onConnectCompleted; - private Message onDisconnect; - private int cid; - private long createTime; - private long lastFailTime; - private PdpFailCause lastFailCause; private ApnSetting apn; - private String interfaceName; - private String ipAddress; - private String gatewayAddress; - private String[] dnsServers; - - private static final String NULL_IP = "0.0.0.0"; // dataLink is only used to support pppd link - DataLink dataLink; - // receivedDisconnectReq is set when disconnect pdp link during activating - private boolean receivedDisconnectReq; + private DataLink dataLink; //***** Constructor - PdpConnection(GSMPhone phone) - { - this.phone = phone; - this.state = PdpState.INACTIVE; - onConnectCompleted = null; - onDisconnect = null; - this.cid = -1; - this.createTime = -1; - this.lastFailTime = -1; - this.lastFailCause = PdpFailCause.NONE; - this.apn = null; + PdpConnection(GSMPhone phone) { + super(phone); this.dataLink = null; - receivedDisconnectReq = false; - this.dnsServers = new String[2]; if (SystemProperties.get("ro.radio.use-ppp","no").equals("yes")) { - dataLink = new PppLink(phone.mDataConnection); + dataLink = new PppLink((GsmDataConnectionTracker) phone.mDataConnection, phone); dataLink.setOnLinkChange(this, EVENT_LINK_STATE_CHANGED, null); } } @@ -171,37 +75,37 @@ public class PdpConnection extends Handler { setHttpProxy (apn.proxy, apn.port); - state = PdpState.ACTIVATING; + state = State.ACTIVATING; this.apn = apn; onConnectCompleted = onCompleted; createTime = -1; lastFailTime = -1; - lastFailCause = PdpFailCause.NONE; + lastFailCause = FailCause.NONE; receivedDisconnectReq = false; if (FAKE_FAIL) { // for debug before baseband implement error in setup PDP if (apn.apn.equalsIgnoreCase("badapn")){ - notifyFail(PdpFailCause.BAD_APN, onConnectCompleted); + notifyFail(FailCause.BAD_APN, onConnectCompleted); return; } } - phone.mCM.setupDefaultPDP(apn.apn, apn.user, apn.password, - obtainMessage(EVENT_SETUP_PDP_DONE)); + phone.mCM.setupDataCall(Integer.toString(RILConstants.GSM_PHONE), null, apn.apn, apn.user, + apn.password, obtainMessage(EVENT_SETUP_DATA_CONNECTION_DONE)); } - void disconnect(Message msg) { + protected void disconnect(Message msg) { onDisconnect = msg; - if (state == PdpState.ACTIVE) { + if (state == State.ACTIVE) { if (dataLink != null) { dataLink.disconnect(); } if (phone.mCM.getRadioState().isOn()) { - phone.mCM.deactivateDefaultPDP(cid, obtainMessage(EVENT_DEACTIVATE_DONE, msg)); + phone.mCM.deactivateDataCall(cid, obtainMessage(EVENT_DEACTIVATE_DONE, msg)); } - } else if (state == PdpState.ACTIVATING) { + } else if (state == State.ACTIVATING) { receivedDisconnectReq = true; } else { // state == INACTIVE. Nothing to do, so notify immediately. @@ -209,20 +113,9 @@ public class PdpConnection extends Handler { } } - private void - setHttpProxy(String httpProxy, String httpPort) - { - if (httpProxy == null || httpProxy.length() == 0) { - phone.setSystemProperty("net.gprs.http-proxy", null); - return; - } - - if (httpPort == null || httpPort.length() == 0) { - httpPort = "8080"; // Default to port 8080 - } - - phone.setSystemProperty("net.gprs.http-proxy", - "http://" + httpProxy + ":" + httpPort + "/"); + public void clearSettings() { + super.clearSettings(); + apn = null; } public String toString() { @@ -231,61 +124,30 @@ public class PdpConnection extends Handler { " lastFailCause=" + lastFailCause; } - public long getConnectionTime() { - return createTime; - } - - public long getLastFailTime() { - return lastFailTime; - } - - public PdpFailCause getLastFailCause() { - return lastFailCause; - } - - public ApnSetting getApn() { - return apn; - } - - String getInterface() { - return interfaceName; - } - - String getIpAddress() { - return ipAddress; - } - - String getGatewayAddress() { - return gatewayAddress; - } - - String[] getDnsServers() { - return dnsServers; - } - - public PdpState getState() { - return state; - } - private void notifyFail(PdpFailCause cause, Message onCompleted) { + protected void notifyFail(FailCause cause, Message onCompleted) { if (onCompleted == null) return; - state = PdpState.INACTIVE; + state = State.INACTIVE; lastFailCause = cause; lastFailTime = System.currentTimeMillis(); onConnectCompleted = null; - if (DBG) log("Notify PDP fail at " + lastFailTime - + " due to " + lastFailCause); + if (DBG) { + log("Notify PDP fail at " + lastFailTime + + " due to " + lastFailCause); + } AsyncResult.forMessage(onCompleted, cause, new Exception()); onCompleted.sendToTarget(); } - private void notifySuccess(Message onCompleted) { - if (onCompleted == null) return; + protected void notifySuccess(Message onCompleted) { + if (onCompleted == null) { + return; + } - state = PdpState.ACTIVE; + state = State.ACTIVE; createTime = System.currentTimeMillis(); onConnectCompleted = null; onCompleted.arg1 = cid; @@ -296,7 +158,7 @@ public class PdpConnection extends Handler { onCompleted.sendToTarget(); } - private void notifyDisconnect(Message msg) { + protected void notifyDisconnect(Message msg) { if (DBG) log("Notify PDP disconnect"); if (msg != null) { @@ -306,22 +168,7 @@ public class PdpConnection extends Handler { clearSettings(); } - void clearSettings() { - state = PdpState.INACTIVE; - receivedDisconnectReq = false; - createTime = -1; - lastFailTime = -1; - lastFailCause = PdpFailCause.NONE; - apn = null; - onConnectCompleted = null; - interfaceName = null; - ipAddress = null; - gatewayAddress = null; - dnsServers[0] = null; - dnsServers[1] = null; - } - - private void onLinkStateChanged(DataLink.LinkState linkState) { + protected void onLinkStateChanged(DataLink.LinkState linkState) { switch (linkState) { case LINK_UP: notifySuccess(onConnectCompleted); @@ -335,151 +182,110 @@ public class PdpConnection extends Handler { } } - private PdpFailCause getFailCauseFromRequest(int rilCause) { - PdpFailCause cause; + protected FailCause getFailCauseFromRequest(int rilCause) { + FailCause cause; switch (rilCause) { case PDP_FAIL_RIL_BARRED: - cause = PdpFailCause.BARRED; + cause = FailCause.BARRED; break; case PDP_FAIL_RIL_BAD_APN: - cause = PdpFailCause.BAD_APN; + cause = FailCause.BAD_APN; break; case PDP_FAIL_RIL_USER_AUTHENTICATION: - cause = PdpFailCause.USER_AUTHENTICATION; + cause = FailCause.USER_AUTHENTICATION; break; case PDP_FAIL_RIL_SERVICE_OPTION_NOT_SUPPORTED: - cause = PdpFailCause.SERVICE_OPTION_NOT_SUPPORTED; + cause = FailCause.SERVICE_OPTION_NOT_SUPPORTED; break; case PDP_FAIL_RIL_SERVICE_OPTION_NOT_SUBSCRIBED: - cause = PdpFailCause.SERVICE_OPTION_NOT_SUBSCRIBED; + cause = FailCause.SERVICE_OPTION_NOT_SUBSCRIBED; break; default: - cause = PdpFailCause.UNKNOWN; + cause = FailCause.UNKNOWN; } return cause; } - - private void log(String s) { + protected void log(String s) { Log.d(LOG_TAG, "[PdpConnection] " + s); } @Override - public void handleMessage(Message msg) { - AsyncResult ar; - - switch (msg.what) { - case EVENT_SETUP_PDP_DONE: - ar = (AsyncResult) msg.obj; - - if (ar.exception != null) { - Log.e(LOG_TAG, "PDP Context Init failed " + ar.exception); - - if (receivedDisconnectReq) { - // Don't bother reporting the error if there's already a - // pending disconnect request, since DataConnectionTracker - // has already updated its state. - notifyDisconnect(onDisconnect); - } else { - if ( ar.exception instanceof CommandException && - ((CommandException) (ar.exception)).getCommandError() - == CommandException.Error.RADIO_NOT_AVAILABLE) { - notifyFail(PdpFailCause.RADIO_NOT_AVIALABLE, - onConnectCompleted); - } else { - phone.mCM.getLastPdpFailCause( - obtainMessage(EVENT_GET_LAST_FAIL_DONE)); - } - } + protected void onDeactivated(AsyncResult ar) { + notifyDisconnect((Message) ar.userObj); + if (DBG) log("PDP Connection Deactivated"); + } + + @Override + protected void onSetupConnectionCompleted(AsyncResult ar) { + if (ar.exception != null) { + Log.e(LOG_TAG, "PDP Context Init failed " + ar.exception); + + if (receivedDisconnectReq) { + // Don't bother reporting the error if there's already a + // pending disconnect request, since DataConnectionTracker + // has already updated its state. + notifyDisconnect(onDisconnect); + } else { + if ( ar.exception instanceof CommandException && + ((CommandException) (ar.exception)).getCommandError() + == CommandException.Error.RADIO_NOT_AVAILABLE) { + notifyFail(FailCause.RADIO_NOT_AVAILABLE, + onConnectCompleted); } else { - if (receivedDisconnectReq) { - // Don't bother reporting success if there's already a - // pending disconnect request, since DataConnectionTracker - // has already updated its state. - // Set ACTIVE so that disconnect does the right thing. - state = PdpState.ACTIVE; - disconnect(onDisconnect); - } else { - String[] response = ((String[]) ar.result); - cid = Integer.parseInt(response[0]); - - if (response.length > 2) { - interfaceName = response[1]; - ipAddress = response[2]; - String prefix = "net." + interfaceName + "."; - gatewayAddress = SystemProperties.get(prefix + "gw"); - dnsServers[0] = SystemProperties.get(prefix + "dns1"); - dnsServers[1] = SystemProperties.get(prefix + "dns2"); - if (DBG) { - log("interface=" + interfaceName + " ipAddress=" + ipAddress - + " gateway=" + gatewayAddress + " DNS1=" + dnsServers[0] - + " DNS2=" + dnsServers[1]); - } - - if (NULL_IP.equals(dnsServers[0]) && NULL_IP.equals(dnsServers[1]) - && !phone.isDnsCheckDisabled()) { - // Work around a race condition where QMI does not fill in DNS: - // Deactivate PDP and let DataConnectionTracker retry. - // Do not apply the race condition workaround for MMS APN - // if Proxy is an IP-address. - // Otherwise, the default APN will not be restored anymore. - if (!apn.types[0].equals(Phone.APN_TYPE_MMS) - || !isIpAddress(apn.mmsProxy)) { - EventLog.writeEvent(TelephonyEventLog.EVENT_LOG_BAD_DNS_ADDRESS, - dnsServers[0]); - phone.mCM.deactivateDefaultPDP(cid, - obtainMessage(EVENT_FORCE_RETRY)); - break; - } - } - } + phone.mCM.getLastPdpFailCause( + obtainMessage(EVENT_GET_LAST_FAIL_DONE)); + } + } + } else { + if (receivedDisconnectReq) { + // Don't bother reporting success if there's already a + // pending disconnect request, since DataConnectionTracker + // has already updated its state. + disconnect(onDisconnect); + } else { + String[] response = ((String[]) ar.result); + cid = Integer.parseInt(response[0]); + + if (response.length > 2) { + interfaceName = response[1]; + ipAddress = response[2]; + String prefix = "net." + interfaceName + "."; + gatewayAddress = SystemProperties.get(prefix + "gw"); + dnsServers[0] = SystemProperties.get(prefix + "dns1"); + dnsServers[1] = SystemProperties.get(prefix + "dns2"); + if (DBG) { + log("interface=" + interfaceName + " ipAddress=" + ipAddress + + " gateway=" + gatewayAddress + " DNS1=" + dnsServers[0] + + " DNS2=" + dnsServers[1]); + } - if (dataLink != null) { - dataLink.connect(); - } else { - onLinkStateChanged(DataLink.LinkState.LINK_UP); + if (NULL_IP.equals(dnsServers[0]) && NULL_IP.equals(dnsServers[1]) + && !((GSMPhone) phone).isDnsCheckDisabled()) { + // Work around a race condition where QMI does not fill in DNS: + // Deactivate PDP and let DataConnectionTracker retry. + // Do not apply the race condition workaround for MMS APN + // if Proxy is an IP-address. + // Otherwise, the default APN will not be restored anymore. + if (!apn.types[0].equals(Phone.APN_TYPE_MMS) + || !isIpAddress(apn.mmsProxy)) { + EventLog.writeEvent(TelephonyEventLog.EVENT_LOG_BAD_DNS_ADDRESS, + dnsServers[0]); + phone.mCM.deactivateDataCall(cid, obtainMessage(EVENT_FORCE_RETRY)); + return; } - - if (DBG) log("PDP setup on cid = " + cid); } } - break; - case EVENT_FORCE_RETRY: - if (receivedDisconnectReq) { - notifyDisconnect(onDisconnect); - } else { - ar = (AsyncResult) msg.obj; - notifyFail(PdpFailCause.RADIO_ERROR_RETRY, onConnectCompleted); - } - break; - case EVENT_GET_LAST_FAIL_DONE: - if (receivedDisconnectReq) { - // Don't bother reporting the error if there's already a - // pending disconnect request, since DataConnectionTracker - // has already updated its state. - notifyDisconnect(onDisconnect); - } else { - ar = (AsyncResult) msg.obj; - PdpFailCause cause = PdpFailCause.UNKNOWN; - if (ar.exception == null) { - int rilFailCause = ((int[]) (ar.result))[0]; - cause = getFailCauseFromRequest(rilFailCause); - } - notifyFail(cause, onConnectCompleted); + if (dataLink != null) { + dataLink.connect(); + } else { + onLinkStateChanged(DataLink.LinkState.LINK_UP); } - break; - case EVENT_LINK_STATE_CHANGED: - ar = (AsyncResult) msg.obj; - DataLink.LinkState ls = (DataLink.LinkState) ar.result; - onLinkStateChanged(ls); - break; - case EVENT_DEACTIVATE_DONE: - ar = (AsyncResult) msg.obj; - notifyDisconnect((Message) ar.userObj); - break; + if (DBG) log("PDP setup on cid = " + cid); + } } } @@ -488,4 +294,8 @@ public class PdpConnection extends Handler { return Regex.IP_ADDRESS_PATTERN.matcher(apn.mmsProxy).matches(); } + + public ApnSetting getApn() { + return this.apn; + } } diff --git a/telephony/java/com/android/internal/telephony/gsm/PppLink.java b/telephony/java/com/android/internal/telephony/gsm/PppLink.java index 43d4f1f..9627696 100644 --- a/telephony/java/com/android/internal/telephony/gsm/PppLink.java +++ b/telephony/java/com/android/internal/telephony/gsm/PppLink.java @@ -16,28 +16,31 @@ package com.android.internal.telephony.gsm; -import java.io.FileNotFoundException; -import java.io.FileOutputStream; -import java.io.IOException; -import java.io.RandomAccessFile; - import android.database.Cursor; import android.os.Message; import android.os.SystemProperties; import android.os.SystemService; -import com.android.internal.telephony.gsm.DataConnectionTracker.State; -import com.android.internal.util.ArrayUtils; import android.util.Log; +import com.android.internal.telephony.DataLink; +import com.android.internal.telephony.DataConnectionTracker.State; +import com.android.internal.telephony.PhoneBase; +import com.android.internal.util.ArrayUtils; + +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.RandomAccessFile; + /** * Represents a PPP link. - * + * * Ideally this would be managed by the RIL implementation, but * we currently have implementations where this is not the case. * * {@hide} */ -final class PppLink extends DataLink implements DataLinkInterface { +final class PppLink extends DataLink { private static final String LOG_TAG = "GSM"; static final String PATH_PPP_OPERSTATE = "/sys/class/net/ppp0/operstate"; @@ -69,11 +72,14 @@ final class PppLink extends DataLink implements DataLinkInterface { }; private final byte[] mCheckPPPBuffer = new byte[32]; + private PhoneBase phone; + int lastPppdExitCode = EXIT_OK; - PppLink(DataConnectionTracker dc) { + PppLink(GsmDataConnectionTracker dc, GSMPhone p) { super(dc); + this.phone = p; } public void connect() { @@ -131,7 +137,7 @@ final class PppLink extends DataLink implements DataLinkInterface { checkPPP(); // keep polling in case interface goes down - if (dataConnection.state != State.IDLE) { + if (dataConnection.getState() != State.IDLE) { Message poll = obtainMessage(); poll.what = EVENT_POLL_DATA_CONNECTION; sendMessageDelayed(poll, POLL_SYSFS_MILLIS); @@ -141,7 +147,7 @@ final class PppLink extends DataLink implements DataLinkInterface { } private void checkPPP() { - boolean connecting = (dataConnection.state == State.CONNECTING); + boolean connecting = (dataConnection.getState() == State.CONNECTING); try { RandomAccessFile file = new RandomAccessFile(PATH_PPP_OPERSTATE, "r"); @@ -152,10 +158,10 @@ final class PppLink extends DataLink implements DataLinkInterface { // "unknown" where one might otherwise expect "up" if (ArrayUtils.equals(mCheckPPPBuffer, UP_ASCII_STRING, UP_ASCII_STRING.length) || ArrayUtils.equals(mCheckPPPBuffer, UNKNOWN_ASCII_STRING, - UNKNOWN_ASCII_STRING.length) - && dataConnection.state == State.CONNECTING) { + UNKNOWN_ASCII_STRING.length) + && dataConnection.getState() == State.CONNECTING) { - Log.i(LOG_TAG, + Log.i(LOG_TAG, "found ppp interface. Notifying GPRS connected"); if (mLinkChangeRegistrant != null) { @@ -163,23 +169,23 @@ final class PppLink extends DataLink implements DataLinkInterface { } connecting = false; - } else if (dataConnection.state == State.CONNECTED + } else if (dataConnection.getState() == State.CONNECTED && ArrayUtils.equals(mCheckPPPBuffer, DOWN_ASCII_STRING, - DOWN_ASCII_STRING.length)) { + DOWN_ASCII_STRING.length)) { - Log.i(LOG_TAG, + Log.i(LOG_TAG, "ppp interface went down. Reconnecting..."); if (mLinkChangeRegistrant != null) { mLinkChangeRegistrant.notifyResult(LinkState.LINK_DOWN); } - } + } } catch (IOException ex) { if (! (ex instanceof FileNotFoundException)) { Log.i(LOG_TAG, "Poll ppp0 ex " + ex.toString()); } - if (dataConnection.state == State.CONNECTED && + if (dataConnection.getState() == State.CONNECTED && mLinkChangeRegistrant != null) { mLinkChangeRegistrant.notifyResult(LinkState.LINK_DOWN); } @@ -206,4 +212,8 @@ final class PppLink extends DataLink implements DataLinkInterface { } } + + protected void log(String s) { + Log.d(LOG_TAG, "[PppLink] " + s); + } } diff --git a/telephony/java/com/android/internal/telephony/gsm/SIMFileHandler.java b/telephony/java/com/android/internal/telephony/gsm/SIMFileHandler.java index 81fc657..ead1327 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SIMFileHandler.java +++ b/telephony/java/com/android/internal/telephony/gsm/SIMFileHandler.java @@ -16,506 +16,54 @@ package com.android.internal.telephony.gsm; -import com.android.internal.telephony.*; -import com.android.internal.telephony.gsm.stk.ImageDescriptor; import android.os.*; import android.os.AsyncResult; -import android.os.RegistrantList; -import android.os.Registrant; import android.util.Log; + +import com.android.internal.telephony.IccConstants; +import com.android.internal.telephony.IccException; +import com.android.internal.telephony.IccFileHandler; +import com.android.internal.telephony.IccFileTypeMismatch; +import com.android.internal.telephony.IccIoResult; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.PhoneProxy; + import java.util.ArrayList; /** * {@hide} */ -public final class SIMFileHandler extends Handler -{ +public final class SIMFileHandler extends IccFileHandler { static final String LOG_TAG = "GSM"; - //from TS 11.11 9.1 or elsewhere - static private final int COMMAND_READ_BINARY = 0xb0; - static private final int COMMAND_UPDATE_BINARY = 0xd6; - static private final int COMMAND_READ_RECORD = 0xb2; - static private final int COMMAND_UPDATE_RECORD = 0xdc; - static private final int COMMAND_SEEK = 0xa2; - static private final int COMMAND_GET_RESPONSE = 0xc0; - - // from TS 11.11 9.2.5 - static private final int READ_RECORD_MODE_ABSOLUTE = 4; - - //***** types of files TS 11.11 9.3 - static private final int EF_TYPE_TRANSPARENT = 0; - static private final int EF_TYPE_LINEAR_FIXED = 1; - static private final int EF_TYPE_CYCLIC = 3; - - //***** types of files TS 11.11 9.3 - static private final int TYPE_RFU = 0; - static private final int TYPE_MF = 1; - static private final int TYPE_DF = 2; - static private final int TYPE_EF = 4; - - // size of GET_RESPONSE for EF - static private final int GET_RESPONSE_EF_SIZE_BYTES = 15; - - // Byte order received in response to COMMAND_GET_RESPONSE - // Refer TS 51.011 Section 9.2.1 - static private final int RESPONSE_DATA_RFU_1 = 0; - static private final int RESPONSE_DATA_RFU_2 = 1; - - static private final int RESPONSE_DATA_FILE_SIZE_1 = 2; - static private final int RESPONSE_DATA_FILE_SIZE_2 = 3; - - static private final int RESPONSE_DATA_FILE_ID_1 = 4; - static private final int RESPONSE_DATA_FILE_ID_2 = 5; - static private final int RESPONSE_DATA_FILE_TYPE = 6; - static private final int RESPONSE_DATA_RFU_3 = 7; - static private final int RESPONSE_DATA_ACCESS_CONDITION_1 = 8; - static private final int RESPONSE_DATA_ACCESS_CONDITION_2 = 9; - static private final int RESPONSE_DATA_ACCESS_CONDITION_3 = 10; - static private final int RESPONSE_DATA_FILE_STATUS = 11; - static private final int RESPONSE_DATA_LENGTH = 12; - static private final int RESPONSE_DATA_STRUCTURE = 13; - static private final int RESPONSE_DATA_RECORD_LENGTH = 14; - - //***** Instance Variables - GSMPhone phone; - - //***** Events - - /** Finished retrieving size of transparent EF; start loading. */ - static private final int EVENT_GET_BINARY_SIZE_DONE = 4; - /** Finished loading contents of transparent EF; post result. */ - static private final int EVENT_READ_BINARY_DONE = 5; - /** Finished retrieving size of records for linear-fixed EF; now load. */ - static private final int EVENT_GET_RECORD_SIZE_DONE = 6; - /** Finished loading single record from a linear-fixed EF; post result. */ - static private final int EVENT_READ_RECORD_DONE = 7; - /** Finished retrieving record size; post result. */ - static private final int EVENT_GET_EF_LINEAR_RECORD_SIZE_DONE = 8; - /** Finished retrieving image instance record; post result. */ - static private final int EVENT_READ_IMG_DONE = 9; - /** Finished retrieving icon data; post result. */ - static private final int EVENT_READ_ICON_DONE = 10; - - //***** Inner Classes - - static class LoadLinearFixedContext - { - - int efid; - int recordNum, recordSize, countRecords; - boolean loadAll; - - Message onLoaded; - - ArrayList<byte[]> results; - - LoadLinearFixedContext(int efid, int recordNum, Message onLoaded) - { - this.efid = efid; - this.recordNum = recordNum; - this.onLoaded = onLoaded; - this.loadAll = false; - } - - LoadLinearFixedContext(int efid, Message onLoaded) - { - this.efid = efid; - this.recordNum = 1; - this.loadAll = true; - this.onLoaded = onLoaded; - } - - } - //***** Constructor - SIMFileHandler(GSMPhone phone) - { - this.phone = phone; + SIMFileHandler(GSMPhone phone) { + super(phone); } - //***** Public Methods - - /** - * Load a record from a SIM Linear Fixed EF - * - * @param fileid EF id - * @param recordNum 1-based (not 0-based) record number - * @param onLoaded - * - * ((AsyncResult)(onLoaded.obj)).result is the byte[] - * - */ - void loadEFLinearFixed(int fileid, int recordNum, Message onLoaded) - { - Message response - = obtainMessage(EVENT_GET_RECORD_SIZE_DONE, - new LoadLinearFixedContext(fileid, recordNum, onLoaded)); - - phone.mCM.simIO(COMMAND_GET_RESPONSE, fileid, null, - 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, response); - } - - /** - * Load a image instance record from a SIM Linear Fixed EF-IMG - * - * @param recordNum 1-based (not 0-based) record number - * @param onLoaded - * - * ((AsyncResult)(onLoaded.obj)).result is the byte[] - * - */ - public void loadEFImgLinearFixed(int recordNum, Message onLoaded) { - Message response = obtainMessage(EVENT_READ_IMG_DONE, - new LoadLinearFixedContext(SimConstants.EF_IMG, recordNum, - onLoaded)); - - phone.mCM.simIO(COMMAND_GET_RESPONSE, SimConstants.EF_IMG, "img", - recordNum, READ_RECORD_MODE_ABSOLUTE, - ImageDescriptor.ID_LENGTH, null, null, response); - } - - /** - * get record size for a linear fixed EF - * - * @param fileid EF id - * @param onLoaded ((AsnyncResult)(onLoaded.obj)).result is the recordSize[] - * int[0] is the record length int[1] is the total length of the EF - * file int[3] is the number of records in the EF file So int[0] * - * int[3] = int[1] - */ - void getEFLinearRecordSize(int fileid, Message onLoaded) - { - Message response - = obtainMessage(EVENT_GET_EF_LINEAR_RECORD_SIZE_DONE, - new LoadLinearFixedContext(fileid, onLoaded)); - phone.mCM.simIO(COMMAND_GET_RESPONSE, fileid, null, - 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, response); - } - - /** - * Load all records from a SIM Linear Fixed EF - * - * @param fileid EF id - * @param onLoaded - * - * ((AsyncResult)(onLoaded.obj)).result is an ArrayList<byte[]> - * - */ - void loadEFLinearFixedAll(int fileid, Message onLoaded) - { - Message response = obtainMessage(EVENT_GET_RECORD_SIZE_DONE, - new LoadLinearFixedContext(fileid,onLoaded)); - - phone.mCM.simIO(COMMAND_GET_RESPONSE, fileid, null, - 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, response); + public void dispose() { + super.dispose(); } - /** - * Load a SIM Transparent EF - * - * @param fileid EF id - * @param onLoaded - * - * ((AsyncResult)(onLoaded.obj)).result is the byte[] - * - */ - - void loadEFTransparent(int fileid, Message onLoaded) - { - Message response = obtainMessage(EVENT_GET_BINARY_SIZE_DONE, - fileid, 0, onLoaded); - - phone.mCM.simIO(COMMAND_GET_RESPONSE, fileid, null, - 0, 0, GET_RESPONSE_EF_SIZE_BYTES, null, null, response); - } - - /** - * Load a SIM Transparent EF-IMG. Used right after loadEFImgLinearFixed to - * retrive STK's icon data. - * - * @param fileid EF id - * @param onLoaded - * - * ((AsyncResult)(onLoaded.obj)).result is the byte[] - * - */ - public void loadEFImgTransparent(int fileid, int highOffset, int lowOffset, - int length, Message onLoaded) { - Message response = obtainMessage(EVENT_READ_ICON_DONE, fileid, 0, - onLoaded); - - phone.mCM.simIO(COMMAND_READ_BINARY, fileid, "img", highOffset, lowOffset, - length, null, null, response); + protected void finalize() { + Log.d(LOG_TAG, "SIMFileHandler finalized"); } - /** - * Update a record in a linear fixed EF - * @param fileid EF id - * @param recordNum 1-based (not 0-based) record number - * @param data must be exactly as long as the record in the EF - * @param pin2 for CHV2 operations, otherwist must be null - * @param onComplete onComplete.obj will be an AsyncResult - * onComplete.obj.userObj will be a SimIoResult on success - */ - void updateEFLinearFixed(int fileid, int recordNum, byte[] data, - String pin2, Message onComplete) - { - phone.mCM.simIO(COMMAND_UPDATE_RECORD, fileid, null, - recordNum, READ_RECORD_MODE_ABSOLUTE, data.length, - SimUtils.bytesToHexString(data), pin2, onComplete); - } + //***** Overridden from IccFileHandler - /** - * Update a transparent EF - * @param fileid EF id - * @param data must be exactly as long as the EF - */ - void updateEFTransparent(int fileid, byte[] data, Message onComplete) - { - phone.mCM.simIO(COMMAND_UPDATE_BINARY, fileid, null, - 0, 0, data.length, - SimUtils.bytesToHexString(data), null, onComplete); + @Override + public void handleMessage(Message msg) { + super.handleMessage(msg); } - //***** Overridden from Handler - - public void handleMessage(Message msg) - { - AsyncResult ar; - SimIoResult result; - Message response = null; - String str; - LoadLinearFixedContext lc; - - SimException simException; - byte data[]; - int size; - int fileid; - int recordNum; - int recordSize[]; - - try { - switch (msg.what) { - case EVENT_READ_IMG_DONE: - ar = (AsyncResult) msg.obj; - lc = (LoadLinearFixedContext) ar.userObj; - result = (SimIoResult) ar.result; - response = lc.onLoaded; - - simException = result.getException(); - if (simException != null) { - sendResult(response, result.payload, ar.exception); - } - break; - case EVENT_READ_ICON_DONE: - ar = (AsyncResult) msg.obj; - response = (Message) ar.userObj; - result = (SimIoResult) ar.result; - - simException = result.getException(); - if (simException != null) { - sendResult(response, result.payload, ar.exception); - } - break; - case EVENT_GET_EF_LINEAR_RECORD_SIZE_DONE: - ar = (AsyncResult)msg.obj; - lc = (LoadLinearFixedContext) ar.userObj; - result = (SimIoResult) ar.result; - response = lc.onLoaded; - - if (ar.exception != null) { - sendResult(response, null, ar.exception); - break; - } - - simException = result.getException(); - if (simException != null) { - sendResult(response, null, simException); - break; - } - - data = result.payload; - - if (TYPE_EF != data[RESPONSE_DATA_FILE_TYPE] || - EF_TYPE_LINEAR_FIXED != data[RESPONSE_DATA_STRUCTURE]) { - throw new SimFileTypeMismatch(); - } - - recordSize = new int[3]; - recordSize[0] = data[RESPONSE_DATA_RECORD_LENGTH] & 0xFF; - recordSize[1] = ((data[RESPONSE_DATA_FILE_SIZE_1] & 0xff) << 8) - + (data[RESPONSE_DATA_FILE_SIZE_2] & 0xff); - recordSize[2] = recordSize[1] / recordSize[0]; - - sendResult(response, recordSize, null); - break; - case EVENT_GET_RECORD_SIZE_DONE: - ar = (AsyncResult)msg.obj; - lc = (LoadLinearFixedContext) ar.userObj; - result = (SimIoResult) ar.result; - response = lc.onLoaded; - - if (ar.exception != null) { - sendResult(response, null, ar.exception); - break; - } - - simException = result.getException(); - - if (simException != null) { - sendResult(response, null, simException); - break; - } - - data = result.payload; - fileid = lc.efid; - recordNum = lc.recordNum; - - if (TYPE_EF != data[RESPONSE_DATA_FILE_TYPE]) { - throw new SimFileTypeMismatch(); - } - - if (EF_TYPE_LINEAR_FIXED != data[RESPONSE_DATA_STRUCTURE]) { - throw new SimFileTypeMismatch(); - } - - lc.recordSize = data[RESPONSE_DATA_RECORD_LENGTH] & 0xFF; - - size = ((data[RESPONSE_DATA_FILE_SIZE_1] & 0xff) << 8) - + (data[RESPONSE_DATA_FILE_SIZE_2] & 0xff); - - lc.countRecords = size / lc.recordSize; - - if (lc.loadAll) { - lc.results = new ArrayList<byte[]>(lc.countRecords); - } - - phone.mCM.simIO(COMMAND_READ_RECORD, lc.efid, null, - lc.recordNum, - READ_RECORD_MODE_ABSOLUTE, - lc.recordSize, null, null, - obtainMessage(EVENT_READ_RECORD_DONE, lc)); - break; - case EVENT_GET_BINARY_SIZE_DONE: - ar = (AsyncResult)msg.obj; - response = (Message) ar.userObj; - result = (SimIoResult) ar.result; - - if (ar.exception != null) { - sendResult(response, null, ar.exception); - break; - } - - simException = result.getException(); - - if (simException != null) { - sendResult(response, null, simException); - break; - } - - data = result.payload; - - fileid = msg.arg1; - - if (TYPE_EF != data[RESPONSE_DATA_FILE_TYPE]) { - throw new SimFileTypeMismatch(); - } - - if (EF_TYPE_TRANSPARENT != data[RESPONSE_DATA_STRUCTURE]) { - throw new SimFileTypeMismatch(); - } - - size = ((data[RESPONSE_DATA_FILE_SIZE_1] & 0xff) << 8) - + (data[RESPONSE_DATA_FILE_SIZE_2] & 0xff); - - phone.mCM.simIO(COMMAND_READ_BINARY, fileid, null, - 0, 0, size, null, null, - obtainMessage(EVENT_READ_BINARY_DONE, - fileid, 0, response)); - break; - - case EVENT_READ_RECORD_DONE: - - ar = (AsyncResult)msg.obj; - lc = (LoadLinearFixedContext) ar.userObj; - result = (SimIoResult) ar.result; - response = lc.onLoaded; - - if (ar.exception != null) { - sendResult(response, null, ar.exception); - break; - } - - simException = result.getException(); - - if (simException != null) { - sendResult(response, null, simException); - break; - } - - if (!lc.loadAll) { - sendResult(response, result.payload, null); - } else { - lc.results.add(result.payload); - - lc.recordNum++; - - if (lc.recordNum > lc.countRecords) { - sendResult(response, lc.results, null); - } else { - phone.mCM.simIO(COMMAND_READ_RECORD, lc.efid, null, - lc.recordNum, - READ_RECORD_MODE_ABSOLUTE, - lc.recordSize, null, null, - obtainMessage(EVENT_READ_RECORD_DONE, lc)); - } - } - - break; - - case EVENT_READ_BINARY_DONE: - ar = (AsyncResult)msg.obj; - response = (Message) ar.userObj; - result = (SimIoResult) ar.result; - - if (ar.exception != null) { - sendResult(response, null, ar.exception); - break; - } - - simException = result.getException(); - - if (simException != null) { - sendResult(response, null, simException); - break; - } - - sendResult(response, result.payload, null); - break; - - }} catch (Exception exc) { - if (response != null) { - sendResult(response, null, exc); - } else { - Log.e(LOG_TAG, "uncaught exception", exc); - } - } + protected void logd(String msg) { + Log.d(LOG_TAG, "[SIMFileHandler] " + msg); } - //***** Private Methods - - private void sendResult(Message response, Object result, Throwable ex) - { - if (response == null) { - return; - } - - AsyncResult.forMessage(response, result, ex); - - response.sendToTarget(); + protected void loge(String msg) { + Log.e(LOG_TAG, "[SIMFileHandler] " + msg); } } diff --git a/telephony/java/com/android/internal/telephony/gsm/SIMRecords.java b/telephony/java/com/android/internal/telephony/gsm/SIMRecords.java index 4467536..09a17f5 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SIMRecords.java +++ b/telephony/java/com/android/internal/telephony/gsm/SIMRecords.java @@ -16,26 +16,45 @@ package com.android.internal.telephony.gsm; +import android.app.ActivityManagerNative; import android.app.AlarmManager; +import android.app.IActivityManager; import android.content.Context; +import android.content.res.Configuration; import android.os.AsyncResult; -import android.os.RegistrantList; -import android.os.Registrant; import android.os.Handler; import android.os.Message; import android.os.SystemProperties; -import android.telephony.gsm.SmsMessage; +import android.os.Registrant; import android.util.Log; import java.util.ArrayList; + import static com.android.internal.telephony.TelephonyProperties.*; -import com.android.internal.telephony.SimCard; + +import com.android.internal.telephony.AdnRecord; +import com.android.internal.telephony.AdnRecordCache; +import com.android.internal.telephony.AdnRecordLoader; +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.gsm.SimCard; +import com.android.internal.telephony.gsm.SmsMessage; +import com.android.internal.telephony.IccFileHandler; +import com.android.internal.telephony.IccRecords; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.IccVmFixedException; +import com.android.internal.telephony.IccVmNotSupportedException; +import com.android.internal.telephony.PhoneProxy; + + + + + + /** * {@hide} */ -public final class SIMRecords extends Handler implements SimConstants -{ +public final class SIMRecords extends IccRecords { static final String LOG_TAG = "GSM"; private static final boolean CRASH_RIL = false; @@ -44,37 +63,19 @@ public final class SIMRecords extends Handler implements SimConstants //***** Instance Variables - GSMPhone phone; - RegistrantList recordsLoadedRegistrants = new RegistrantList(); - - int recordsToLoad; // number of pending load requests + VoiceMailConstants mVmConfig; - AdnRecordCache adnCache; - VoiceMailConstants mVmConfig; SpnOverride mSpnOverride; //***** Cached SIM State; cleared on channel close - boolean recordsRequested = false; // true if we've made requests for the sim records - String imsi; - String iccid; - String msisdn = null; // My mobile number - String msisdnTag = null; - String voiceMailNum = null; - String voiceMailTag = null; - String newVoiceMailNum = null; - String newVoiceMailTag = null; - boolean isVoiceMailFixed = false; - int countVoiceMessages = 0; boolean callForwardingEnabled; - int mncLength = 0; // 0 is used to indicate that the value - // is not initialized - int mailboxIndex = 0; // 0 is no mailbox dailing number associated + /** - * Sates only used by getSpnFsm FSM + * States only used by getSpnFsm FSM */ private Get_Spn_Fsm_State spnState; @@ -157,9 +158,8 @@ public final class SIMRecords extends Handler implements SimConstants //***** Constructor - SIMRecords(GSMPhone phone) - { - this.phone = phone; + SIMRecords(GSMPhone p) { + super(p); adnCache = new AdnRecordCache(phone); @@ -172,30 +172,35 @@ public final class SIMRecords extends Handler implements SimConstants recordsToLoad = 0; - phone.mCM.registerForSIMReady(this, EVENT_SIM_READY, null); - phone.mCM.registerForOffOrNotAvailable( + p.mCM.registerForSIMReady(this, EVENT_SIM_READY, null); + p.mCM.registerForOffOrNotAvailable( this, EVENT_RADIO_OFF_OR_NOT_AVAILABLE, null); - phone.mCM.setOnSmsOnSim(this, EVENT_SMS_ON_SIM, null); - phone.mCM.setOnSimRefresh(this, EVENT_SIM_REFRESH, null); + p.mCM.setOnSmsOnSim(this, EVENT_SMS_ON_SIM, null); + p.mCM.setOnIccRefresh(this, EVENT_SIM_REFRESH, null); // Start off by setting empty state - onRadioOffOrNotAvailable(); + onRadioOffOrNotAvailable(); } - AdnRecordCache getAdnCache() { - return adnCache; + public void dispose() { + //Unregister for all events + phone.mCM.unregisterForSIMReady(this); + phone.mCM.unregisterForOffOrNotAvailable( this); + phone.mCM.unSetOnIccRefresh(this); } - private void onRadioOffOrNotAvailable() - { + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "SIMRecords finalized"); + } + + protected void onRadioOffOrNotAvailable() { imsi = null; msisdn = null; voiceMailNum = null; countVoiceMessages = 0; mncLength = 0; iccid = null; - spn = null; // -1 means no EF_SPN found; treat accordingly. spnDisplayCondition = -1; efMWIS = null; @@ -205,9 +210,9 @@ public final class SIMRecords extends Handler implements SimConstants adnCache.reset(); - phone.setSystemProperty(PROPERTY_SIM_OPERATOR_NUMERIC, null); - phone.setSystemProperty(PROPERTY_SIM_OPERATOR_ALPHA, null); - phone.setSystemProperty(PROPERTY_SIM_OPERATOR_ISO_COUNTRY, null); + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_NUMERIC, null); + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_ALPHA, null); + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_ISO_COUNTRY, null); // recordsRequested is set to false indicating that the SIM // read requests made so far are not valid. This is set to @@ -217,24 +222,13 @@ public final class SIMRecords extends Handler implements SimConstants //***** Public Methods - public void registerForRecordsLoaded(Handler h, int what, Object obj) - { - Registrant r = new Registrant(h, what, obj); - recordsLoadedRegistrants.add(r); - - if (recordsToLoad == 0 && recordsRequested == true) { - r.notifyRegistrant(new AsyncResult(null, null, null)); - } - } /** Returns null if SIM is not yet ready */ - public String getIMSI() - { + public String getIMSI() { return imsi; } - public String getMsisdnNumber() - { + public String getMsisdnNumber() { return msisdn; } @@ -272,28 +266,18 @@ public final class SIMRecords extends Handler implements SimConstants return msisdnTag; } - public String getVoiceMailNumber() - { + public String getVoiceMailNumber() { return voiceMailNum; } /** - * Return Service Provider Name stored in SIM - * @return null if SIM is not yet ready - */ - String getServiceProviderName() - { - return spn; - } - - /** * Set voice mail number to SIM record * * The voice mail number can be stored either in EF_MBDN (TS 51.011) or * EF_MAILBOX_CPHS (CPHS 4.2) * * If EF_MBDN is available, store the voice mail number to EF_MBDN - * + * * If EF_MAILBOX_CPHS is enabled, store the voice mail number to EF_CHPS * * So the voice mail number will be stored in both EFs if both are available @@ -314,7 +298,7 @@ public final class SIMRecords extends Handler implements SimConstants Message onComplete) { if (isVoiceMailFixed) { AsyncResult.forMessage((onComplete)).exception = - new SimVmFixedException("Voicemail number is fixed by operator"); + new IccVmFixedException("Voicemail number is fixed by operator"); onComplete.sendToTarget(); return; } @@ -336,9 +320,9 @@ public final class SIMRecords extends Handler implements SimConstants EF_EXT1, 1, null, obtainMessage(EVENT_SET_CPHS_MAILBOX_DONE, onComplete)); - }else { + } else { AsyncResult.forMessage((onComplete)).exception = - new SimVmNotSupportedException("Update SIM voice mailbox error"); + new IccVmNotSupportedException("Update SIM voice mailbox error"); onComplete.sendToTarget(); } } @@ -352,12 +336,11 @@ public final class SIMRecords extends Handler implements SimConstants * Sets the SIM voice message waiting indicator records * @param line GSM Subscriber Profile Number, one-based. Only '1' is supported * @param countWaiting The number of messages waiting, if known. Use - * -1 to indicate that an unknown number of + * -1 to indicate that an unknown number of * messages are waiting */ public void - setVoiceMessageWaiting(int line, int countWaiting) - { + setVoiceMessageWaiting(int line, int countWaiting) { if (line != 1) { // only profile 1 is supported return; @@ -374,14 +357,14 @@ public final class SIMRecords extends Handler implements SimConstants countVoiceMessages = countWaiting; - phone.notifyMessageWaitingIndicator(); + ((GSMPhone) phone).notifyMessageWaitingIndicator(); try { if (efMWIS != null) { // TS 51.011 10.3.45 // lsb of byte 0 is 'voicemail' status - efMWIS[0] = (byte)((efMWIS[0] & 0xfe) + efMWIS[0] = (byte)((efMWIS[0] & 0xfe) | (countVoiceMessages == 0 ? 0 : 1)); // byte 1 is the number of voice messages waiting @@ -393,17 +376,17 @@ public final class SIMRecords extends Handler implements SimConstants efMWIS[1] = (byte) countWaiting; } - phone.mSIMFileHandler.updateEFLinearFixed( + phone.getIccFileHandler().updateEFLinearFixed( EF_MWIS, 1, efMWIS, null, obtainMessage (EVENT_UPDATE_DONE, EF_MWIS)); - } + } if (efCPHS_MWI != null) { // Refer CPHS4_2.WW6 B4.2.3 - efCPHS_MWI[0] = (byte)((efCPHS_MWI[0] & 0xf0) + efCPHS_MWI[0] = (byte)((efCPHS_MWI[0] & 0xf0) | (countVoiceMessages == 0 ? 0x5 : 0xa)); - phone.mSIMFileHandler.updateEFTransparent( + phone.getIccFileHandler().updateEFTransparent( EF_VOICE_MAIL_INDICATOR_CPHS, efCPHS_MWI, obtainMessage (EVENT_UPDATE_DONE, EF_VOICE_MAIL_INDICATOR_CPHS)); } @@ -413,22 +396,6 @@ public final class SIMRecords extends Handler implements SimConstants } } - /** @return true if there are messages waiting, false otherwise. */ - public boolean getVoiceMessageWaiting() - { - return countVoiceMessages != 0; - } - - /** - * Returns number of voice messages waiting, if available - * If not available (eg, on an older CPHS SIM) -1 is returned if - * getVoiceMessageWaiting() is true - */ - public int getCountVoiceMessages() - { - return countVoiceMessages; - } - public boolean getVoiceCallForwardingFlag() { return callForwardingEnabled; } @@ -439,7 +406,7 @@ public final class SIMRecords extends Handler implements SimConstants callForwardingEnabled = enable; - phone.notifyCallForwardingIndicator(); + ((GSMPhone) phone).notifyCallForwardingIndicator(); try { if (mEfCfis != null) { @@ -453,7 +420,7 @@ public final class SIMRecords extends Handler implements SimConstants // TODO: Should really update other fields in EF_CFIS, eg, // dialing number. We don't read or use it right now. - phone.mSIMFileHandler.updateEFLinearFixed( + phone.getIccFileHandler().updateEFLinearFixed( EF_CFIS, 1, mEfCfis, null, obtainMessage (EVENT_UPDATE_DONE, EF_CFIS)); } @@ -467,7 +434,7 @@ public final class SIMRecords extends Handler implements SimConstants | CFF_UNCONDITIONAL_DEACTIVE); } - phone.mSIMFileHandler.updateEFTransparent( + phone.getIccFileHandler().updateEFTransparent( EF_CFF_CPHS, mEfCff, obtainMessage (EVENT_UPDATE_DONE, EF_CFF_CPHS)); } @@ -496,8 +463,7 @@ public final class SIMRecords extends Handler implements SimConstants /** Returns the 5 or 6 digit MCC/MNC of the operator that * provided the SIM card. Returns null of SIM is not yet ready */ - String getSIMOperatorNumeric() - { + String getSIMOperatorNumeric() { if (imsi == null) { return null; } @@ -517,17 +483,8 @@ public final class SIMRecords extends Handler implements SimConstants return imsi.substring(0, 3 + MccTable.smallestDigitsMccForMnc(mcc)); } - - boolean getRecordsLoaded() - { - if (recordsToLoad == 0 && recordsRequested == true) { - return true; - } else { - return false; - } - } - - /** + + /** * If the timezone is not already set, set it based on the MCC of the SIM. * @param mcc Mobile Country Code of the SIM */ @@ -557,8 +514,7 @@ public final class SIMRecords extends Handler implements SimConstants } //***** Overridden from Handler - public void handleMessage(Message msg) - { + public void handleMessage(Message msg) { AsyncResult ar; AdnRecord adn; @@ -573,19 +529,19 @@ public final class SIMRecords extends Handler implements SimConstants case EVENT_RADIO_OFF_OR_NOT_AVAILABLE: onRadioOffOrNotAvailable(); - break; + break; /* IO events */ case EVENT_GET_IMSI_DONE: isRecordLoadResponse = true; - + ar = (AsyncResult)msg.obj; if (ar.exception != null) { Log.e(LOG_TAG, "Exception querying IMSI, Exception:" + ar.exception); break; - } - + } + imsi = (String) ar.result; // IMSI (MCC+MNC+MSIN) is at least 6 digits, but not more @@ -594,11 +550,11 @@ public final class SIMRecords extends Handler implements SimConstants Log.e(LOG_TAG, "invalid IMSI " + imsi); imsi = null; } - + Log.d(LOG_TAG, "IMSI: " + imsi.substring(0, 6) + "xxxxxxxxx"); - phone.mSimCard.updateImsiConfiguration(imsi); - phone.mSimCard.broadcastSimStateChangedIntent( - SimCard.INTENT_VALUE_SIM_IMSI, null); + ((GSMPhone) phone).mSimCard.updateImsiConfiguration(imsi); + ((GSMPhone) phone).mSimCard.broadcastSimStateChangedIntent( + SimCard.INTENT_VALUE_ICC_IMSI, null); int mcc = Integer.parseInt(imsi.substring(0, 3)); setTimezoneFromMccIfNeeded(mcc); @@ -616,7 +572,7 @@ public final class SIMRecords extends Handler implements SimConstants if (ar.exception == null) { // Refer TS 51.011 Section 10.3.44 for content details Log.d(LOG_TAG, "EF_MBI: " + - SimUtils.bytesToHexString(data)); + IccUtils.bytesToHexString(data)); // Voice mail record number stored first mailboxIndex = (int)data[0] & 0xff; @@ -651,20 +607,20 @@ public final class SIMRecords extends Handler implements SimConstants ar = (AsyncResult)msg.obj; if (ar.exception != null) { - - Log.d(LOG_TAG, "Invalid or missing EF" + + Log.d(LOG_TAG, "Invalid or missing EF" + ((msg.what == EVENT_GET_CPHS_MAILBOX_DONE) ? "[MAILBOX]" : "[MBDN]")); // Bug #645770 fall back to CPHS // FIXME should use SST to decide if (msg.what == EVENT_GET_MBDN_DONE) { - //load CPHS on fail... + //load CPHS on fail... // FIXME right now, only load line1's CPHS voice mail entry recordsToLoad += 1; new AdnRecordLoader(phone).loadFromEF( - EF_MAILBOX_CPHS, EF_EXT1, 1, + EF_MAILBOX_CPHS, EF_EXT1, 1, obtainMessage(EVENT_GET_CPHS_MAILBOX_DONE)); } break; @@ -672,7 +628,8 @@ public final class SIMRecords extends Handler implements SimConstants adn = (AdnRecord)ar.result; - Log.d(LOG_TAG, "VM: " + adn + ((msg.what == EVENT_GET_CPHS_MAILBOX_DONE) ? " EF[MAILBOX]" : " EF[MBDN]")); + Log.d(LOG_TAG, "VM: " + adn + + ((msg.what == EVENT_GET_CPHS_MAILBOX_DONE) ? " EF[MAILBOX]" : " EF[MBDN]")); if (adn.isEmpty() && msg.what == EVENT_GET_MBDN_DONE) { // Bug #645770 fall back to CPHS @@ -680,7 +637,7 @@ public final class SIMRecords extends Handler implements SimConstants // FIXME right now, only load line1's CPHS voice mail entry recordsToLoad += 1; new AdnRecordLoader(phone).loadFromEF( - EF_MAILBOX_CPHS, EF_EXT1, 1, + EF_MAILBOX_CPHS, EF_EXT1, 1, obtainMessage(EVENT_GET_CPHS_MAILBOX_DONE)); break; @@ -730,7 +687,7 @@ public final class SIMRecords extends Handler implements SimConstants } Log.d(LOG_TAG, "EF_MWIS: " + - SimUtils.bytesToHexString(data)); + IccUtils.bytesToHexString(data)); efMWIS = data; @@ -744,11 +701,11 @@ public final class SIMRecords extends Handler implements SimConstants countVoiceMessages = data[1] & 0xff; if (voiceMailWaiting && countVoiceMessages == 0) { - // Unknown count = -1 + // Unknown count = -1 countVoiceMessages = -1; } - phone.notifyMessageWaitingIndicator(); + ((GSMPhone) phone).notifyMessageWaitingIndicator(); break; case EVENT_GET_VOICE_MAIL_INDICATOR_CPHS_DONE: @@ -777,7 +734,7 @@ public final class SIMRecords extends Handler implements SimConstants countVoiceMessages = 0; } - phone.notifyMessageWaitingIndicator(); + ((GSMPhone) phone).notifyMessageWaitingIndicator(); } break; @@ -786,13 +743,13 @@ public final class SIMRecords extends Handler implements SimConstants ar = (AsyncResult)msg.obj; data = (byte[])ar.result; - + if (ar.exception != null) { break; - } + } + + iccid = IccUtils.bcdToString(data, 0, data.length); - iccid = SimUtils.bcdToString(data, 0, data.length); - Log.d(LOG_TAG, "iccid: " + iccid); break; @@ -809,7 +766,7 @@ public final class SIMRecords extends Handler implements SimConstants } Log.d(LOG_TAG, "EF_AD: " + - SimUtils.bytesToHexString(data)); + IccUtils.bytesToHexString(data)); if (data.length < 3) { Log.d(LOG_TAG, "SIMRecords: Corrupt AD data on SIM"); @@ -851,14 +808,14 @@ public final class SIMRecords extends Handler implements SimConstants } Log.d(LOG_TAG, "EF_CFF_CPHS: " + - SimUtils.bytesToHexString(data)); + IccUtils.bytesToHexString(data)); mEfCff = data; if (mEfCfis == null) { callForwardingEnabled = ((data[0] & CFF_LINE1_MASK) == CFF_UNCONDITIONAL_ACTIVE); - phone.notifyCallForwardingIndicator(); + ((GSMPhone) phone).notifyCallForwardingIndicator(); } break; @@ -872,7 +829,7 @@ public final class SIMRecords extends Handler implements SimConstants break; } - parseEfSpdi(data); + parseEfSpdi(data); break; case EVENT_UPDATE_DONE: @@ -896,8 +853,8 @@ public final class SIMRecords extends Handler implements SimConstants for ( ; tlv.isValidObject() ; tlv.nextObject()) { if (tlv.getTag() == TAG_FULL_NETWORK_NAME) { - pnnHomeName - = SimUtils.networkNameToString( + pnnHomeName + = IccUtils.networkNameToString( tlv.getData(), 0, tlv.getData().length); break; } @@ -931,7 +888,8 @@ public final class SIMRecords extends Handler implements SimConstants + ar.exception + " length " + index.length); } else { Log.d(LOG_TAG, "READ EF_SMS RECORD index=" + index[0]); - phone.mSIMFileHandler.loadEFLinearFixed(EF_SMS,index[0],obtainMessage(EVENT_GET_SMS_DONE)); + phone.getIccFileHandler().loadEFLinearFixed(EF_SMS,index[0], + obtainMessage(EVENT_GET_SMS_DONE)); } break; @@ -955,7 +913,7 @@ public final class SIMRecords extends Handler implements SimConstants break; } - //Log.d(LOG_TAG, "SST: " + SimUtils.bytesToHexString(data)); + //Log.d(LOG_TAG, "SST: " + IccUtils.bytesToHexString(data)); break; case EVENT_GET_INFO_CPHS_DONE: @@ -969,7 +927,7 @@ public final class SIMRecords extends Handler implements SimConstants mCphsInfo = (byte[])ar.result; - if (DBG) log("iCPHS: " + SimUtils.bytesToHexString(mCphsInfo)); + if (DBG) log("iCPHS: " + IccUtils.bytesToHexString(mCphsInfo)); break; case EVENT_SET_MBDN_DONE: @@ -1050,20 +1008,20 @@ public final class SIMRecords extends Handler implements SimConstants } Log.d(LOG_TAG, "EF_CFIS: " + - SimUtils.bytesToHexString(data)); + IccUtils.bytesToHexString(data)); mEfCfis = data; // Refer TS 51.011 Section 10.3.46 for the content description callForwardingEnabled = ((data[1] & 0x01) != 0); - phone.notifyCallForwardingIndicator(); + ((GSMPhone) phone).notifyCallForwardingIndicator(); break; }}catch (RuntimeException exc) { // I don't want these exceptions to be fatal Log.w(LOG_TAG, "Exception parsing SIM record", exc); - } finally { + } finally { // Count up record load responses even if they are fails if (isRecordLoadResponse) { onRecordLoaded(); @@ -1076,12 +1034,12 @@ public final class SIMRecords extends Handler implements SimConstants case EF_MBDN: recordsToLoad++; new AdnRecordLoader(phone).loadFromEF(EF_MBDN, EF_EXT6, - mailboxIndex, obtainMessage(EVENT_GET_MBDN_DONE)); + mailboxIndex, obtainMessage(EVENT_GET_MBDN_DONE)); break; case EF_MAILBOX_CPHS: recordsToLoad++; new AdnRecordLoader(phone).loadFromEF(EF_MAILBOX_CPHS, EF_EXT1, - 1, obtainMessage(EVENT_GET_CPHS_MAILBOX_DONE)); + 1, obtainMessage(EVENT_GET_CPHS_MAILBOX_DONE)); break; default: // For now, fetch all records if this is not a @@ -1093,7 +1051,7 @@ public final class SIMRecords extends Handler implements SimConstants } } - private void handleSimRefresh(int[] result) { + private void handleSimRefresh(int[] result) { if (result == null || result.length == 0) { if (DBG) log("handleSimRefresh without input"); return; @@ -1102,7 +1060,7 @@ public final class SIMRecords extends Handler implements SimConstants switch ((result[0])) { case CommandsInterface.SIM_REFRESH_FILE_UPDATED: if (DBG) log("handleSimRefresh with SIM_REFRESH_FILE_UPDATED"); - // result[1] contains the EFID of the updated file. + // result[1] contains the EFID of the updated file. int efid = result[1]; handleFileUpdate(efid); break; @@ -1130,8 +1088,7 @@ public final class SIMRecords extends Handler implements SimConstants } } - private void handleSms(byte[] ba) - { + private void handleSms(byte[] ba) { if (ba[0] != 0) Log.d("ENF", "status : " + ba[0]); @@ -1145,12 +1102,13 @@ public final class SIMRecords extends Handler implements SimConstants byte[] nba = new byte[n - 1]; System.arraycopy(ba, 1, nba, 0, n - 1); - String pdu = SimUtils.bytesToHexString(nba); + String pdu = IccUtils.bytesToHexString(nba); // XXX first line is bogus SmsMessage message = SmsMessage.newFromCMT( new String[] { "", pdu }); - phone.mSMS.dispatchMessage(message); + + ((GSMPhone) phone).mSMS.dispatchMessage(message); } } @@ -1175,12 +1133,13 @@ public final class SIMRecords extends Handler implements SimConstants byte[] nba = new byte[n - 1]; System.arraycopy(ba, 1, nba, 0, n - 1); - String pdu = SimUtils.bytesToHexString(nba); + String pdu = IccUtils.bytesToHexString(nba); // XXX first line is bogus SmsMessage message = SmsMessage.newFromCMT( new String[] { "", pdu }); - phone.mSMS.dispatchMessage(message); + + ((GSMPhone) phone).mSMS.dispatchMessage(message); // 3GPP TS 51.011 v5.0.0 (20011-12) 10.5.3 // 1 == "received by MS from network; message read" @@ -1188,18 +1147,14 @@ public final class SIMRecords extends Handler implements SimConstants ba[0] = 1; if (false) { // XXX writing seems to crash RdoServD - phone.mSIMFileHandler.updateEFLinearFixed(EF_SMS, i, ba, null, - obtainMessage(EVENT_MARK_SMS_READ_DONE, i)); + phone.getIccFileHandler().updateEFLinearFixed(EF_SMS, + i, ba, null, obtainMessage(EVENT_MARK_SMS_READ_DONE, i)); } } } } - - //***** Private Methods - - private void onRecordLoaded() - { + protected void onRecordLoaded() { // One record loaded successfully or failed, In either case // we need to update the recordsToLoad count recordsToLoad -= 1; @@ -1211,21 +1166,19 @@ public final class SIMRecords extends Handler implements SimConstants recordsToLoad = 0; } } - - private void onAllRecordsLoaded() - { + + protected void onAllRecordsLoaded() { Log.d(LOG_TAG, "SIMRecords: record load complete"); String operator = getSIMOperatorNumeric(); // Some fields require more than one SIM record to set - phone.setSystemProperty(PROPERTY_SIM_OPERATOR_NUMERIC, operator); + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_NUMERIC, operator); if (imsi != null) { - phone.setSystemProperty(PROPERTY_SIM_OPERATOR_ISO_COUNTRY, - MccTable.countryCodeForMcc( - Integer.parseInt(imsi.substring(0,3)))); + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_ISO_COUNTRY, + MccTable.countryCodeForMcc(Integer.parseInt(imsi.substring(0,3)))); } else { Log.e("SIM", "[SIMRecords] onAllRecordsLoaded: imsi is NULL!"); @@ -1236,16 +1189,19 @@ public final class SIMRecords extends Handler implements SimConstants recordsLoadedRegistrants.notifyRegistrants( new AsyncResult(null, null, null)); - phone.mSimCard.broadcastSimStateChangedIntent( - SimCard.INTENT_VALUE_SIM_LOADED, null); + ((GSMPhone) phone).mSimCard.broadcastSimStateChangedIntent( + SimCard.INTENT_VALUE_ICC_LOADED, null); } + //***** Private methods + private void setSpnFromConfig(String carrier) { if (mSpnOverride.containsCarrier(carrier)) { spn = mSpnOverride.getSpn(carrier); } } + private void setVoiceMailByCountry (String spn) { if (mVmConfig.containsCarrier(spn)) { isVoiceMailFixed = true; @@ -1258,22 +1214,22 @@ public final class SIMRecords extends Handler implements SimConstants /* broadcast intent SIM_READY here so that we can make sure READY is sent before IMSI ready */ - phone.mSimCard.broadcastSimStateChangedIntent( - SimCard.INTENT_VALUE_SIM_READY, null); + ((GSMPhone) phone).mSimCard.broadcastSimStateChangedIntent( + SimCard.INTENT_VALUE_ICC_READY, null); fetchSimRecords(); } private void fetchSimRecords() { recordsRequested = true; + IccFileHandler iccFh = phone.getIccFileHandler(); - Log.v(LOG_TAG, "SIMRecords:fetchSimRecords " + recordsToLoad); + Log.v(LOG_TAG, "SIMRecords:fetchSimRecords " + recordsToLoad); phone.mCM.getIMSI(obtainMessage(EVENT_GET_IMSI_DONE)); recordsToLoad++; - phone.mSIMFileHandler.loadEFTransparent(EF_ICCID, - obtainMessage(EVENT_GET_ICCID_DONE)); + iccFh.loadEFTransparent(EF_ICCID, obtainMessage(EVENT_GET_ICCID_DONE)); recordsToLoad++; // FIXME should examine EF[MSISDN]'s capability configuration @@ -1283,17 +1239,14 @@ public final class SIMRecords extends Handler implements SimConstants recordsToLoad++; // Record number is subscriber profile - phone.mSIMFileHandler.loadEFLinearFixed(EF_MBI, 1, - obtainMessage(EVENT_GET_MBI_DONE)); + iccFh.loadEFLinearFixed(EF_MBI, 1, obtainMessage(EVENT_GET_MBI_DONE)); recordsToLoad++; - phone.mSIMFileHandler.loadEFTransparent(EF_AD, - obtainMessage(EVENT_GET_AD_DONE)); + iccFh.loadEFTransparent(EF_AD, obtainMessage(EVENT_GET_AD_DONE)); recordsToLoad++; // Record number is subscriber profile - phone.mSIMFileHandler.loadEFLinearFixed(EF_MWIS, 1, - obtainMessage(EVENT_GET_MWIS_DONE)); + iccFh.loadEFLinearFixed(EF_MWIS, 1, obtainMessage(EVENT_GET_MWIS_DONE)); recordsToLoad++; @@ -1301,50 +1254,49 @@ public final class SIMRecords extends Handler implements SimConstants // the same info as EF[MWIS]. If both exist, both are updated // but the EF[MWIS] data is preferred // Please note this must be loaded after EF[MWIS] - phone.mSIMFileHandler.loadEFTransparent( - EF_VOICE_MAIL_INDICATOR_CPHS, + iccFh.loadEFTransparent( + EF_VOICE_MAIL_INDICATOR_CPHS, obtainMessage(EVENT_GET_VOICE_MAIL_INDICATOR_CPHS_DONE)); recordsToLoad++; // Same goes for Call Forward Status indicator: fetch both // EF[CFIS] and CPHS-EF, with EF[CFIS] preferred. - phone.mSIMFileHandler.loadEFLinearFixed(EF_CFIS, 1, obtainMessage(EVENT_GET_CFIS_DONE)); + iccFh.loadEFLinearFixed(EF_CFIS, 1, obtainMessage(EVENT_GET_CFIS_DONE)); recordsToLoad++; - phone.mSIMFileHandler.loadEFTransparent(EF_CFF_CPHS, - obtainMessage(EVENT_GET_CFF_DONE)); + iccFh.loadEFTransparent(EF_CFF_CPHS, obtainMessage(EVENT_GET_CFF_DONE)); recordsToLoad++; getSpnFsm(true, null); - phone.mSIMFileHandler.loadEFTransparent(EF_SPDI, - obtainMessage(EVENT_GET_SPDI_DONE)); + iccFh.loadEFTransparent(EF_SPDI, obtainMessage(EVENT_GET_SPDI_DONE)); recordsToLoad++; - phone.mSIMFileHandler.loadEFLinearFixed(EF_PNN, 1, - obtainMessage(EVENT_GET_PNN_DONE)); + iccFh.loadEFLinearFixed(EF_PNN, 1, obtainMessage(EVENT_GET_PNN_DONE)); recordsToLoad++; - phone.mSIMFileHandler.loadEFTransparent(EF_SST, - obtainMessage(EVENT_GET_SST_DONE)); + iccFh.loadEFTransparent(EF_SST, obtainMessage(EVENT_GET_SST_DONE)); recordsToLoad++; - phone.mSIMFileHandler.loadEFTransparent(EF_INFO_CPHS, - obtainMessage(EVENT_GET_INFO_CPHS_DONE)); + iccFh.loadEFTransparent(EF_INFO_CPHS, obtainMessage(EVENT_GET_INFO_CPHS_DONE)); recordsToLoad++; // XXX should seek instead of examining them all if (false) { // XXX - phone.mSIMFileHandler.loadEFLinearFixedAll(EF_SMS, - obtainMessage(EVENT_GET_ALL_SMS_DONE)); + iccFh.loadEFLinearFixedAll(EF_SMS, obtainMessage(EVENT_GET_ALL_SMS_DONE)); recordsToLoad++; } if (CRASH_RIL) { - String sms = "0107912160130310f20404d0110041007030208054832b0120ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"; - byte[] ba = SimUtils.hexStringToBytes(sms); - - phone.mSIMFileHandler.updateEFLinearFixed(EF_SMS, 1, ba, null, + String sms = "0107912160130310f20404d0110041007030208054832b0120" + + "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + + "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + + "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + + "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + + "ffffffffffffffffffffffffffffff"; + byte[] ba = IccUtils.hexStringToBytes(sms); + + iccFh.updateEFLinearFixed(EF_SMS, 1, ba, null, obtainMessage(EVENT_MARK_SMS_READ_DONE, 1)); } } @@ -1356,7 +1308,7 @@ public final class SIMRecords extends Handler implements SimConstants * * If the SPN is not found on the SIM, the rule is always PLMN_ONLY. */ - int getDisplayRule(String plmn) { + protected int getDisplayRule(String plmn) { int rule; if (spn == null || spnDisplayCondition == -1) { // EF_SPN was not found on the SIM, or not yet loaded. Just show ONS. @@ -1431,7 +1383,7 @@ public final class SIMRecords extends Handler implements SimConstants case INIT: spn = null; - phone.mSIMFileHandler.loadEFTransparent( EF_SPN, + phone.getIccFileHandler().loadEFTransparent( EF_SPN, obtainMessage(EVENT_GET_SPN_DONE)); recordsToLoad++; @@ -1441,20 +1393,20 @@ public final class SIMRecords extends Handler implements SimConstants if (ar != null && ar.exception == null) { data = (byte[]) ar.result; spnDisplayCondition = 0xff & data[0]; - spn = SimUtils.adnStringFieldToString(data, 1, data.length - 1); + spn = IccUtils.adnStringFieldToString(data, 1, data.length - 1); if (DBG) log("Load EF_SPN: " + spn + " spnDisplayCondition: " + spnDisplayCondition); - phone.setSystemProperty(PROPERTY_SIM_OPERATOR_ALPHA, spn); + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_ALPHA, spn); spnState = Get_Spn_Fsm_State.IDLE; } else { - phone.mSIMFileHandler.loadEFTransparent( EF_SPN_CPHS, + phone.getIccFileHandler().loadEFTransparent( EF_SPN_CPHS, obtainMessage(EVENT_GET_SPN_DONE)); recordsToLoad++; spnState = Get_Spn_Fsm_State.READ_SPN_CPHS; - + // See TS 51.011 10.3.11. Basically, default to // show PLMN always, and SPN also if roaming. spnDisplayCondition = -1; @@ -1463,16 +1415,16 @@ public final class SIMRecords extends Handler implements SimConstants case READ_SPN_CPHS: if (ar != null && ar.exception == null) { data = (byte[]) ar.result; - spn = SimUtils.adnStringFieldToString( + spn = IccUtils.adnStringFieldToString( data, 0, data.length - 1 ); if (DBG) log("Load EF_SPN_CPHS: " + spn); - phone.setSystemProperty(PROPERTY_SIM_OPERATOR_ALPHA, spn); + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_ALPHA, spn); spnState = Get_Spn_Fsm_State.IDLE; } else { - phone.mSIMFileHandler.loadEFTransparent( EF_SPN_SHORT_CPHS, - obtainMessage(EVENT_GET_SPN_DONE)); + phone.getIccFileHandler().loadEFTransparent( + EF_SPN_SHORT_CPHS, obtainMessage(EVENT_GET_SPN_DONE)); recordsToLoad++; spnState = Get_Spn_Fsm_State.READ_SPN_SHORT_CPHS; @@ -1481,11 +1433,11 @@ public final class SIMRecords extends Handler implements SimConstants case READ_SPN_SHORT_CPHS: if (ar != null && ar.exception == null) { data = (byte[]) ar.result; - spn = SimUtils.adnStringFieldToString( + spn = IccUtils.adnStringFieldToString( data, 0, data.length - 1); if (DBG) log("Load EF_SPN_SHORT_CPHS: " + spn); - phone.setSystemProperty(PROPERTY_SIM_OPERATOR_ALPHA, spn); + phone.setSystemProperty(PROPERTY_ICC_OPERATOR_ALPHA, spn); }else { if (DBG) log("No SPN loaded in either CHPS or 3GPP"); } @@ -1503,8 +1455,7 @@ public final class SIMRecords extends Handler implements SimConstants * are treated specially when determining SPN display */ private void - parseEfSpdi(byte[] data) - { + parseEfSpdi(byte[] data) { SimTlv tlv = new SimTlv(data, 0, data.length); byte[] plmnEntries = null; @@ -1524,8 +1475,8 @@ public final class SIMRecords extends Handler implements SimConstants spdiNetworks = new ArrayList<String>(plmnEntries.length / 3); for (int i = 0 ; i + 2 < plmnEntries.length ; i += 3) { - String plmnCode; - plmnCode = SimUtils.bcdToString(plmnEntries, i, 3); + String plmnCode; + plmnCode = IccUtils.bcdToString(plmnEntries, i, 3); // Valid operator codes are 5 or 6 digits if (plmnCode.length() >= 5) { @@ -1543,7 +1494,11 @@ public final class SIMRecords extends Handler implements SimConstants return ((mCphsInfo[1] & CPHS_SST_MBN_MASK) == CPHS_SST_MBN_ENABLED ); } - private void log(String s) { + protected void log(String s) { Log.d(LOG_TAG, "[SIMRecords] " + s); } + } + + + diff --git a/telephony/java/com/android/internal/telephony/gsm/GsmSimCard.java b/telephony/java/com/android/internal/telephony/gsm/SimCard.java index a4cded9..9af3aa6 100644 --- a/telephony/java/com/android/internal/telephony/gsm/GsmSimCard.java +++ b/telephony/java/com/android/internal/telephony/gsm/SimCard.java @@ -16,6 +16,9 @@ package com.android.internal.telephony.gsm; +import android.app.ActivityManagerNative; +import android.content.Intent; +import android.content.res.Configuration; import android.os.AsyncResult; import android.os.RemoteException; import android.os.Handler; @@ -23,32 +26,34 @@ import android.os.Message; import android.os.Registrant; import android.os.RegistrantList; import android.util.Log; -import com.android.internal.telephony.SimCard; -import com.android.internal.telephony.TelephonyProperties; + +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.IccCard; import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneProxy; import com.android.internal.telephony.TelephonyIntents; -import android.content.Intent; -import android.content.res.Configuration; -import android.app.ActivityManagerNative; +import com.android.internal.telephony.TelephonyProperties; import static android.Manifest.permission.READ_PHONE_STATE; /** + * Note: this class shares common code with RuimCard, consider a base class to minimize code + * duplication. * {@hide} */ -public final class GsmSimCard extends Handler implements SimCard { +public final class SimCard extends Handler implements IccCard { static final String LOG_TAG="GSM"; - + //***** Instance Variables private static final boolean DBG = true; private GSMPhone phone; - private CommandsInterface.SimStatus status = null; + private CommandsInterface.IccStatus status = null; + private boolean mDesiredPinLocked; + private boolean mDesiredFdnEnabled; private boolean mSimPinLocked = true; // Default to locked private boolean mSimFdnEnabled = false; // Default to disabled. // Will be updated when SIM_READY. - private boolean mDesiredPinLocked; - private boolean mDesiredFdnEnabled; //***** Constants @@ -72,8 +77,7 @@ public final class GsmSimCard extends Handler implements SimCard { //***** Constructor - GsmSimCard(GSMPhone phone) - { + SimCard(GSMPhone phone) { this.phone = phone; phone.mCM.registerForSIMLockedOrAbsent( @@ -87,12 +91,22 @@ public final class GsmSimCard extends Handler implements SimCard { updateStateProperty(); } - + + public void dispose() { + //Unregister for all events + phone.mCM.unregisterForSIMLockedOrAbsent(this); + phone.mCM.unregisterForOffOrNotAvailable(this); + phone.mCM.unregisterForSIMReady(this); + } + + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "SimCard finalized"); + } + //***** SimCard implementation public State - getState() - { + getState() { if (status == null) { switch(phone.mCM.getRadioState()) { /* This switch block must not return anything in @@ -111,12 +125,12 @@ public final class GsmSimCard extends Handler implements SimCard { } } else { switch (status) { - case SIM_ABSENT: return State.ABSENT; - case SIM_NOT_READY: return State.UNKNOWN; - case SIM_READY: return State.READY; - case SIM_PIN: return State.PIN_REQUIRED; - case SIM_PUK: return State.PUK_REQUIRED; - case SIM_NETWORK_PERSONALIZATION: return State.NETWORK_LOCKED; + case ICC_ABSENT: return State.ABSENT; + case ICC_NOT_READY: return State.UNKNOWN; + case ICC_READY: return State.READY; + case ICC_PIN: return State.PIN_REQUIRED; + case ICC_PUK: return State.PUK_REQUIRED; + case ICC_NETWORK_PERSONALIZATION: return State.NETWORK_LOCKED; } } @@ -129,8 +143,7 @@ public final class GsmSimCard extends Handler implements SimCard { private RegistrantList networkLockedRegistrants = new RegistrantList(); - public void registerForAbsent(Handler h, int what, Object obj) - { + public void registerForAbsent(Handler h, int what, Object obj) { Registrant r = new Registrant (h, what, obj); absentRegistrants.add(r); @@ -139,9 +152,9 @@ public final class GsmSimCard extends Handler implements SimCard { r.notifyRegistrant(); } } - + public void unregisterForAbsent(Handler h) { - absentRegistrants.remove(h); + absentRegistrants.remove(h); } public void registerForNetworkLocked(Handler h, int what, Object obj) { @@ -155,11 +168,10 @@ public final class GsmSimCard extends Handler implements SimCard { } public void unregisterForNetworkLocked(Handler h) { - networkLockedRegistrants.remove(h); + networkLockedRegistrants.remove(h); } - - public void registerForLocked(Handler h, int what, Object obj) - { + + public void registerForLocked(Handler h, int what, Object obj) { Registrant r = new Registrant (h, what, obj); pinLockedRegistrants.add(r); @@ -169,50 +181,44 @@ public final class GsmSimCard extends Handler implements SimCard { } } - public void unregisterForLocked(Handler h) - { + public void unregisterForLocked(Handler h) { pinLockedRegistrants.remove(h); } - public void supplyPin (String pin, Message onComplete) - { - phone.mCM.supplySimPin(pin, + public void supplyPin (String pin, Message onComplete) { + phone.mCM.supplyIccPin(pin, obtainMessage(EVENT_PINPUK_DONE, onComplete)); } - public void supplyPuk (String puk, String newPin, Message onComplete) - { - phone.mCM.supplySimPuk(puk, newPin, + public void supplyPuk (String puk, String newPin, Message onComplete) { + phone.mCM.supplyIccPuk(puk, newPin, obtainMessage(EVENT_PINPUK_DONE, onComplete)); } - public void supplyPin2 (String pin2, Message onComplete) - { - phone.mCM.supplySimPin2(pin2, + public void supplyPin2 (String pin2, Message onComplete) { + phone.mCM.supplyIccPin2(pin2, obtainMessage(EVENT_PINPUK_DONE, onComplete)); } - public void supplyPuk2 (String puk2, String newPin2, Message onComplete) - { - phone.mCM.supplySimPuk2(puk2, newPin2, + public void supplyPuk2 (String puk2, String newPin2, Message onComplete) { + phone.mCM.supplyIccPuk2(puk2, newPin2, obtainMessage(EVENT_PINPUK_DONE, onComplete)); } - public void supplyNetworkDepersonalization (String pin, Message onComplete) - { + public void supplyNetworkDepersonalization (String pin, Message onComplete) { if(DBG) log("Network Despersonalization: " + pin); phone.mCM.supplyNetworkDepersonalization(pin, obtainMessage(EVENT_PINPUK_DONE, onComplete)); } - public boolean getSimLockEnabled() { + public boolean getIccLockEnabled() { return mSimPinLocked; } - public boolean getSimFdnEnabled() { + public boolean getIccFdnEnabled() { return mSimFdnEnabled; } - public void setSimLockEnabled (boolean enabled, + public void setIccLockEnabled (boolean enabled, String password, Message onComplete) { int serviceClassX; serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE + @@ -226,7 +232,7 @@ public final class GsmSimCard extends Handler implements SimCard { obtainMessage(EVENT_CHANGE_FACILITY_LOCK_DONE, onComplete)); } - public void setSimFdnEnabled (boolean enabled, + public void setIccFdnEnabled (boolean enabled, String password, Message onComplete) { int serviceClassX; serviceClassX = CommandsInterface.SERVICE_CLASS_VOICE + @@ -241,18 +247,18 @@ public final class GsmSimCard extends Handler implements SimCard { obtainMessage(EVENT_CHANGE_FACILITY_FDN_DONE, onComplete)); } - public void changeSimLockPassword(String oldPassword, String newPassword, + public void changeIccLockPassword(String oldPassword, String newPassword, Message onComplete) { if(DBG) log("Change Pin1 old: " + oldPassword + " new: " + newPassword); - phone.mCM.changeSimPin(oldPassword, newPassword, + phone.mCM.changeIccPin(oldPassword, newPassword, obtainMessage(EVENT_CHANGE_SIM_PASSWORD_DONE, onComplete)); } - public void changeSimFdnPassword(String oldPassword, String newPassword, + public void changeIccFdnPassword(String oldPassword, String newPassword, Message onComplete) { if(DBG) log("Change Pin2 old: " + oldPassword + " new: " + newPassword); - phone.mCM.changeSimPin2(oldPassword, newPassword, + phone.mCM.changeIccPin2(oldPassword, newPassword, obtainMessage(EVENT_CHANGE_SIM_PASSWORD_DONE, onComplete)); } @@ -275,11 +281,11 @@ public final class GsmSimCard extends Handler implements SimCard { case EVENT_RADIO_OFF_OR_NOT_AVAILABLE: status = null; updateStateProperty(); - broadcastSimStateChangedIntent(SimCard.INTENT_VALUE_SIM_NOT_READY, null); + broadcastSimStateChangedIntent(SimCard.INTENT_VALUE_ICC_NOT_READY, null); break; case EVENT_SIM_READY: //TODO: put facility read in SIM_READY now, maybe in REG_NW - phone.mCM.getSimStatus(obtainMessage(EVENT_GET_SIM_STATUS_DONE)); + phone.mCM.getIccStatus(obtainMessage(EVENT_GET_SIM_STATUS_DONE)); phone.mCM.queryFacilityLock ( CommandsInterface.CB_FACILITY_BA_SIM, "", serviceClassX, obtainMessage(EVENT_QUERY_FACILITY_LOCK_DONE)); @@ -288,7 +294,7 @@ public final class GsmSimCard extends Handler implements SimCard { obtainMessage(EVENT_QUERY_FACILITY_FDN_DONE)); break; case EVENT_SIM_LOCKED_OR_ABSENT: - phone.mCM.getSimStatus(obtainMessage(EVENT_GET_SIM_STATUS_DONE)); + phone.mCM.getIccStatus(obtainMessage(EVENT_GET_SIM_STATUS_DONE)); phone.mCM.queryFacilityLock ( CommandsInterface.CB_FACILITY_BA_SIM, "", serviceClassX, obtainMessage(EVENT_QUERY_FACILITY_LOCK_DONE)); @@ -306,7 +312,7 @@ public final class GsmSimCard extends Handler implements SimCard { // TODO should abstract these exceptions AsyncResult.forMessage(((Message)ar.userObj)).exception = ar.exception; - phone.mCM.getSimStatus( + phone.mCM.getIccStatus( obtainMessage(EVENT_REPOLL_STATUS_DONE, ar.userObj)); break; case EVENT_REPOLL_STATUS_DONE: @@ -415,24 +421,24 @@ public final class GsmSimCard extends Handler implements SimCard { private void getSimStatusDone(AsyncResult ar) { if (ar.exception != null) { - Log.e(LOG_TAG,"Error getting SIM status. " - + "RIL_REQUEST_GET_SIM_STATUS should " + Log.e(LOG_TAG,"Error getting ICC status. " + + "RIL_REQUEST_GET_ICC_STATUS should " + "never return an error", ar.exception); return; } - CommandsInterface.SimStatus newStatus - = (CommandsInterface.SimStatus) ar.result; + CommandsInterface.IccStatus newStatus + = (CommandsInterface.IccStatus) ar.result; handleSimStatus(newStatus); } private void - handleSimStatus(CommandsInterface.SimStatus newStatus) { + handleSimStatus(CommandsInterface.IccStatus newStatus) { boolean transitionedIntoPinLocked; boolean transitionedIntoAbsent; boolean transitionedIntoNetworkLocked; - + SimCard.State oldState, newState; oldState = getState(); @@ -451,17 +457,17 @@ public final class GsmSimCard extends Handler implements SimCard { if (transitionedIntoPinLocked) { if(DBG) log("Notify SIM pin or puk locked."); pinLockedRegistrants.notifyRegistrants(); - broadcastSimStateChangedIntent(SimCard.INTENT_VALUE_SIM_LOCKED, + broadcastSimStateChangedIntent(SimCard.INTENT_VALUE_ICC_LOCKED, (newState == State.PIN_REQUIRED) ? INTENT_VALUE_LOCKED_ON_PIN : INTENT_VALUE_LOCKED_ON_PUK); } else if (transitionedIntoAbsent) { if(DBG) log("Notify SIM missing."); absentRegistrants.notifyRegistrants(); - broadcastSimStateChangedIntent(SimCard.INTENT_VALUE_SIM_ABSENT, null); + broadcastSimStateChangedIntent(SimCard.INTENT_VALUE_ICC_ABSENT, null); } else if (transitionedIntoNetworkLocked) { if(DBG) log("Notify SIM network locked."); networkLockedRegistrants.notifyRegistrants(); - broadcastSimStateChangedIntent(SimCard.INTENT_VALUE_SIM_LOCKED, + broadcastSimStateChangedIntent(SimCard.INTENT_VALUE_ICC_LOCKED, INTENT_VALUE_LOCKED_NETWORK); } } @@ -469,7 +475,7 @@ public final class GsmSimCard extends Handler implements SimCard { public void broadcastSimStateChangedIntent(String value, String reason) { Intent intent = new Intent(TelephonyIntents.ACTION_SIM_STATE_CHANGED); intent.putExtra(Phone.PHONE_NAME_KEY, phone.getPhoneName()); - intent.putExtra(SimCard.INTENT_KEY_SIM_STATE, value); + intent.putExtra(SimCard.INTENT_KEY_ICC_STATE, value); intent.putExtra(SimCard.INTENT_KEY_LOCKED_REASON, reason); if(DBG) log("Broadcasting intent SIM_STATE_CHANGED_ACTION " + value + " reason " + reason); diff --git a/telephony/java/com/android/internal/telephony/gsm/SimPhoneBookInterfaceManager.java b/telephony/java/com/android/internal/telephony/gsm/SimPhoneBookInterfaceManager.java index 7cc9a80..076da6b 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimPhoneBookInterfaceManager.java +++ b/telephony/java/com/android/internal/telephony/gsm/SimPhoneBookInterfaceManager.java @@ -25,6 +25,11 @@ import android.os.ServiceManager; import android.telephony.PhoneNumberUtils; import android.util.Log; +import com.android.internal.telephony.AdnRecord; +import com.android.internal.telephony.AdnRecordCache; +import com.android.internal.telephony.IccPhoneBookInterfaceManager; +import com.android.internal.telephony.PhoneProxy; + import java.util.ArrayList; import java.util.List; @@ -32,247 +37,65 @@ import java.util.List; * SimPhoneBookInterfaceManager to provide an inter-process communication to * access ADN-like SIM records. */ -public class SimPhoneBookInterfaceManager extends ISimPhoneBook.Stub { - static final String LOG_TAG = "GSM"; - static final boolean DBG = false; - private GSMPhone phone; - private AdnRecordCache adnCache; - private final Object mLock = new Object(); - private int recordSize[]; - private boolean success; - private List<AdnRecord> records; - private static final boolean ALLOW_SIM_OP_IN_UI_THREAD = false; +public class SimPhoneBookInterfaceManager extends IccPhoneBookInterfaceManager { + static final String LOG_TAG = "GSM"; - private static final int EVENT_GET_SIZE_DONE = 1; - private static final int EVENT_LOAD_DONE = 2; - private static final int EVENT_UPDATE_DONE = 3; Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { AsyncResult ar; - switch (msg.what) { - case EVENT_GET_SIZE_DONE: - ar = (AsyncResult) msg.obj; - synchronized (mLock) { - if (ar.exception == null) { - recordSize = (int[])ar.result; - // recordSize[0] is the record length - // recordSize[1] is the total length of the EF file - // recordSize[2] is the number of records in the EF file - log("GET_RECORD_SIZE Size " + recordSize[0] + - " total " + recordSize[1] + - " #record " + recordSize[2]); - mLock.notifyAll(); - } - } - break; - case EVENT_UPDATE_DONE: - ar = (AsyncResult) msg.obj; - synchronized (mLock) { - success = (ar.exception == null); - mLock.notifyAll(); - } - break; - case EVENT_LOAD_DONE: - ar = (AsyncResult)msg.obj; - synchronized (mLock) { - if (ar.exception == null) { - records = (List<AdnRecord>) - ((ArrayList<AdnRecord>) ar.result); - } else { - if(DBG) log("Cannot load ADN records"); - if (records != null) { - records.clear(); - } - } - mLock.notifyAll(); - } + switch(msg.what) { + default: + mBaseHandler.handleMessage(msg); break; } } }; public SimPhoneBookInterfaceManager(GSMPhone phone) { - this.phone = phone; + super(phone); adnCache = phone.mSIMRecords.getAdnCache(); - publish(); + //NOTE service "simphonebook" added by IccSmsInterfaceManagerProxy } - private void publish() { - ServiceManager.addService("simphonebook", this); + public void dispose() { + super.dispose(); } - /** - * Replace oldAdn with newAdn in ADN-like record in EF - * - * getAdnRecordsInEf must be called at least once before this function, - * otherwise an error will be returned - * throws SecurityException if no WRITE_CONTACTS permission - * - * @param efid must be one among EF_ADN, EF_FDN, and EF_SDN - * @param oldTag adn tag to be replaced - * @param oldPhoneNumber adn number to be replaced - * Set both oldTag and oldPhoneNubmer to "" means to replace an - * empty record, aka, insert new record - * @param newTag adn tag to be stored - * @param newPhoneNumber adn number ot be stored - * Set both newTag and newPhoneNubmer to "" means to replace the old - * record with empty one, aka, delete old record - * @param pin2 required to update EF_FDN, otherwise must be null - * @return true for success - */ - public boolean - updateAdnRecordsInEfBySearch (int efid, - String oldTag, String oldPhoneNumber, - String newTag, String newPhoneNumber, String pin2) { - - - if (phone.getContext().checkCallingOrSelfPermission( - android.Manifest.permission.WRITE_CONTACTS) - != PackageManager.PERMISSION_GRANTED) { - throw new SecurityException( - "Requires android.permission.WRITE_CONTACTS permission"); - } - - - if (DBG) log("updateAdnRecordsInEfBySearch: efid=" + efid + - " ("+ oldTag + "," + oldPhoneNumber + ")"+ "==>" + - " ("+ newTag + "," + newPhoneNumber + ")"+ " pin2=" + pin2); - synchronized(mLock) { - checkThread(); - success = false; - Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE); - AdnRecord oldAdn = new AdnRecord(oldTag, oldPhoneNumber); - AdnRecord newAdn = new AdnRecord(newTag, newPhoneNumber); - adnCache.updateAdnBySearch(efid, oldAdn, newAdn, pin2, response); - try { - mLock.wait(); - } catch (InterruptedException e) { - log("interrupted while trying to update by search"); - } - } - return success; - } - - /** - * Update an ADN-like EF record by record index - * - * This is useful for iteration the whole ADN file, such as write the whole - * phone book or erase/format the whole phonebook - * throws SecurityException if no WRITE_CONTACTS permission - * - * @param efid must be one among EF_ADN, EF_FDN, and EF_SDN - * @param newTag adn tag to be stored - * @param newPhoneNumber adn number to be stored - * Set both newTag and newPhoneNubmer to "" means to replace the old - * record with empty one, aka, delete old record - * @param index is 1-based adn record index to be updated - * @param pin2 required to update EF_FDN, otherwise must be null - * @return true for success - */ - public boolean - updateAdnRecordsInEfByIndex(int efid, String newTag, - String newPhoneNumber, int index, String pin2) { - - if (phone.getContext().checkCallingOrSelfPermission( - android.Manifest.permission.WRITE_CONTACTS) - != PackageManager.PERMISSION_GRANTED) { - throw new SecurityException( - "Requires android.permission.WRITE_CONTACTS permission"); - } - - if (DBG) log("updateAdnRecordsInEfByIndex: efid=" + efid + - " Index=" + index + " ==> " + - "("+ newTag + "," + newPhoneNumber + ")"+ " pin2=" + pin2); - synchronized(mLock) { - checkThread(); - success = false; - Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE); - AdnRecord newAdn = new AdnRecord(newTag, newPhoneNumber); - adnCache.updateAdnByIndex(efid, newAdn, index, pin2, response); - try { - mLock.wait(); - } catch (InterruptedException e) { - log("interrupted while trying to update by index"); - } - } - return success; + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "SimPhoneBookInterfaceManager finalized"); } - /** - * Get the capacity of records in efid - * - * @param efid the EF id of a ADN-like SIM - * @return int[3] array - * recordSizes[0] is the single record length - * recordSizes[1] is the total length of the EF file - * recordSizes[2] is the number of records in the EF file - */ public int[] getAdnRecordsSize(int efid) { - if (DBG) log("getAdnRecordsSize: efid=" + efid); + if (DBG) logd("getAdnRecordsSize: efid=" + efid); synchronized(mLock) { checkThread(); recordSize = new int[3]; - Message response = mHandler.obtainMessage(EVENT_GET_SIZE_DONE); - phone.mSIMFileHandler.getEFLinearRecordSize(efid, response); - try { - mLock.wait(); - } catch (InterruptedException e) { - log("interrupted while trying to load from the SIM"); - } - } - return recordSize; - } + //Using mBaseHandler, no difference in EVENT_GET_SIZE_DONE handling + Message response = mBaseHandler.obtainMessage(EVENT_GET_SIZE_DONE); - /** - * Loads the AdnRecords in efid and returns them as a - * List of AdnRecords - * - * throws SecurityException if no READ_CONTACTS permission - * - * @param efid the EF id of a ADN-like SIM - * @return List of AdnRecord - */ - public List<AdnRecord> getAdnRecordsInEf(int efid) { - - if (phone.getContext().checkCallingOrSelfPermission( - android.Manifest.permission.READ_CONTACTS) - != PackageManager.PERMISSION_GRANTED) { - throw new SecurityException( - "Requires android.permission.READ_CONTACTS permission"); - } - - if (DBG) log("getAdnRecordsInEF: efid=" + efid); - - synchronized(mLock) { - checkThread(); - Message response = mHandler.obtainMessage(EVENT_LOAD_DONE); - adnCache.requestLoadAllAdnLike(efid, response); + phone.getIccFileHandler().getEFLinearRecordSize(efid, response); try { mLock.wait(); } catch (InterruptedException e) { - log("interrupted while trying to load from the SIM"); + logd("interrupted while trying to load from the SIM"); } } - return records; + + return recordSize; } - private void checkThread() { - if (!ALLOW_SIM_OP_IN_UI_THREAD) { - // Make sure this isn't the UI thread, since it will block - if (mHandler.getLooper().equals(Looper.myLooper())) { - Log.e(LOG_TAG, "query() called on the main UI thread!"); - throw new IllegalStateException("You cannot call query on this provder from the main UI thread."); - } - } + protected void logd(String msg) { + Log.d(LOG_TAG, "[SimPbInterfaceManager] " + msg); } - private void log(String msg) { - Log.d(LOG_TAG, "[SpbInterfaceManager] " + msg); + protected void loge(String msg) { + Log.e(LOG_TAG, "[SimPbInterfaceManager] " + msg); } } + diff --git a/telephony/java/com/android/internal/telephony/gsm/SimSmsInterfaceManager.java b/telephony/java/com/android/internal/telephony/gsm/SimSmsInterfaceManager.java index c3df0d0..875d8d0 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimSmsInterfaceManager.java +++ b/telephony/java/com/android/internal/telephony/gsm/SimSmsInterfaceManager.java @@ -16,27 +16,31 @@ package com.android.internal.telephony.gsm; -import android.app.PendingIntent; import android.content.Context; import android.os.AsyncResult; import android.os.Handler; import android.os.Message; -import android.os.ServiceManager; -import android.telephony.gsm.SmsManager; import android.util.Log; +import com.android.internal.telephony.IccConstants; +import com.android.internal.telephony.IccSmsInterfaceManager; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.PhoneProxy; +import com.android.internal.telephony.SmsRawData; + import java.util.ArrayList; import java.util.List; +import static android.telephony.SmsManager.STATUS_ON_ICC_FREE; + /** * SimSmsInterfaceManager to provide an inter-process communication to * access Sms in Sim. */ -public class SimSmsInterfaceManager extends ISms.Stub { +public class SimSmsInterfaceManager extends IccSmsInterfaceManager { static final String LOG_TAG = "GSM"; - static final boolean DBG = false; + static final boolean DBG = true; - private GSMPhone mPhone; private final Object mLock = new Object(); private boolean mSuccess; private List<SmsRawData> mSms; @@ -76,33 +80,31 @@ public class SimSmsInterfaceManager extends ISms.Stub { }; public SimSmsInterfaceManager(GSMPhone phone) { - this.mPhone = phone; - ServiceManager.addService("isms", this); + super(phone); + mDispatcher = new GsmSMSDispatcher(phone); } - private void enforceReceiveAndSend(String message) { - Context context = mPhone.getContext(); + public void dispose() { + } - context.enforceCallingPermission( - "android.permission.RECEIVE_SMS", message); - context.enforceCallingPermission( - "android.permission.SEND_SMS", message); + protected void finalize() { + if(DBG) Log.d(LOG_TAG, "SimSmsInterfaceManager finalized"); } /** * Update the specified message on the SIM. * * @param index record index of message to update - * @param status new message status (STATUS_ON_SIM_READ, - * STATUS_ON_SIM_UNREAD, STATUS_ON_SIM_SENT, - * STATUS_ON_SIM_UNSENT, STATUS_ON_SIM_FREE) + * @param status new message status (STATUS_ON_ICC_READ, + * STATUS_ON_ICC_UNREAD, STATUS_ON_ICC_SENT, + * STATUS_ON_ICC_UNSENT, STATUS_ON_ICC_FREE) * @param pdu the raw PDU to store * @return success or not * */ public boolean - updateMessageOnSimEf(int index, int status, byte[] pdu) { - if (DBG) log("updateMessageOnSimEf: index=" + index + + updateMessageOnIccEf(int index, int status, byte[] pdu) { + if (DBG) log("updateMessageOnIccEf: index=" + index + " status=" + status + " ==> " + "("+ pdu + ")"); enforceReceiveAndSend("Updating message on SIM"); @@ -110,13 +112,14 @@ public class SimSmsInterfaceManager extends ISms.Stub { mSuccess = false; Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE); - if (status == SmsManager.STATUS_ON_SIM_FREE) { + if (status == STATUS_ON_ICC_FREE) { // Special case FREE: call deleteSmsOnSim instead of // manipulating the SIM record mPhone.mCM.deleteSmsOnSim(index, response); } else { byte[] record = makeSmsRecordData(status, pdu); - mPhone.mSIMFileHandler.updateEFLinearFixed( SimConstants.EF_SMS, + ((SIMFileHandler)mPhone.getIccFileHandler()).updateEFLinearFixed( + IccConstants.EF_SMS, index, record, null, response); } try { @@ -132,21 +135,21 @@ public class SimSmsInterfaceManager extends ISms.Stub { * Copy a raw SMS PDU to the SIM. * * @param pdu the raw PDU to store - * @param status message status (STATUS_ON_SIM_READ, STATUS_ON_SIM_UNREAD, - * STATUS_ON_SIM_SENT, STATUS_ON_SIM_UNSENT) + * @param status message status (STATUS_ON_ICC_READ, STATUS_ON_ICC_UNREAD, + * STATUS_ON_ICC_SENT, STATUS_ON_ICC_UNSENT) * @return success or not * */ - public boolean copyMessageToSimEf(int status, byte[] pdu, byte[] smsc) { - if (DBG) log("copyMessageToSimEf: status=" + status + " ==> " + + public boolean copyMessageToIccEf(int status, byte[] pdu, byte[] smsc) { + if (DBG) log("copyMessageToIccEf: status=" + status + " ==> " + "pdu=("+ pdu + "), smsm=(" + smsc +")"); enforceReceiveAndSend("Copying message to SIM"); synchronized(mLock) { mSuccess = false; Message response = mHandler.obtainMessage(EVENT_UPDATE_DONE); - mPhone.mCM.writeSmsToSim(status, SimUtils.bytesToHexString(smsc), - SimUtils.bytesToHexString(pdu), response); + mPhone.mCM.writeSmsToSim(status, IccUtils.bytesToHexString(smsc), + IccUtils.bytesToHexString(pdu), response); try { mLock.wait(); @@ -158,11 +161,11 @@ public class SimSmsInterfaceManager extends ISms.Stub { } /** - * Retrieves all messages currently stored on SIM. + * Retrieves all messages currently stored on ICC. * - * @return list of SmsRawData of all sms on SIM + * @return list of SmsRawData of all sms on ICC */ - public List<SmsRawData> getAllMessagesFromSimEf() { + public List<SmsRawData> getAllMessagesFromIccEf() { if (DBG) log("getAllMessagesFromEF"); Context context = mPhone.getContext(); @@ -172,7 +175,7 @@ public class SimSmsInterfaceManager extends ISms.Stub { "Reading messages from SIM"); synchronized(mLock) { Message response = mHandler.obtainMessage(EVENT_LOAD_DONE); - mPhone.mSIMFileHandler.loadEFLinearFixedAll(SimConstants.EF_SMS, + ((SIMFileHandler)mPhone.getIccFileHandler()).loadEFLinearFixedAll(IccConstants.EF_SMS, response); try { @@ -184,119 +187,7 @@ public class SimSmsInterfaceManager extends ISms.Stub { return mSms; } - /** - * Send a Raw PDU SMS - * - * @param smsc the SMSC to send the message through, or NULL for the - * defatult SMSC - * @param pdu the raw PDU to send - * @param sentIntent if not NULL this <code>Intent</code> is - * broadcast when the message is sucessfully sent, or failed. - * The result code will be <code>Activity.RESULT_OK<code> for success, - * or one of these errors: - * <code>RESULT_ERROR_GENERIC_FAILURE</code> - * <code>RESULT_ERROR_RADIO_OFF</code> - * <code>RESULT_ERROR_NULL_PDU</code>. - * @param deliveryIntent if not NULL this <code>Intent</code> is - * broadcast when the message is delivered to the recipient. The - * raw pdu of the status report is in the extended data ("pdu"). - */ - public void sendRawPdu(byte[] smsc, byte[] pdu, PendingIntent sentIntent, - PendingIntent deliveryIntent) { - Context context = mPhone.getContext(); - - context.enforceCallingPermission( - "android.permission.SEND_SMS", - "Sending SMS message"); - if (DBG) log("sendRawPdu: smsc=" + smsc + - " pdu="+ pdu + " sentIntent" + sentIntent + - " deliveryIntent" + deliveryIntent); - mPhone.mSMS.sendRawPdu(smsc, pdu, sentIntent, deliveryIntent); - } - - /** - * Send a multi-part text based SMS. - * - * @param destinationAddress the address to send the message to - * @param scAddress is the service center address or null to use - * the current default SMSC - * @param parts an <code>ArrayList</code> of strings that, in order, - * comprise the original message - * @param sentIntents if not null, an <code>ArrayList</code> of - * <code>PendingIntent</code>s (one for each message part) that is - * broadcast when the corresponding message part has been sent. - * The result code will be <code>Activity.RESULT_OK<code> for success, - * or one of these errors: - * <code>RESULT_ERROR_GENERIC_FAILURE</code> - * <code>RESULT_ERROR_RADIO_OFF</code> - * <code>RESULT_ERROR_NULL_PDU</code>. - * @param deliveryIntents if not null, an <code>ArrayList</code> of - * <code>PendingIntent</code>s (one for each message part) that is - * broadcast when the corresponding message part has been delivered - * to the recipient. The raw pdu of the status report is in the - * extended data ("pdu"). - */ - public void sendMultipartText(String destinationAddress, String scAddress, List<String> parts, - List<PendingIntent> sentIntents, List<PendingIntent> deliveryIntents) { - Context context = mPhone.getContext(); - - context.enforceCallingPermission( - "android.permission.SEND_SMS", - "Sending SMS message"); - if (DBG) log("sendMultipartText"); - mPhone.mSMS.sendMultipartText(destinationAddress, scAddress, (ArrayList<String>) parts, - (ArrayList<PendingIntent>) sentIntents, (ArrayList<PendingIntent>) deliveryIntents); - } - - /** - * Generates an EF_SMS record from status and raw PDU. - * - * @param status Message status. See TS 51.011 10.5.3. - * @param pdu Raw message PDU. - * @return byte array for the record. - */ - private byte[] makeSmsRecordData(int status, byte[] pdu) { - byte[] data = new byte[SimConstants.SMS_RECORD_LENGTH]; - - // Status bits for this record. See TS 51.011 10.5.3 - data[0] = (byte)(status & 7); - - System.arraycopy(pdu, 0, data, 1, pdu.length); - - // Pad out with 0xFF's. - for (int j = pdu.length+1; j < SimConstants.SMS_RECORD_LENGTH; j++) { - data[j] = -1; - } - - return data; - } - - /** - * create SmsRawData lists from all sms record byte[] - * Use null to indicate "free" record - * - * @param messages List of message records from EF_SMS. - * @return SmsRawData list of all in-used records - */ - private ArrayList<SmsRawData> buildValidRawData(ArrayList<byte[]> messages) { - int count = messages.size(); - ArrayList<SmsRawData> ret; - - ret = new ArrayList<SmsRawData>(count); - - for (int i = 0; i < count; i++) { - byte[] ba = messages.get(i); - if (ba[0] == 0) { - ret.add(null); - } else { - ret.add(new SmsRawData(messages.get(i))); - } - } - - return ret; - } - - private void log(String msg) { - Log.d(LOG_TAG, "[SmsInterfaceManager] " + msg); + protected void log(String msg) { + Log.d(LOG_TAG, "[SimSmsInterfaceManager] " + msg); } } diff --git a/telephony/java/com/android/internal/telephony/gsm/SimTlv.java b/telephony/java/com/android/internal/telephony/gsm/SimTlv.java index 00879ce..30543c7 100644 --- a/telephony/java/com/android/internal/telephony/gsm/SimTlv.java +++ b/telephony/java/com/android/internal/telephony/gsm/SimTlv.java @@ -34,9 +34,8 @@ public class SimTlv int curDataOffset; int curDataLength; boolean hasValidTlvObject; - - public SimTlv(byte[] record, int offset, int length) - { + + public SimTlv(byte[] record, int offset, int length) { this.record = record; this.tlvOffset = offset; @@ -46,19 +45,15 @@ public class SimTlv hasValidTlvObject = parseCurrentTlvObject(); } - public boolean - nextObject() - { + public boolean nextObject() { if (!hasValidTlvObject) return false; curOffset = curDataOffset + curDataLength; - hasValidTlvObject = parseCurrentTlvObject(); + hasValidTlvObject = parseCurrentTlvObject(); return hasValidTlvObject; } - public boolean - isValidObject() - { + public boolean isValidObject() { return hasValidTlvObject; } @@ -68,9 +63,7 @@ public class SimTlv * 0 and 0xff are invalid tag values * valid tags range from 1 - 0xfe */ - public int - getTag() - { + public int getTag() { if (!hasValidTlvObject) return 0; return record[curOffset] & 0xff; } @@ -79,10 +72,8 @@ public class SimTlv * Returns data associated with current TLV object * returns null if !isValidObject() */ - - public byte[] - getData() - { + + public byte[] getData() { if (!hasValidTlvObject) return null; byte[] ret = new byte[curDataLength]; @@ -95,14 +86,12 @@ public class SimTlv * @return false on invalid record, true on valid record */ - private boolean - parseCurrentTlvObject() - { + private boolean parseCurrentTlvObject() { // 0x00 and 0xff are invalid tag values if (record[curOffset] == 0 || (record[curOffset] & 0xff) == 0xff) { return false; } - + try { if ((record[curOffset + 1] & 0xff) < 0x80) { // one byte length 0 - 0x7f diff --git a/telephony/java/com/android/internal/telephony/gsm/SmsMessage.java b/telephony/java/com/android/internal/telephony/gsm/SmsMessage.java new file mode 100644 index 0000000..867b719 --- /dev/null +++ b/telephony/java/com/android/internal/telephony/gsm/SmsMessage.java @@ -0,0 +1,1058 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.internal.telephony.gsm; + +import android.os.Parcel; +import android.telephony.PhoneNumberUtils; +import android.text.format.Time; +import android.util.Config; +import android.util.Log; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.EncodeException; +import com.android.internal.telephony.GsmAlphabet; +import com.android.internal.telephony.SmsHeader; +import com.android.internal.telephony.SmsMessageBase; + +import java.io.ByteArrayOutputStream; +import java.io.UnsupportedEncodingException; + +import static android.telephony.SmsMessage.ENCODING_7BIT; +import static android.telephony.SmsMessage.ENCODING_8BIT; +import static android.telephony.SmsMessage.ENCODING_16BIT; +import static android.telephony.SmsMessage.ENCODING_UNKNOWN; +import static android.telephony.SmsMessage.MAX_USER_DATA_BYTES; +import static android.telephony.SmsMessage.MAX_USER_DATA_BYTES_WITH_HEADER; +import static android.telephony.SmsMessage.MAX_USER_DATA_SEPTETS; +import static android.telephony.SmsMessage.MAX_USER_DATA_SEPTETS_WITH_HEADER; +import static android.telephony.SmsMessage.MessageClass; + +/** + * A Short Message Service message. + * + */ +public class SmsMessage extends SmsMessageBase{ + static final String LOG_TAG = "GSM"; + + private MessageClass messageClass; + + /** + * TP-Message-Type-Indicator + * 9.2.3 + */ + private int mti; + + /** TP-Protocol-Identifier (TP-PID) */ + private int protocolIdentifier; + + // TP-Data-Coding-Scheme + // see TS 23.038 + private int dataCodingScheme; + + // TP-Reply-Path + // e.g. 23.040 9.2.2.1 + private boolean replyPathPresent = false; + + // "Message Marked for Automatic Deletion Group" + // 23.038 Section 4 + private boolean automaticDeletion; + + /** True if Status Report is for SMS-SUBMIT; false for SMS-COMMAND. */ + private boolean forSubmit; + + /** The address of the receiver. */ + private GsmSmsAddress recipientAddress; + + /** Time when SMS-SUBMIT was delivered from SC to MSE. */ + private long dischargeTimeMillis; + + /** + * TP-Status - status of a previously submitted SMS. + * This field applies to SMS-STATUS-REPORT messages. 0 indicates success; + * see TS 23.040, 9.2.3.15 for description of other possible values. + */ + private int status; + + /** + * TP-Status - status of a previously submitted SMS. + * This field is true iff the message is a SMS-STATUS-REPORT message. + */ + private boolean isStatusReportMessage = false; + + public static class SubmitPdu extends SubmitPduBase { + } + + /** + * Create an SmsMessage from a raw PDU. + */ + public static SmsMessage createFromPdu(byte[] pdu) { + try { + SmsMessage msg = new SmsMessage(); + msg.parsePdu(pdu); + return msg; + } catch (RuntimeException ex) { + Log.e(LOG_TAG, "SMS PDU parsing failed: ", ex); + return null; + } + } + + /** + * TS 27.005 3.4.1 lines[0] and lines[1] are the two lines read from the + * +CMT unsolicited response (PDU mode, of course) + * +CMT: [<alpha>],<length><CR><LF><pdu> + * + * Only public for debugging + * + * {@hide} + */ + public static SmsMessage newFromCMT(String[] lines) { + try { + SmsMessage msg = new SmsMessage(); + msg.parsePdu(IccUtils.hexStringToBytes(lines[1])); + return msg; + } catch (RuntimeException ex) { + Log.e(LOG_TAG, "SMS PDU parsing failed: ", ex); + return null; + } + } + + /** @hide */ + public static SmsMessage newFromCMTI(String line) { + // the thinking here is not to read the message immediately + // FTA test case + Log.e(LOG_TAG, "newFromCMTI: not yet supported"); + return null; + } + + /** @hide */ + public static SmsMessage newFromCDS(String line) { + try { + SmsMessage msg = new SmsMessage(); + msg.parsePdu(IccUtils.hexStringToBytes(line)); + return msg; + } catch (RuntimeException ex) { + Log.e(LOG_TAG, "CDS SMS PDU parsing failed: ", ex); + return null; + } + } + + /** + * Note: This functionality is currently not supported in GSM mode. + * @hide + */ + public static SmsMessageBase newFromParcel(Parcel p){ + Log.w(LOG_TAG, "newFromParcel: is not supported in GSM mode."); + return null; + } + + /** + * Create an SmsMessage from an SMS EF record. + * + * @param index Index of SMS record. This should be index in ArrayList + * returned by SmsManager.getAllMessagesFromSim + 1. + * @param data Record data. + * @return An SmsMessage representing the record. + * + * @hide + */ + public static SmsMessage createFromEfRecord(int index, byte[] data) { + try { + SmsMessage msg = new SmsMessage(); + + msg.indexOnIcc = index; + + // First byte is status: RECEIVED_READ, RECEIVED_UNREAD, STORED_SENT, + // or STORED_UNSENT + // See TS 51.011 10.5.3 + if ((data[0] & 1) == 0) { + Log.w(LOG_TAG, + "SMS parsing failed: Trying to parse a free record"); + return null; + } else { + msg.statusOnIcc = data[0] & 0x07; + } + + int size = data.length - 1; + + // Note: Data may include trailing FF's. That's OK; message + // should still parse correctly. + byte[] pdu = new byte[size]; + System.arraycopy(data, 1, pdu, 0, size); + msg.parsePdu(pdu); + return msg; + } catch (RuntimeException ex) { + Log.e(LOG_TAG, "SMS PDU parsing failed: ", ex); + return null; + } + } + + /** + * Get the TP-Layer-Length for the given SMS-SUBMIT PDU Basically, the + * length in bytes (not hex chars) less the SMSC header + */ + public static int getTPLayerLengthForPDU(String pdu) { + int len = pdu.length() / 2; + int smscLen = 0; + + smscLen = Integer.parseInt(pdu.substring(0, 2), 16); + + return len - smscLen - 1; + } + + /** + * Get an SMS-SUBMIT PDU for a destination address and a message + * + * @param scAddress Service Centre address. Null means use default. + * @return a <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message. + * Returns null on encode error. + * @hide + */ + public static SubmitPdu getSubmitPdu(String scAddress, + String destinationAddress, String message, + boolean statusReportRequested, byte[] header) { + + // Perform null parameter checks. + if (message == null || destinationAddress == null) { + return null; + } + + SubmitPdu ret = new SubmitPdu(); + // MTI = SMS-SUBMIT, UDHI = header != null + byte mtiByte = (byte)(0x01 | (header != null ? 0x40 : 0x00)); + ByteArrayOutputStream bo = getSubmitPduHead( + scAddress, destinationAddress, mtiByte, + statusReportRequested, ret); + + try { + // First, try encoding it with the GSM alphabet + + // User Data (and length) + byte[] userData = GsmAlphabet.stringToGsm7BitPackedWithHeader(message, header); + + if ((0xff & userData[0]) > MAX_USER_DATA_SEPTETS) { + // Message too long + return null; + } + + // TP-Data-Coding-Scheme + // Default encoding, uncompressed + bo.write(0x00); + + // (no TP-Validity-Period) + + bo.write(userData, 0, userData.length); + } catch (EncodeException ex) { + byte[] userData, textPart; + // Encoding to the 7-bit alphabet failed. Let's see if we can + // send it as a UCS-2 encoded message + + try { + textPart = message.getBytes("utf-16be"); + } catch (UnsupportedEncodingException uex) { + Log.e(LOG_TAG, + "Implausible UnsupportedEncodingException ", + uex); + return null; + } + + if (header != null) { + userData = new byte[header.length + textPart.length]; + + System.arraycopy(header, 0, userData, 0, header.length); + System.arraycopy(textPart, 0, userData, header.length, textPart.length); + } + else { + userData = textPart; + } + + if (userData.length > MAX_USER_DATA_BYTES) { + // Message too long + return null; + } + + // TP-Data-Coding-Scheme + // Class 3, UCS-2 encoding, uncompressed + bo.write(0x0b); + + // (no TP-Validity-Period) + + // TP-UDL + bo.write(userData.length); + + bo.write(userData, 0, userData.length); + } + + ret.encodedMessage = bo.toByteArray(); + return ret; + } + + /** + * Get an SMS-SUBMIT PDU for a destination address and a message + * + * @param scAddress Service Centre address. Null means use default. + * @return a <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message. + * Returns null on encode error. + */ + public static SubmitPdu getSubmitPdu(String scAddress, + String destinationAddress, String message, + boolean statusReportRequested) { + + return getSubmitPdu(scAddress, destinationAddress, message, statusReportRequested, null); + } + + /** + * Get an SMS-SUBMIT PDU for a data message to a destination address & port + * + * @param scAddress Service Centre address. null == use default + * @param destinationAddress the address of the destination for the message + * @param destinationPort the port to deliver the message to at the + * destination + * @param data the dat for the message + * @return a <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message. + * Returns null on encode error. + */ + public static SubmitPdu getSubmitPdu(String scAddress, + String destinationAddress, short destinationPort, byte[] data, + boolean statusReportRequested) { + if (data.length > (MAX_USER_DATA_BYTES - 7 /* UDH size */)) { + Log.e(LOG_TAG, "SMS data message may only contain " + + (MAX_USER_DATA_BYTES - 7) + " bytes"); + return null; + } + + SubmitPdu ret = new SubmitPdu(); + ByteArrayOutputStream bo = getSubmitPduHead( + scAddress, destinationAddress, (byte) 0x41, // MTI = SMS-SUBMIT, + // TP-UDHI = true + statusReportRequested, ret); + + // TP-Data-Coding-Scheme + // No class, 8 bit data + bo.write(0x04); + + // (no TP-Validity-Period) + + // User data size + bo.write(data.length + 7); + + // User data header size + bo.write(0x06); // header is 6 octets + + // User data header, indicating the destination port + bo.write(SmsHeader.APPLICATION_PORT_ADDRESSING_16_BIT); // port + // addressing + // header + bo.write(0x04); // each port is 2 octets + bo.write((destinationPort >> 8) & 0xFF); // MSB of destination port + bo.write(destinationPort & 0xFF); // LSB of destination port + bo.write(0x00); // MSB of originating port + bo.write(0x00); // LSB of originating port + + // User data + bo.write(data, 0, data.length); + + ret.encodedMessage = bo.toByteArray(); + return ret; + } + + /** + * Create the beginning of a SUBMIT PDU. This is the part of the + * SUBMIT PDU that is common to the two versions of {@link #getSubmitPdu}, + * one of which takes a byte array and the other of which takes a + * <code>String</code>. + * + * @param scAddress Service Centre address. null == use default + * @param destinationAddress the address of the destination for the message + * @param mtiByte + * @param ret <code>SubmitPdu</code> containing the encoded SC + * address, if applicable, and the encoded message + */ + private static ByteArrayOutputStream getSubmitPduHead( + String scAddress, String destinationAddress, byte mtiByte, + boolean statusReportRequested, SubmitPdu ret) { + ByteArrayOutputStream bo = new ByteArrayOutputStream( + MAX_USER_DATA_BYTES + 40); + + // SMSC address with length octet, or 0 + if (scAddress == null) { + ret.encodedScAddress = null; + } else { + ret.encodedScAddress = PhoneNumberUtils.networkPortionToCalledPartyBCDWithLength( + scAddress); + } + + // TP-Message-Type-Indicator (and friends) + if (statusReportRequested) { + // Set TP-Status-Report-Request bit. + mtiByte |= 0x20; + if (Config.LOGD) Log.d(LOG_TAG, "SMS status report requested"); + } + bo.write(mtiByte); + + // space for TP-Message-Reference + bo.write(0); + + byte[] daBytes; + + daBytes = PhoneNumberUtils.networkPortionToCalledPartyBCD(destinationAddress); + + // destination address length in BCD digits, ignoring TON byte and pad + // TODO Should be better. + bo.write((daBytes.length - 1) * 2 + - ((daBytes[daBytes.length - 1] & 0xf0) == 0xf0 ? 1 : 0)); + + // destination address + bo.write(daBytes, 0, daBytes.length); + + // TP-Protocol-Identifier + bo.write(0); + return bo; + } + + static class PduParser { + byte pdu[]; + int cur; + SmsHeader userDataHeader; + byte[] userData; + int mUserDataSeptetPadding; + int mUserDataSize; + + PduParser(String s) { + this(IccUtils.hexStringToBytes(s)); + } + + PduParser(byte[] pdu) { + this.pdu = pdu; + cur = 0; + mUserDataSeptetPadding = 0; + } + + /** + * Parse and return the SC address prepended to SMS messages coming via + * the TS 27.005 / AT interface. Returns null on invalid address + */ + String getSCAddress() { + int len; + String ret; + + // length of SC Address + len = getByte(); + + if (len == 0) { + // no SC address + ret = null; + } else { + // SC address + try { + ret = PhoneNumberUtils + .calledPartyBCDToString(pdu, cur, len); + } catch (RuntimeException tr) { + Log.d(LOG_TAG, "invalid SC address: ", tr); + ret = null; + } + } + + cur += len; + + return ret; + } + + /** + * returns non-sign-extended byte value + */ + int getByte() { + return pdu[cur++] & 0xff; + } + + /** + * Any address except the SC address (eg, originating address) See TS + * 23.040 9.1.2.5 + */ + GsmSmsAddress getAddress() { + GsmSmsAddress ret; + + // "The Address-Length field is an integer representation of + // the number field, i.e. excludes any semi octet containing only + // fill bits." + // The TOA field is not included as part of this + int addressLength = pdu[cur] & 0xff; + int lengthBytes = 2 + (addressLength + 1) / 2; + + ret = new GsmSmsAddress(pdu, cur, lengthBytes); + + cur += lengthBytes; + + return ret; + } + + /** + * Parses an SC timestamp and returns a currentTimeMillis()-style + * timestamp + */ + + long getSCTimestampMillis() { + // TP-Service-Centre-Time-Stamp + int year = IccUtils.bcdByteToInt(pdu[cur++]); + int month = IccUtils.bcdByteToInt(pdu[cur++]); + int day = IccUtils.bcdByteToInt(pdu[cur++]); + int hour = IccUtils.bcdByteToInt(pdu[cur++]); + int minute = IccUtils.bcdByteToInt(pdu[cur++]); + int second = IccUtils.bcdByteToInt(pdu[cur++]); + + // For the timezone, the most significant bit of the + // least signficant nibble is the sign byte + // (meaning the max range of this field is 79 quarter-hours, + // which is more than enough) + + byte tzByte = pdu[cur++]; + + // Mask out sign bit. + int timezoneOffset = IccUtils + .bcdByteToInt((byte) (tzByte & (~0x08))); + + timezoneOffset = ((tzByte & 0x08) == 0) ? timezoneOffset + : -timezoneOffset; + + Time time = new Time(Time.TIMEZONE_UTC); + + // It's 2006. Should I really support years < 2000? + time.year = year >= 90 ? year + 1900 : year + 2000; + time.month = month - 1; + time.monthDay = day; + time.hour = hour; + time.minute = minute; + time.second = second; + + // Timezone offset is in quarter hours. + return time.toMillis(true) - (timezoneOffset * 15 * 60 * 1000); + } + + /** + * Pulls the user data out of the PDU, and separates the payload from + * the header if there is one. + * + * @param hasUserDataHeader true if there is a user data header + * @param dataInSeptets true if the data payload is in septets instead + * of octets + * @return the number of septets or octets in the user data payload + */ + int constructUserData(boolean hasUserDataHeader, boolean dataInSeptets) { + int offset = cur; + int userDataLength = pdu[offset++] & 0xff; + int headerSeptets = 0; + + if (hasUserDataHeader) { + int userDataHeaderLength = pdu[offset++] & 0xff; + + byte[] udh = new byte[userDataHeaderLength]; + System.arraycopy(pdu, offset, udh, 0, userDataHeaderLength); + userDataHeader = SmsHeader.parse(udh); + offset += userDataHeaderLength; + + int headerBits = (userDataHeaderLength + 1) * 8; + headerSeptets = headerBits / 7; + headerSeptets += (headerBits % 7) > 0 ? 1 : 0; + mUserDataSeptetPadding = (headerSeptets * 7) - headerBits; + } + + /* + * Here we just create the user data length to be the remainder of + * the pdu minus the user data hearder. This is because the count + * could mean the number of uncompressed sepets if the userdata is + * encoded in 7-bit. + */ + userData = new byte[pdu.length - offset]; + System.arraycopy(pdu, offset, userData, 0, userData.length); + cur = offset; + + if (dataInSeptets) { + // Return the number of septets + return userDataLength - headerSeptets; + } else { + // Return the number of octets + return userData.length; + } + } + + /** + * Returns the user data payload, not including the headers + * + * @return the user data payload, not including the headers + */ + byte[] getUserData() { + return userData; + } + + /** + * Returns the number of padding bits at the begining of the user data + * array before the start of the septets. + * + * @return the number of padding bits at the begining of the user data + * array before the start of the septets + */ + int getUserDataSeptetPadding() { + return mUserDataSeptetPadding; + } + + /** + * Returns an object representing the user data headers + * + * @return an object representing the user data headers + * + * {@hide} + */ + SmsHeader getUserDataHeader() { + return userDataHeader; + } + +/* + XXX Not sure what this one is supposed to be doing, and no one is using + it. + String getUserDataGSM8bit() { + // System.out.println("remainder of pud:" + + // HexDump.dumpHexString(pdu, cur, pdu.length - cur)); + int count = pdu[cur++] & 0xff; + int size = pdu[cur++]; + + // skip over header for now + cur += size; + + if (pdu[cur - 1] == 0x01) { + int tid = pdu[cur++] & 0xff; + int type = pdu[cur++] & 0xff; + + size = pdu[cur++] & 0xff; + + int i = cur; + + while (pdu[i++] != '\0') { + } + + int length = i - cur; + String mimeType = new String(pdu, cur, length); + + cur += length; + + if (false) { + System.out.println("tid = 0x" + HexDump.toHexString(tid)); + System.out.println("type = 0x" + HexDump.toHexString(type)); + System.out.println("header size = " + size); + System.out.println("mimeType = " + mimeType); + System.out.println("remainder of header:" + + HexDump.dumpHexString(pdu, cur, (size - mimeType.length()))); + } + + cur += size - mimeType.length(); + + // System.out.println("data count = " + count + " cur = " + cur + // + " :" + HexDump.dumpHexString(pdu, cur, pdu.length - cur)); + + MMSMessage msg = MMSMessage.parseEncoding(mContext, pdu, cur, + pdu.length - cur); + } else { + System.out.println(new String(pdu, cur, pdu.length - cur - 1)); + } + + return IccUtils.bytesToHexString(pdu); + } +*/ + + /** + * Interprets the user data payload as pack GSM 7bit characters, and + * decodes them into a String. + * + * @param septetCount the number of septets in the user data payload + * @return a String with the decoded characters + */ + String getUserDataGSM7Bit(int septetCount) { + String ret; + + ret = GsmAlphabet.gsm7BitPackedToString(pdu, cur, septetCount, + mUserDataSeptetPadding); + + cur += (septetCount * 7) / 8; + + return ret; + } + + /** + * Interprets the user data payload as UCS2 characters, and + * decodes them into a String. + * + * @param byteCount the number of bytes in the user data payload + * @return a String with the decoded characters + */ + String getUserDataUCS2(int byteCount) { + String ret; + + try { + ret = new String(pdu, cur, byteCount, "utf-16"); + } catch (UnsupportedEncodingException ex) { + ret = ""; + Log.e(LOG_TAG, "implausible UnsupportedEncodingException", ex); + } + + cur += byteCount; + return ret; + } + + boolean moreDataPresent() { + return (pdu.length > cur); + } + } + + /** {@inheritDoc} */ + public int getProtocolIdentifier() { + return protocolIdentifier; + } + + /** {@inheritDoc} */ + public boolean isReplace() { + return (protocolIdentifier & 0xc0) == 0x40 + && (protocolIdentifier & 0x3f) > 0 + && (protocolIdentifier & 0x3f) < 8; + } + + /** {@inheritDoc} */ + public boolean isCphsMwiMessage() { + return ((GsmSmsAddress) originatingAddress).isCphsVoiceMessageClear() + || ((GsmSmsAddress) originatingAddress).isCphsVoiceMessageSet(); + } + + /** {@inheritDoc} */ + public boolean isMWIClearMessage() { + if (isMwi && (mwiSense == false)) { + return true; + } + + return originatingAddress != null + && ((GsmSmsAddress) originatingAddress).isCphsVoiceMessageClear(); + } + + /** {@inheritDoc} */ + public boolean isMWISetMessage() { + if (isMwi && (mwiSense == true)) { + return true; + } + + return originatingAddress != null + && ((GsmSmsAddress) originatingAddress).isCphsVoiceMessageSet(); + } + + /** {@inheritDoc} */ + public boolean isMwiDontStore() { + if (isMwi && mwiDontStore) { + return true; + } + + if (isCphsMwiMessage()) { + // See CPHS 4.2 Section B.4.2.1 + // If the user data is a single space char, do not store + // the message. Otherwise, store and display as usual + if (" ".equals(getMessageBody())) { + ; + } + return true; + } + + return false; + } + + /** {@inheritDoc} */ + public int getStatus() { + return status; + } + + /** {@inheritDoc} */ + public boolean isStatusReportMessage() { + return isStatusReportMessage; + } + + /** {@inheritDoc} */ + public boolean isReplyPathPresent() { + return replyPathPresent; + } + + /** + * TS 27.005 3.1, <pdu> definition "In the case of SMS: 3GPP TS 24.011 [6] + * SC address followed by 3GPP TS 23.040 [3] TPDU in hexadecimal format: + * ME/TA converts each octet of TP data unit into two IRA character long + * hexad number (e.g. octet with integer value 42 is presented to TE as two + * characters 2A (IRA 50 and 65))" ...in the case of cell broadcast, + * something else... + */ + private void parsePdu(byte[] pdu) { + mPdu = pdu; + // Log.d(LOG_TAG, "raw sms mesage:"); + // Log.d(LOG_TAG, s); + + PduParser p = new PduParser(pdu); + + scAddress = p.getSCAddress(); + + if (scAddress != null) { + if (Config.LOGD) Log.d(LOG_TAG, "SMS SC address: " + scAddress); + } + + // TODO(mkf) support reply path, user data header indicator + + // TP-Message-Type-Indicator + // 9.2.3 + int firstByte = p.getByte(); + + mti = firstByte & 0x3; + switch (mti) { + // TP-Message-Type-Indicator + // 9.2.3 + case 0: + parseSmsDeliver(p, firstByte); + break; + case 2: + parseSmsStatusReport(p, firstByte); + break; + default: + // TODO(mkf) the rest of these + throw new RuntimeException("Unsupported message type"); + } + } + + /** + * Parses a SMS-STATUS-REPORT message. + * + * @param p A PduParser, cued past the first byte. + * @param firstByte The first byte of the PDU, which contains MTI, etc. + */ + private void parseSmsStatusReport(PduParser p, int firstByte) { + isStatusReportMessage = true; + + // TP-Status-Report-Qualifier bit == 0 for SUBMIT + forSubmit = (firstByte & 0x20) == 0x00; + // TP-Message-Reference + messageRef = p.getByte(); + // TP-Recipient-Address + recipientAddress = p.getAddress(); + // TP-Service-Centre-Time-Stamp + scTimeMillis = p.getSCTimestampMillis(); + // TP-Discharge-Time + dischargeTimeMillis = p.getSCTimestampMillis(); + // TP-Status + status = p.getByte(); + + // The following are optional fields that may or may not be present. + if (p.moreDataPresent()) { + // TP-Parameter-Indicator + int extraParams = p.getByte(); + int moreExtraParams = extraParams; + while ((moreExtraParams & 0x80) != 0) { + // We only know how to parse a few extra parameters, all + // indicated in the first TP-PI octet, so skip over any + // additional TP-PI octets. + moreExtraParams = p.getByte(); + } + // TP-Protocol-Identifier + if ((extraParams & 0x01) != 0) { + protocolIdentifier = p.getByte(); + } + // TP-Data-Coding-Scheme + if ((extraParams & 0x02) != 0) { + dataCodingScheme = p.getByte(); + } + // TP-User-Data-Length (implies existence of TP-User-Data) + if ((extraParams & 0x04) != 0) { + boolean hasUserDataHeader = (firstByte & 0x40) == 0x40; + parseUserData(p, hasUserDataHeader); + } + } + } + + private void parseSmsDeliver(PduParser p, int firstByte) { + replyPathPresent = (firstByte & 0x80) == 0x80; + + originatingAddress = p.getAddress(); + + if (originatingAddress != null) { + if (Config.LOGV) Log.v(LOG_TAG, "SMS originating address: " + + originatingAddress.address); + } + + // TP-Protocol-Identifier (TP-PID) + // TS 23.040 9.2.3.9 + protocolIdentifier = p.getByte(); + + // TP-Data-Coding-Scheme + // see TS 23.038 + dataCodingScheme = p.getByte(); + + if (Config.LOGV) { + Log.v(LOG_TAG, "SMS TP-PID:" + protocolIdentifier + + " data coding scheme: " + dataCodingScheme); + } + + scTimeMillis = p.getSCTimestampMillis(); + + if (Config.LOGD) Log.d(LOG_TAG, "SMS SC timestamp: " + scTimeMillis); + + boolean hasUserDataHeader = (firstByte & 0x40) == 0x40; + + parseUserData(p, hasUserDataHeader); + } + + /** + * Parses the User Data of an SMS. + * + * @param p The current PduParser. + * @param hasUserDataHeader Indicates whether a header is present in the + * User Data. + */ + private void parseUserData(PduParser p, boolean hasUserDataHeader) { + boolean hasMessageClass = false; + boolean userDataCompressed = false; + + int encodingType = ENCODING_UNKNOWN; + + // Look up the data encoding scheme + if ((dataCodingScheme & 0x80) == 0) { + // Bits 7..4 == 0xxx + automaticDeletion = (0 != (dataCodingScheme & 0x40)); + userDataCompressed = (0 != (dataCodingScheme & 0x20)); + hasMessageClass = (0 != (dataCodingScheme & 0x10)); + + if (userDataCompressed) { + Log.w(LOG_TAG, "4 - Unsupported SMS data coding scheme " + + "(compression) " + (dataCodingScheme & 0xff)); + } else { + switch ((dataCodingScheme >> 2) & 0x3) { + case 0: // GSM 7 bit default alphabet + encodingType = ENCODING_7BIT; + break; + + case 2: // UCS 2 (16bit) + encodingType = ENCODING_16BIT; + break; + + case 1: // 8 bit data + case 3: // reserved + Log.w(LOG_TAG, "1 - Unsupported SMS data coding scheme " + + (dataCodingScheme & 0xff)); + encodingType = ENCODING_8BIT; + break; + } + } + } else if ((dataCodingScheme & 0xf0) == 0xf0) { + automaticDeletion = false; + hasMessageClass = true; + userDataCompressed = false; + + if (0 == (dataCodingScheme & 0x04)) { + // GSM 7 bit default alphabet + encodingType = ENCODING_7BIT; + } else { + // 8 bit data + encodingType = ENCODING_8BIT; + } + } else if ((dataCodingScheme & 0xF0) == 0xC0 + || (dataCodingScheme & 0xF0) == 0xD0 + || (dataCodingScheme & 0xF0) == 0xE0) { + // 3GPP TS 23.038 V7.0.0 (2006-03) section 4 + + // 0xC0 == 7 bit, don't store + // 0xD0 == 7 bit, store + // 0xE0 == UCS-2, store + + if ((dataCodingScheme & 0xF0) == 0xE0) { + encodingType = ENCODING_16BIT; + } else { + encodingType = ENCODING_7BIT; + } + + userDataCompressed = false; + boolean active = ((dataCodingScheme & 0x08) == 0x08); + + // bit 0x04 reserved + + if ((dataCodingScheme & 0x03) == 0x00) { + isMwi = true; + mwiSense = active; + mwiDontStore = ((dataCodingScheme & 0xF0) == 0xC0); + } else { + isMwi = false; + + Log.w(LOG_TAG, "MWI for fax, email, or other " + + (dataCodingScheme & 0xff)); + } + } else { + Log.w(LOG_TAG, "3 - Unsupported SMS data coding scheme " + + (dataCodingScheme & 0xff)); + } + + // set both the user data and the user data header. + int count = p.constructUserData(hasUserDataHeader, + encodingType == ENCODING_7BIT); + this.userData = p.getUserData(); + this.userDataHeader = p.getUserDataHeader(); + + switch (encodingType) { + case ENCODING_UNKNOWN: + case ENCODING_8BIT: + messageBody = null; + break; + + case ENCODING_7BIT: + messageBody = p.getUserDataGSM7Bit(count); + break; + + case ENCODING_16BIT: + messageBody = p.getUserDataUCS2(count); + break; + } + + if (Config.LOGV) Log.v(LOG_TAG, "SMS message body (raw): '" + messageBody + "'"); + + if (messageBody != null) { + parseMessageBody(); + } + + if (!hasMessageClass) { + messageClass = MessageClass.UNKNOWN; + } else { + switch (dataCodingScheme & 0x3) { + case 0: + messageClass = MessageClass.CLASS_0; + break; + case 1: + messageClass = MessageClass.CLASS_1; + break; + case 2: + messageClass = MessageClass.CLASS_2; + break; + case 3: + messageClass = MessageClass.CLASS_3; + break; + } + } + } + + /** + * {@inheritDoc} + */ + public MessageClass getMessageClass() { + return messageClass; + } + +} diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/BerTlv.java b/telephony/java/com/android/internal/telephony/gsm/stk/BerTlv.java index 26c2175..19d3279 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/BerTlv.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/BerTlv.java @@ -20,9 +20,9 @@ import java.util.List; /** * Class for representing BER-TLV objects. - * + * * @see "ETSI TS 102 223 Annex C" for more information. - * + * * {@hide} */ class BerTlv { @@ -41,16 +41,16 @@ class BerTlv { /** * Gets a list of ComprehensionTlv objects contained in this BER-TLV object. - * + * * @return A list of COMPREHENSION-TLV object */ public List<ComprehensionTlv> getComprehensionTlvs() { return mCompTlvs; } - + /** * Gets a tag id of the BER-TLV object. - * + * * @return A tag integer. */ public int getTag() { @@ -59,7 +59,7 @@ class BerTlv { /** * Decodes a BER-TLV object from a byte array. - * + * * @param data A byte array to decode from * @return A BER-TLV object decoded * @throws ResultException diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/CommandParams.java b/telephony/java/com/android/internal/telephony/gsm/stk/CommandParams.java index 60e8148..a27c582 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/CommandParams.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/CommandParams.java @@ -19,7 +19,7 @@ package com.android.internal.telephony.gsm.stk; import android.graphics.Bitmap; /** - * Container class for proactive command parameters. + * Container class for proactive command parameters. * */ class CommandParams { diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/CommandParamsFactory.java b/telephony/java/com/android/internal/telephony/gsm/stk/CommandParamsFactory.java index eb354e9..06b36a4 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/CommandParamsFactory.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/CommandParamsFactory.java @@ -20,7 +20,7 @@ import android.graphics.Bitmap; import android.os.Handler; import android.os.Message; -import com.android.internal.telephony.gsm.GsmAlphabet; +import com.android.internal.telephony.GsmAlphabet; import com.android.internal.telephony.gsm.SIMFileHandler; import java.util.Iterator; diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/ComprehensionTlv.java b/telephony/java/com/android/internal/telephony/gsm/stk/ComprehensionTlv.java index 833ff3c..4f746ac 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/ComprehensionTlv.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/ComprehensionTlv.java @@ -22,9 +22,9 @@ import java.util.List; /** * Class for representing COMPREHENSION-TLV objects. - * + * * @see "ETSI TS 101 220 subsection 7.1.1" - * + * * {@hide} */ class ComprehensionTlv { @@ -38,7 +38,7 @@ class ComprehensionTlv { * Constructor. Private on purpose. Use * {@link #decodeMany(byte[], int) decodeMany} or * {@link #decode(byte[], int) decode} method. - * + * * @param tag The tag for this object * @param cr Comprehension Required flag * @param length Length of the value @@ -76,7 +76,7 @@ class ComprehensionTlv { /** * Parses a list of COMPREHENSION-TLV objects from a byte array. - * + * * @param data A byte array containing data to be parsed * @param startIndex Index in data at which to start parsing * @return A list of COMPREHENSION-TLV objects parsed @@ -97,7 +97,7 @@ class ComprehensionTlv { /** * Parses an COMPREHENSION-TLV object from a byte array. - * + * * @param data A byte array containing data to be parsed * @param startIndex Index in data at which to start parsing * @return A COMPREHENSION-TLV object parsed diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/IconLoader.java b/telephony/java/com/android/internal/telephony/gsm/stk/IconLoader.java index a63d1ca..fc02d2a 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/IconLoader.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/IconLoader.java @@ -30,9 +30,9 @@ import android.util.Log; import java.util.HashMap; /** - * Class for loading icons from the SIM card. Has two states: single, for loading + * Class for loading icons from the SIM card. Has two states: single, for loading * one icon. Multi, for loading icons list. - * + * */ class IconLoader extends Handler { // members @@ -51,13 +51,13 @@ class IconLoader extends Handler { private static IconLoader sLoader = null; - // Loader state values. + // Loader state values. private static final int STATE_SINGLE_ICON = 1; private static final int STATE_MULTI_ICONS = 2; - // Finished loading single record from a linear-fixed EF-IMG. + // Finished loading single record from a linear-fixed EF-IMG. private static final int EVENT_READ_EF_IMG_RECOED_DONE = 1; - // Finished loading single icon from a Transparent DF-Graphics. + // Finished loading single icon from a Transparent DF-Graphics. private static final int EVENT_READ_ICON_DONE = 2; // Finished loading single colour icon lookup table. private static final int EVENT_READ_CLUT_DONE = 3; @@ -170,10 +170,10 @@ class IconLoader extends Handler { } /** - * Handles Image descriptor parsing and required processing. This is the + * Handles Image descriptor parsing and required processing. This is the * first step required to handle retrieving icons from the SIM. - * - * @param data byte [] containing Image Instance descriptor as defined in + * + * @param data byte [] containing Image Instance descriptor as defined in * TS 51.011. */ private boolean handleImageDescriptor(byte[] rawData) { @@ -232,7 +232,7 @@ class IconLoader extends Handler { * @param data The raw data * @param length The length of image body * @return The bitmap - */ + */ public static Bitmap parseToBnW(byte[] data, int length){ int valueIndex = 0; int width = data[valueIndex++] & 0xFF; @@ -264,7 +264,7 @@ class IconLoader extends Handler { * 0 is black * 1 is white * @param bit to decode - * @return RGB color + * @return RGB color */ private static int bitToBnW(int bit){ if(bit == 1){ @@ -276,11 +276,11 @@ class IconLoader extends Handler { /** * a TS 131.102 image instance of code scheme '11' into color Bitmap - * + * * @param data The raw data * @param length the length of image body * @param transparency with or without transparency - * @param clut coulor lookup table + * @param clut coulor lookup table * @return The color bitmap */ public static Bitmap parseToRGB(byte[] data, int length, @@ -321,9 +321,9 @@ class IconLoader extends Handler { return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888); } - + /** - * Calculate bit mask for a given number of bits. The mask should enable to + * Calculate bit mask for a given number of bits. The mask should enable to * make a bitwise and to the given number of bits. * @param numOfBits number of bits to calculate mask for. * @return bit mask diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/ImageDescriptor.java b/telephony/java/com/android/internal/telephony/gsm/stk/ImageDescriptor.java index 7120a37..880b9e5 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/ImageDescriptor.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/ImageDescriptor.java @@ -33,7 +33,8 @@ public class ImageDescriptor { static final int CODING_SCHEME_BASIC = 0x11; static final int CODING_SCHEME_COLOUR = 0x21; - public static final int ID_LENGTH = 9; + // public static final int ID_LENGTH = 9; + // ID_LENGTH substituted by IccFileHandlerBase.GET_RESPONSE_EF_IMG_SIZE_BYTES ImageDescriptor() { width = 0; @@ -47,7 +48,7 @@ public class ImageDescriptor { /** * Extract descriptor information about image instance. - * + * * @param rawData * @param valueIndex * @return ImageDescriptor diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/ResponseData.java b/telephony/java/com/android/internal/telephony/gsm/stk/ResponseData.java index 9afa063..810afd2 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/ResponseData.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/ResponseData.java @@ -16,8 +16,8 @@ package com.android.internal.telephony.gsm.stk; -import com.android.internal.telephony.gsm.EncodeException; -import com.android.internal.telephony.gsm.GsmAlphabet; +import com.android.internal.telephony.EncodeException; +import com.android.internal.telephony.GsmAlphabet; import java.io.ByteArrayOutputStream; import java.io.UnsupportedEncodingException; diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/RilMessageDecoder.java b/telephony/java/com/android/internal/telephony/gsm/stk/RilMessageDecoder.java index 5d82473..1cf38ed 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/RilMessageDecoder.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/RilMessageDecoder.java @@ -17,7 +17,7 @@ package com.android.internal.telephony.gsm.stk; import com.android.internal.telephony.gsm.SIMFileHandler; -import com.android.internal.telephony.gsm.SimUtils; +import com.android.internal.telephony.IccUtils; import android.os.Handler; import android.os.HandlerState; @@ -142,7 +142,7 @@ class RilMessageDecoder extends HandlerStateMachine { case StkService.MSG_ID_REFRESH: byte[] rawData = null; try { - rawData = SimUtils.hexStringToBytes((String) rilMsg.mData); + rawData = IccUtils.hexStringToBytes((String) rilMsg.mData); } catch (Exception e) { // zombie messages are dropped StkLog.d(this, "decodeMessageParams dropping zombie messages"); diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/StkService.java b/telephony/java/com/android/internal/telephony/gsm/stk/StkService.java index c0c4ceb..3de14f0 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/StkService.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/StkService.java @@ -23,11 +23,13 @@ import android.os.Handler; import android.os.HandlerThread; import android.os.Message; -import com.android.internal.telephony.gsm.CommandsInterface; -import com.android.internal.telephony.gsm.GsmSimCard; +import com.android.internal.telephony.IccUtils; +import com.android.internal.telephony.CommandsInterface; +import com.android.internal.telephony.EncodeException; +import com.android.internal.telephony.GsmAlphabet; +import com.android.internal.telephony.gsm.SimCard; import com.android.internal.telephony.gsm.SIMFileHandler; import com.android.internal.telephony.gsm.SIMRecords; -import com.android.internal.telephony.gsm.SimUtils; import android.util.Config; @@ -115,10 +117,12 @@ class RilMessage { */ public class StkService extends Handler implements AppInterface { + // Class members + private static SIMRecords mSimRecords; + // Service members. private static StkService sInstance; private CommandsInterface mCmdIf; - private SIMRecords mSimRecords; private Context mContext; private StkCmdMessage mCurrntCmd = null; private StkCmdMessage mMenuCmd = null; @@ -147,7 +151,7 @@ public class StkService extends Handler implements AppInterface { /* Intentionally private for singleton */ private StkService(CommandsInterface ci, SIMRecords sr, Context context, - SIMFileHandler fh, GsmSimCard sc) { + SIMFileHandler fh, SimCard sc) { if (ci == null || sr == null || context == null || fh == null || sc == null) { throw new NullPointerException( @@ -172,6 +176,23 @@ public class StkService extends Handler implements AppInterface { mSimRecords.registerForRecordsLoaded(this, MSG_ID_SIM_LOADED, null); } + public void dispose() { + mSimRecords.unregisterForRecordsLoaded(this); + mCmdIf.unSetOnStkSessionEnd(this); + mCmdIf.unSetOnStkProactiveCmd(this); + mCmdIf.unSetOnStkEvent(this); + mCmdIf.unSetOnStkCallSetUp(this); + + this.removeCallbacksAndMessages(null); + + //removing instance + sInstance = null; + } + + protected void finalize() { + StkLog.d(this, "Service finalized"); + } + private void handleRilMsg(RilMessage rilMsg) { if (rilMsg == null) { return; @@ -334,7 +355,7 @@ public class StkService extends Handler implements AppInterface { } byte[] rawData = buf.toByteArray(); - String hexString = SimUtils.bytesToHexString(rawData); + String hexString = IccUtils.bytesToHexString(rawData); if (Config.LOGD) { StkLog.d(this, "TERMINAL RESPONSE: " + hexString); } @@ -380,7 +401,7 @@ public class StkService extends Handler implements AppInterface { int len = rawData.length - 2; // minus (tag + length) rawData[1] = (byte) len; - String hexString = SimUtils.bytesToHexString(rawData); + String hexString = IccUtils.bytesToHexString(rawData); mCmdIf.sendEnvelope(hexString, null); } @@ -423,7 +444,7 @@ public class StkService extends Handler implements AppInterface { int len = rawData.length - 2; // minus (tag + length) rawData[1] = (byte) len; - String hexString = SimUtils.bytesToHexString(rawData); + String hexString = IccUtils.bytesToHexString(rawData); mCmdIf.sendEnvelope(hexString, null); } @@ -439,7 +460,7 @@ public class StkService extends Handler implements AppInterface { * @return The only Service object in the system */ public static StkService getInstance(CommandsInterface ci, SIMRecords sr, - Context context, SIMFileHandler fh, GsmSimCard sc) { + Context context, SIMFileHandler fh, SimCard sc) { if (sInstance == null) { if (ci == null || sr == null || context == null || fh == null || sc == null) { @@ -448,6 +469,17 @@ public class StkService extends Handler implements AppInterface { HandlerThread thread = new HandlerThread("Stk Telephony service"); thread.start(); sInstance = new StkService(ci, sr, context, fh, sc); + StkLog.d(sInstance, "NEW sInstance"); + } else if ((sr != null) && (mSimRecords != sr)) { + StkLog.d(sInstance, String.format( + "Reinitialize the Service with SIMRecords sr=0x%x.", sr)); + mSimRecords = sr; + + // re-Register for SIM ready event. + mSimRecords.registerForRecordsLoaded(sInstance, MSG_ID_SIM_LOADED, null); + StkLog.d(sInstance, "sr changed reinitialize and return current sInstance"); + } else { + StkLog.d(sInstance, "Return current sInstance"); } return sInstance; } diff --git a/telephony/java/com/android/internal/telephony/gsm/stk/ValueParser.java b/telephony/java/com/android/internal/telephony/gsm/stk/ValueParser.java index 2cf87ba..8c8f977 100644 --- a/telephony/java/com/android/internal/telephony/gsm/stk/ValueParser.java +++ b/telephony/java/com/android/internal/telephony/gsm/stk/ValueParser.java @@ -16,8 +16,8 @@ package com.android.internal.telephony.gsm.stk; -import com.android.internal.telephony.gsm.GsmAlphabet; -import com.android.internal.telephony.gsm.SimUtils; +import com.android.internal.telephony.GsmAlphabet; +import com.android.internal.telephony.IccUtils; import com.android.internal.telephony.gsm.stk.Duration.TimeUnit; import java.io.UnsupportedEncodingException; @@ -117,7 +117,7 @@ abstract class ValueParser { try { int id = rawValue[valueIndex] & 0xff; - String text = SimUtils.adnStringFieldToString(rawValue, + String text = IccUtils.adnStringFieldToString(rawValue, valueIndex + 1, textLen); item = new Item(id, text); } catch (IndexOutOfBoundsException e) { @@ -278,7 +278,7 @@ abstract class ValueParser { int length = ctlv.getLength(); if (length != 0) { try { - return SimUtils.adnStringFieldToString(rawValue, valueIndex, + return IccUtils.adnStringFieldToString(rawValue, valueIndex, length); } catch (IndexOutOfBoundsException e) { throw new ResultException(ResultCode.CMD_DATA_NOT_UNDERSTOOD); diff --git a/telephony/java/com/android/internal/telephony/test/SimulatedCommands.java b/telephony/java/com/android/internal/telephony/test/SimulatedCommands.java index 33c1679..3e53654 100644 --- a/telephony/java/com/android/internal/telephony/test/SimulatedCommands.java +++ b/telephony/java/com/android/internal/telephony/test/SimulatedCommands.java @@ -23,19 +23,18 @@ import android.os.Looper; import android.os.Message; import android.util.Log; -import com.android.internal.telephony.Phone; -import com.android.internal.telephony.gsm.BaseCommands; +import com.android.internal.telephony.BaseCommands; +import com.android.internal.telephony.CommandException; +import com.android.internal.telephony.CommandsInterface; import com.android.internal.telephony.gsm.CallFailCause; -import com.android.internal.telephony.gsm.CommandException; -import com.android.internal.telephony.gsm.CommandsInterface; import com.android.internal.telephony.gsm.PDPContextState; import com.android.internal.telephony.gsm.SuppServiceNotification; +import com.android.internal.telephony.Phone; import java.util.ArrayList; public final class SimulatedCommands extends BaseCommands - implements CommandsInterface, SimulatedRadioControl -{ + implements CommandsInterface, SimulatedRadioControl { private final static String LOG_TAG = "SIM"; private enum SimLockState { @@ -43,14 +42,14 @@ public final class SimulatedCommands extends BaseCommands REQUIRE_PIN, REQUIRE_PUK, SIM_PERM_LOCKED - }; + } private enum SimFdnState { NONE, REQUIRE_PIN2, REQUIRE_PUK2, SIM_PERM_LOCKED - }; + } private final static SimLockState INITIAL_LOCK_STATE = SimLockState.NONE; private final static String DEFAULT_SIM_PIN_CODE = "1234"; @@ -103,11 +102,10 @@ public final class SimulatedCommands extends BaseCommands //***** CommandsInterface implementation - public void getSimStatus(Message result) - { + public void getIccStatus(Message result) { switch (mState) { case SIM_READY: - resultSuccess(result, SimStatus.SIM_READY); + resultSuccess(result, IccStatus.ICC_READY); break; case SIM_LOCKED_OR_ABSENT: @@ -115,7 +113,7 @@ public final class SimulatedCommands extends BaseCommands break; default: - resultSuccess(result, SimStatus.SIM_NOT_READY); + resultSuccess(result, IccStatus.ICC_NOT_READY); break; } } @@ -123,13 +121,13 @@ public final class SimulatedCommands extends BaseCommands private void returnSimLockedStatus(Message result) { switch (mSimLockedState) { case REQUIRE_PIN: - Log.i(LOG_TAG, "[SimCmd] returnSimLockedStatus: SIM_PIN"); - resultSuccess(result, SimStatus.SIM_PIN); + Log.i(LOG_TAG, "[SimCmd] returnSimLockedStatus: ICC_PIN"); + resultSuccess(result, IccStatus.ICC_PIN); break; case REQUIRE_PUK: - Log.i(LOG_TAG, "[SimCmd] returnSimLockedStatus: SIM_PUK"); - resultSuccess(result, SimStatus.SIM_PUK); + Log.i(LOG_TAG, "[SimCmd] returnSimLockedStatus: ICC_PUK"); + resultSuccess(result, IccStatus.ICC_PUK); break; default: @@ -139,9 +137,9 @@ public final class SimulatedCommands extends BaseCommands } } - public void supplySimPin(String pin, Message result) { + public void supplyIccPin(String pin, Message result) { if (mSimLockedState != SimLockState.REQUIRE_PIN) { - Log.i(LOG_TAG, "[SimCmd] supplySimPin: wrong state, state=" + + Log.i(LOG_TAG, "[SimCmd] supplyIccPin: wrong state, state=" + mSimLockedState); CommandException ex = new CommandException( CommandException.Error.PASSWORD_INCORRECT); @@ -151,7 +149,7 @@ public final class SimulatedCommands extends BaseCommands } if (pin != null && pin.equals(mPinCode)) { - Log.i(LOG_TAG, "[SimCmd] supplySimPin: success!"); + Log.i(LOG_TAG, "[SimCmd] supplyIccPin: success!"); setRadioState(RadioState.SIM_READY); mPinUnlockAttempts = 0; mSimLockedState = SimLockState.NONE; @@ -167,10 +165,10 @@ public final class SimulatedCommands extends BaseCommands if (result != null) { mPinUnlockAttempts ++; - Log.i(LOG_TAG, "[SimCmd] supplySimPin: failed! attempt=" + + Log.i(LOG_TAG, "[SimCmd] supplyIccPin: failed! attempt=" + mPinUnlockAttempts); if (mPinUnlockAttempts >= 3) { - Log.i(LOG_TAG, "[SimCmd] supplySimPin: set state to REQUIRE_PUK"); + Log.i(LOG_TAG, "[SimCmd] supplyIccPin: set state to REQUIRE_PUK"); mSimLockedState = SimLockState.REQUIRE_PUK; } @@ -181,9 +179,9 @@ public final class SimulatedCommands extends BaseCommands } } - public void supplySimPuk(String puk, String newPin, Message result) { + public void supplyIccPuk(String puk, String newPin, Message result) { if (mSimLockedState != SimLockState.REQUIRE_PUK) { - Log.i(LOG_TAG, "[SimCmd] supplySimPuk: wrong state, state=" + + Log.i(LOG_TAG, "[SimCmd] supplyIccPuk: wrong state, state=" + mSimLockedState); CommandException ex = new CommandException( CommandException.Error.PASSWORD_INCORRECT); @@ -193,7 +191,7 @@ public final class SimulatedCommands extends BaseCommands } if (puk != null && puk.equals(SIM_PUK_CODE)) { - Log.i(LOG_TAG, "[SimCmd] supplySimPuk: success!"); + Log.i(LOG_TAG, "[SimCmd] supplyIccPuk: success!"); setRadioState(RadioState.SIM_READY); mSimLockedState = SimLockState.NONE; mPukUnlockAttempts = 0; @@ -209,10 +207,10 @@ public final class SimulatedCommands extends BaseCommands if (result != null) { mPukUnlockAttempts ++; - Log.i(LOG_TAG, "[SimCmd] supplySimPuk: failed! attempt=" + + Log.i(LOG_TAG, "[SimCmd] supplyIccPuk: failed! attempt=" + mPukUnlockAttempts); if (mPukUnlockAttempts >= 10) { - Log.i(LOG_TAG, "[SimCmd] supplySimPuk: set state to SIM_PERM_LOCKED"); + Log.i(LOG_TAG, "[SimCmd] supplyIccPuk: set state to SIM_PERM_LOCKED"); mSimLockedState = SimLockState.SIM_PERM_LOCKED; } @@ -223,9 +221,9 @@ public final class SimulatedCommands extends BaseCommands } } - public void supplySimPin2(String pin2, Message result) { + public void supplyIccPin2(String pin2, Message result) { if (mSimFdnEnabledState != SimFdnState.REQUIRE_PIN2) { - Log.i(LOG_TAG, "[SimCmd] supplySimPin2: wrong state, state=" + + Log.i(LOG_TAG, "[SimCmd] supplyIccPin2: wrong state, state=" + mSimFdnEnabledState); CommandException ex = new CommandException( CommandException.Error.PASSWORD_INCORRECT); @@ -235,7 +233,7 @@ public final class SimulatedCommands extends BaseCommands } if (pin2 != null && pin2.equals(mPin2Code)) { - Log.i(LOG_TAG, "[SimCmd] supplySimPin2: success!"); + Log.i(LOG_TAG, "[SimCmd] supplyIccPin2: success!"); mPin2UnlockAttempts = 0; mSimFdnEnabledState = SimFdnState.NONE; @@ -250,10 +248,10 @@ public final class SimulatedCommands extends BaseCommands if (result != null) { mPin2UnlockAttempts ++; - Log.i(LOG_TAG, "[SimCmd] supplySimPin2: failed! attempt=" + + Log.i(LOG_TAG, "[SimCmd] supplyIccPin2: failed! attempt=" + mPin2UnlockAttempts); if (mPin2UnlockAttempts >= 3) { - Log.i(LOG_TAG, "[SimCmd] supplySimPin2: set state to REQUIRE_PUK2"); + Log.i(LOG_TAG, "[SimCmd] supplyIccPin2: set state to REQUIRE_PUK2"); mSimFdnEnabledState = SimFdnState.REQUIRE_PUK2; } @@ -264,9 +262,9 @@ public final class SimulatedCommands extends BaseCommands } } - public void supplySimPuk2(String puk2, String newPin2, Message result) { + public void supplyIccPuk2(String puk2, String newPin2, Message result) { if (mSimFdnEnabledState != SimFdnState.REQUIRE_PUK2) { - Log.i(LOG_TAG, "[SimCmd] supplySimPuk2: wrong state, state=" + + Log.i(LOG_TAG, "[SimCmd] supplyIccPuk2: wrong state, state=" + mSimLockedState); CommandException ex = new CommandException( CommandException.Error.PASSWORD_INCORRECT); @@ -276,7 +274,7 @@ public final class SimulatedCommands extends BaseCommands } if (puk2 != null && puk2.equals(SIM_PUK2_CODE)) { - Log.i(LOG_TAG, "[SimCmd] supplySimPuk2: success!"); + Log.i(LOG_TAG, "[SimCmd] supplyIccPuk2: success!"); mSimFdnEnabledState = SimFdnState.NONE; mPuk2UnlockAttempts = 0; @@ -291,10 +289,10 @@ public final class SimulatedCommands extends BaseCommands if (result != null) { mPuk2UnlockAttempts ++; - Log.i(LOG_TAG, "[SimCmd] supplySimPuk2: failed! attempt=" + + Log.i(LOG_TAG, "[SimCmd] supplyIccPuk2: failed! attempt=" + mPuk2UnlockAttempts); if (mPuk2UnlockAttempts >= 10) { - Log.i(LOG_TAG, "[SimCmd] supplySimPuk2: set state to SIM_PERM_LOCKED"); + Log.i(LOG_TAG, "[SimCmd] supplyIccPuk2: set state to SIM_PERM_LOCKED"); mSimFdnEnabledState = SimFdnState.SIM_PERM_LOCKED; } @@ -305,7 +303,7 @@ public final class SimulatedCommands extends BaseCommands } } - public void changeSimPin(String oldPin, String newPin, Message result) { + public void changeIccPin(String oldPin, String newPin, Message result) { if (oldPin != null && oldPin.equals(mPinCode)) { mPinCode = newPin; if (result != null) { @@ -317,7 +315,7 @@ public final class SimulatedCommands extends BaseCommands } if (result != null) { - Log.i(LOG_TAG, "[SimCmd] changeSimPin: pin failed!"); + Log.i(LOG_TAG, "[SimCmd] changeIccPin: pin failed!"); CommandException ex = new CommandException( CommandException.Error.PASSWORD_INCORRECT); @@ -326,7 +324,7 @@ public final class SimulatedCommands extends BaseCommands } } - public void changeSimPin2(String oldPin2, String newPin2, Message result) { + public void changeIccPin2(String oldPin2, String newPin2, Message result) { if (oldPin2 != null && oldPin2.equals(mPin2Code)) { mPin2Code = newPin2; if (result != null) { @@ -338,7 +336,7 @@ public final class SimulatedCommands extends BaseCommands } if (result != null) { - Log.i(LOG_TAG, "[SimCmd] changeSimPin: pin2 failed!"); + Log.i(LOG_TAG, "[SimCmd] changeIccPin2: pin2 failed!"); CommandException ex = new CommandException( CommandException.Error.PASSWORD_INCORRECT); @@ -348,14 +346,12 @@ public final class SimulatedCommands extends BaseCommands } public void - changeBarringPassword(String facility, String oldPwd, String newPwd, Message result) - { + changeBarringPassword(String facility, String oldPwd, String newPwd, Message result) { unimplemented(result); } public void - setSuppServiceNotifications(boolean enable, Message result) - { + setSuppServiceNotifications(boolean enable, Message result) { resultSuccess(result, null); if (enable && mSsnNotifyOn) { @@ -477,8 +473,7 @@ public final class SimulatedCommands extends BaseCommands * ar.result contains a List of DriverCall * The ar.result List is sorted by DriverCall.index */ - public void getCurrentCalls (Message result) - { + public void getCurrentCalls (Message result) { if (mState == RadioState.SIM_READY) { //Log.i("GSM", "[SimCmds] getCurrentCalls"); resultSuccess(result, simulatedCallState.getDriverCalls()); @@ -491,14 +486,20 @@ public final class SimulatedCommands extends BaseCommands } /** + * @deprecated + */ + public void getPDPContextList(Message result) { + getDataCallList(result); + } + + /** * returned message * retMsg.obj = AsyncResult ar * ar.exception carries exception on failure * ar.userObject contains the orignal value of result.obj * ar.result contains a List of PDPContextState */ - public void getPDPContextList(Message result) - { + public void getDataCallList(Message result) { resultSuccess(result, new ArrayList<PDPContextState>(0)); } @@ -513,8 +514,7 @@ public final class SimulatedCommands extends BaseCommands * CLIR_SUPPRESSION == on "CLIR suppression" (allow CLI presentation) * CLIR_INVOCATION == on "CLIR invocation" (restrict CLI presentation) */ - public void dial (String address, int clirMode, Message result) - { + public void dial (String address, int clirMode, Message result) { simulatedCallState.onDial(address); resultSuccess(result, null); @@ -527,8 +527,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is String containing IMSI on success */ - public void getIMSI(Message result) - { + public void getIMSI(Message result) { resultSuccess(result, "012345678901234"); } @@ -539,8 +538,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is String containing IMEI on success */ - public void getIMEI(Message result) - { + public void getIMEI(Message result) { resultSuccess(result, "012345678901234"); } @@ -551,8 +549,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is String containing IMEISV on success */ - public void getIMEISV(Message result) - { + public void getIMEISV(Message result) { resultSuccess(result, "99"); } @@ -567,8 +564,7 @@ public final class SimulatedCommands extends BaseCommands * 3GPP 22.030 6.5.5 * "Releases a specific active call X" */ - public void hangupConnection (int gsmIndex, Message result) - { + public void hangupConnection (int gsmIndex, Message result) { boolean success; success = simulatedCallState.onChld('1', (char)('0'+gsmIndex)); @@ -590,8 +586,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void hangupWaitingOrBackground (Message result) - { + public void hangupWaitingOrBackground (Message result) { boolean success; success = simulatedCallState.onChld('0', '\0'); @@ -612,8 +607,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void hangupForegroundResumeBackground (Message result) - { + public void hangupForegroundResumeBackground (Message result) { boolean success; success = simulatedCallState.onChld('1', '\0'); @@ -634,8 +628,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void switchWaitingOrHoldingAndActive (Message result) - { + public void switchWaitingOrHoldingAndActive (Message result) { boolean success; success = simulatedCallState.onChld('2', '\0'); @@ -655,8 +648,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void conference (Message result) - { + public void conference (Message result) { boolean success; success = simulatedCallState.onChld('3', '\0'); @@ -676,8 +668,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void explicitCallTransfer (Message result) - { + public void explicitCallTransfer (Message result) { boolean success; success = simulatedCallState.onChld('4', '\0'); @@ -694,8 +685,7 @@ public final class SimulatedCommands extends BaseCommands * "Places all active calls on hold except call X with which * communication shall be supported." */ - public void separateConnection (int gsmIndex, Message result) - { + public void separateConnection (int gsmIndex, Message result) { boolean success; char ch = (char)(gsmIndex + '0'); @@ -714,8 +704,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void acceptCall (Message result) - { + public void acceptCall (Message result) { boolean success; success = simulatedCallState.onAnswer(); @@ -733,8 +722,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void rejectCall (Message result) - { + public void rejectCall (Message result) { boolean success; success = simulatedCallState.onChld('0', '\0'); @@ -754,17 +742,22 @@ public final class SimulatedCommands extends BaseCommands * - Any defined in 22.001 F.4 (for generating busy/congestion) * - Cause 68: ACM >= ACMMax */ - public void getLastCallFailCause (Message result) - { + public void getLastCallFailCause (Message result) { int[] ret = new int[1]; ret[0] = nextCallFailCause; resultSuccess(result, ret); } - public void - getLastPdpFailCause (Message result) - { + /** + * @deprecated + */ + public void getLastPdpFailCause (Message result) { + unimplemented(result); + } + + public void getLastDataCallFailCause(Message result) { + // unimplemented(result); } @@ -779,8 +772,7 @@ public final class SimulatedCommands extends BaseCommands * response.obj.result[1] is bit error rate (0-7, 99) * as defined in TS 27.007 8.5 */ - public void getSignalStrength (Message result) - { + public void getSignalStrength (Message result) { int ret[] = new int[2]; ret[0] = 23; @@ -850,8 +842,7 @@ public final class SimulatedCommands extends BaseCommands * Please note that registration state 4 ("unknown") is treated * as "out of service" above */ - public void getRegistrationState (Message result) - { + public void getRegistrationState (Message result) { String ret[] = new String[3]; ret[0] = "5"; // registered roam @@ -878,8 +869,7 @@ public final class SimulatedCommands extends BaseCommands * Please note that registration state 4 ("unknown") is treated * as "out of service" in the Android telephony system */ - public void getGPRSRegistrationState (Message result) - { + public void getGPRSRegistrationState (Message result) { String ret[] = new String[4]; ret[0] = "5"; // registered roam @@ -896,8 +886,7 @@ public final class SimulatedCommands extends BaseCommands * response.obj.result[1] is short alpha or null if unregistered * response.obj.result[2] is numeric or null if unregistered */ - public void getOperator(Message result) - { + public void getOperator(Message result) { String[] ret = new String[3]; ret[0] = "El Telco Loco"; @@ -912,8 +901,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void sendDtmf(char c, Message result) - { + public void sendDtmf(char c, Message result) { resultSuccess(result, null); } @@ -922,8 +910,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void startDtmf(char c, Message result) - { + public void startDtmf(char c, Message result) { resultSuccess(result, null); } @@ -932,8 +919,7 @@ public final class SimulatedCommands extends BaseCommands * ar.userObject contains the orignal value of result.obj * ar.result is null on success and failure */ - public void stopDtmf(Message result) - { + public void stopDtmf(Message result) { resultSuccess(result, null); } @@ -950,16 +936,35 @@ public final class SimulatedCommands extends BaseCommands unimplemented(response); } + public void deleteSmsOnRuim(int index, Message response) { + Log.d(LOG_TAG, "Delete RUIM message at index " + index); + unimplemented(response); + } + public void writeSmsToSim(int status, String smsc, String pdu, Message response) { Log.d(LOG_TAG, "Write SMS to SIM with status " + status); unimplemented(response); } + public void writeSmsToRuim(int status, String pdu, Message response) { + Log.d(LOG_TAG, "Write SMS to RUIM with status " + status); + unimplemented(response); + } public void setupDefaultPDP(String apn, String user, String password, Message result) { unimplemented(result); } + public void setupDataCall(String radioTechnology, String profile, String apn, String user, + String password, Message result) { + unimplemented(result); + } + + public void deactivateDataCall(int cid, Message result) {unimplemented(result);} + + /** + * @deprecated + */ public void deactivateDefaultPDP(int cid, Message result) {unimplemented(result);} public void setPreferredNetworkType(int networkType , Message result) { @@ -994,9 +999,8 @@ public final class SimulatedCommands extends BaseCommands } return false; } - - public void setRadioPower(boolean on, Message result) - { + + public void setRadioPower(boolean on, Message result) { if(on) { if (isSimLocked()) { Log.i("SIM", "[SimCmd] setRadioPower: SIM locked! state=" + @@ -1016,12 +1020,16 @@ public final class SimulatedCommands extends BaseCommands unimplemented(result); } + public void acknowledgeLastIncomingCdmaSms(boolean success, Message result) { + unimplemented(result); + } + /** * parameters equivilient to 27.007 AT+CRSM command * response.obj will be an AsyncResult * response.obj.userObj will be a SimIoResult on success */ - public void simIO (int command, int fileid, String path, int p1, int p2, + public void iccIO (int command, int fileid, String path, int p1, int p2, int p3, String data, String pin2, Message result) { unimplemented(result); } @@ -1069,8 +1077,7 @@ public final class SimulatedCommands extends BaseCommands * @param response is callback message */ - public void queryCallWaiting(int serviceClass, Message response) - { + public void queryCallWaiting(int serviceClass, Message response) { unimplemented(response); } @@ -1081,8 +1088,7 @@ public final class SimulatedCommands extends BaseCommands */ public void setCallWaiting(boolean enable, int serviceClass, - Message response) - { + Message response) { unimplemented(response); } @@ -1092,7 +1098,7 @@ public final class SimulatedCommands extends BaseCommands * @param serviceClass is a sum of SERVICE_CLASSS_* */ public void setCallForward(int action, int cfReason, int serviceClass, - String number, int timeSeconds, Message result) {unimplemented(result);} + String number, int timeSeconds, Message result) {unimplemented(result);} /** * cfReason is one of CF_REASON_* @@ -1103,11 +1109,12 @@ public final class SimulatedCommands extends BaseCommands * An array of length 0 means "disabled for all codes" */ public void queryCallForwardStatus(int cfReason, int serviceClass, - String number, Message result) {unimplemented(result);} + String number, Message result) {unimplemented(result);} public void setNetworkSelectionModeAutomatic(Message result) {unimplemented(result);} - public void setNetworkSelectionModeManual(String operatorNumeric, Message result) {unimplemented(result);} + public void setNetworkSelectionModeManual( + String operatorNumeric, Message result) {unimplemented(result);} /** * Queries whether the current network selection mode is automatic @@ -1117,8 +1124,7 @@ public final class SimulatedCommands extends BaseCommands * a 0 for automatic selection and a 1 for manual selection */ - public void getNetworkSelectionMode(Message result) - { + public void getNetworkSelectionMode(Message result) { int ret[] = new int[1]; ret[0] = 0; @@ -1132,8 +1138,7 @@ public final class SimulatedCommands extends BaseCommands */ public void getAvailableNetworks(Message result) {unimplemented(result);} - public void getBasebandVersion (Message result) - { + public void getBasebandVersion (Message result) { resultSuccess(result, "SimulatedCommands"); } @@ -1172,13 +1177,11 @@ public final class SimulatedCommands extends BaseCommands } - public void resetRadio(Message result) - { + public void resetRadio(Message result) { unimplemented(result); } - public void invokeOemRilRequestRaw(byte[] data, Message response) - { + public void invokeOemRilRequestRaw(byte[] data, Message response) { // Just echo back data if (response != null) { AsyncResult.forMessage(response).result = data; @@ -1186,8 +1189,7 @@ public final class SimulatedCommands extends BaseCommands } } - public void invokeOemRilRequestStrings(String[] strings, Message response) - { + public void invokeOemRilRequestStrings(String[] strings, Message response) { // Just echo back data if (response != null) { AsyncResult.forMessage(response).result = strings; @@ -1200,23 +1202,20 @@ public final class SimulatedCommands extends BaseCommands /** Start the simulated phone ringing */ public void - triggerRing(String number) - { + triggerRing(String number) { simulatedCallState.triggerRing(number); mCallStateRegistrants.notifyRegistrants(); } public void - progressConnectingCallState() - { + progressConnectingCallState() { simulatedCallState.progressConnectingCallState(); mCallStateRegistrants.notifyRegistrants(); } /** If a call is DIALING or ALERTING, progress it all the way to ACTIVE */ public void - progressConnectingToActive() - { + progressConnectingToActive() { simulatedCallState.progressConnectingToActive(); mCallStateRegistrants.notifyRegistrants(); } @@ -1225,40 +1224,34 @@ public final class SimulatedCommands extends BaseCommands * default to true */ public void - setAutoProgressConnectingCall(boolean b) - { + setAutoProgressConnectingCall(boolean b) { simulatedCallState.setAutoProgressConnectingCall(b); } public void - setNextDialFailImmediately(boolean b) - { + setNextDialFailImmediately(boolean b) { simulatedCallState.setNextDialFailImmediately(b); } public void - setNextCallFailCause(int gsmCause) - { + setNextCallFailCause(int gsmCause) { nextCallFailCause = gsmCause; } public void - triggerHangupForeground() - { + triggerHangupForeground() { simulatedCallState.triggerHangupForeground(); mCallStateRegistrants.notifyRegistrants(); } /** hangup holding calls */ public void - triggerHangupBackground() - { + triggerHangupBackground() { simulatedCallState.triggerHangupBackground(); mCallStateRegistrants.notifyRegistrants(); } - public void triggerSsn(int type, int code) - { + public void triggerSsn(int type, int code) { SuppServiceNotification not = new SuppServiceNotification(); not.notificationType = type; not.code = code; @@ -1266,8 +1259,7 @@ public final class SimulatedCommands extends BaseCommands } public void - shutdown() - { + shutdown() { setRadioState(RadioState.RADIO_UNAVAILABLE); Looper looper = mHandlerThread.getLooper(); if (looper != null) { @@ -1278,27 +1270,23 @@ public final class SimulatedCommands extends BaseCommands /** hangup all */ public void - triggerHangupAll() - { + triggerHangupAll() { simulatedCallState.triggerHangupAll(); mCallStateRegistrants.notifyRegistrants(); } public void - triggerIncomingSMS(String message) - { + triggerIncomingSMS(String message) { //TODO } public void - pauseResponses() - { + pauseResponses() { pausedResponseCount++; } public void - resumeResponses() - { + resumeResponses() { pausedResponseCount--; if (pausedResponseCount == 0) { @@ -1313,8 +1301,7 @@ public final class SimulatedCommands extends BaseCommands //***** Private Methods - private void unimplemented(Message result) - { + private void unimplemented(Message result) { if (result != null) { AsyncResult.forMessage(result).exception = new RuntimeException("Unimplemented"); @@ -1327,8 +1314,7 @@ public final class SimulatedCommands extends BaseCommands } } - private void resultSuccess(Message result, Object ret) - { + private void resultSuccess(Message result, Object ret) { if (result != null) { AsyncResult.forMessage(result).result = ret; if (pausedResponseCount > 0) { @@ -1339,8 +1325,7 @@ public final class SimulatedCommands extends BaseCommands } } - private void resultFail(Message result, Throwable tr) - { + private void resultFail(Message result, Throwable tr) { if (result != null) { AsyncResult.forMessage(result).exception = tr; if (pausedResponseCount > 0) { @@ -1351,4 +1336,103 @@ public final class SimulatedCommands extends BaseCommands } } + // ***** Methods for CDMA support + public void + getDeviceIdentity(Message response) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(response); + } + + public void + getCDMASubscription(Message response) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(response); + } + + public void + setCdmaSubscription(int cdmaSubscriptionType, Message response) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(response); + } + + public void queryCdmaRoamingPreference(Message response) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(response); + } + + public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(response); + } + + public void + setPhoneType(int phoneType) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + } + + public void getPreferredVoicePrivacy(Message result) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(result); + } + + public void setPreferredVoicePrivacy(boolean enable, Message result) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(result); + } + + /** + * Set the TTY mode for the CDMA phone + * + * @param enable is true to enable, false to disable + * @param serviceClass is a sum of SERVICE_CLASS_* + * @param response is callback message + */ + public void setTTYModeEnabled(boolean enable, Message response) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(response); + } + + /** + * Query the TTY mode for the CDMA phone + * (AsyncResult)response.obj).result is an int[] with element [0] set to + * 0 for disabled, 1 for enabled. + * + * @param serviceClass is a sum of SERVICE_CLASS_* + * @param response is callback message + */ + public void queryTTYModeEnabled(Message response) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(response); + } + + /** + * {@inheritDoc} + */ + public void sendCDMAFeatureCode(String FeatureCode, Message response) { + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + unimplemented(response); + } + + /** + * {@inheritDoc} + */ + public void sendCdmaSms(byte[] pdu, Message response){ + Log.w(LOG_TAG, "CDMA not implemented in SimulatedCommands"); + } + + public void activateCdmaBroadcastSms(int activate, Message result) { + // TODO Auto-generated method stub + + } + + public void getCdmaBroadcastConfig(Message result) { + // TODO Auto-generated method stub + + } + + public void setCdmaBroadcastConfig(int[] configValuesArray, Message result) { + // TODO Auto-generated method stub + + } + } diff --git a/telephony/java/com/android/internal/telephony/test/SimulatedGsmCallState.java b/telephony/java/com/android/internal/telephony/test/SimulatedGsmCallState.java index 340d788..803735c 100644 --- a/telephony/java/com/android/internal/telephony/test/SimulatedGsmCallState.java +++ b/telephony/java/com/android/internal/telephony/test/SimulatedGsmCallState.java @@ -21,14 +21,13 @@ import android.os.Message; import android.os.Handler; import android.telephony.PhoneNumberUtils; import com.android.internal.telephony.ATParseEx; -import com.android.internal.telephony.gsm.DriverCall; +import com.android.internal.telephony.DriverCall; import java.util.List; import java.util.ArrayList; import android.util.Log; -class CallInfo -{ +class CallInfo { enum State { ACTIVE(0), HOLDING(1), @@ -49,8 +48,7 @@ class CallInfo String number; int TOA; - CallInfo (boolean isMT, State state, boolean isMpty, String number) - { + CallInfo (boolean isMT, State state, boolean isMpty, String number) { this.isMT = isMT; this.state = state; this.isMpty = isMpty; @@ -64,20 +62,17 @@ class CallInfo } static CallInfo - createOutgoingCall(String number) - { + createOutgoingCall(String number) { return new CallInfo (false, State.DIALING, false, number); } static CallInfo - createIncomingCall(String number) - { + createIncomingCall(String number) { return new CallInfo (true, State.INCOMING, false, number); } String - toCLCCLine(int index) - { + toCLCCLine(int index) { return "+CLCC: " + index + "," + (isMT ? "1" : "0") +"," @@ -86,8 +81,7 @@ class CallInfo } DriverCall - toDriverCall(int index) - { + toDriverCall(int index) { DriverCall ret; ret = new DriverCall(); @@ -112,36 +106,30 @@ class CallInfo boolean - isActiveOrHeld() - { + isActiveOrHeld() { return state == State.ACTIVE || state == State.HOLDING; } boolean - isConnecting() - { + isConnecting() { return state == State.DIALING || state == State.ALERTING; } boolean - isRinging() - { + isRinging() { return state == State.INCOMING || state == State.WAITING; } } -class InvalidStateEx extends Exception -{ - InvalidStateEx() - { +class InvalidStateEx extends Exception { + InvalidStateEx() { } } -class SimulatedGsmCallState extends Handler -{ +class SimulatedGsmCallState extends Handler { //***** Instance Variables CallInfo calls[] = new CallInfo[MAX_CALLS]; @@ -168,8 +156,7 @@ class SimulatedGsmCallState extends Handler } public void - handleMessage(Message msg) - { + handleMessage(Message msg) { synchronized(this) { switch (msg.what) { // PLEASE REMEMBER // calls may have hung up by the time delayed events happen @@ -181,15 +168,13 @@ class SimulatedGsmCallState extends Handler } //***** Public Methods - - + /** * Start the simulated phone ringing * true if succeeded, false if failed */ public boolean - triggerRing(String number) - { + triggerRing(String number) { synchronized (this) { int empty = -1; boolean isCallWaiting = false; @@ -230,8 +215,7 @@ class SimulatedGsmCallState extends Handler /** If a call is DIALING or ALERTING, progress it to the next state */ public void - progressConnectingCallState() - { + progressConnectingCallState() { synchronized (this) { for (int i = 0 ; i < calls.length ; i++) { CallInfo call = calls[i]; @@ -257,8 +241,7 @@ class SimulatedGsmCallState extends Handler /** If a call is DIALING or ALERTING, progress it all the way to ACTIVE */ public void - progressConnectingToActive() - { + progressConnectingToActive() { synchronized (this) { for (int i = 0 ; i < calls.length ; i++) { CallInfo call = calls[i]; @@ -277,14 +260,12 @@ class SimulatedGsmCallState extends Handler * default to true */ public void - setAutoProgressConnectingCall(boolean b) - { + setAutoProgressConnectingCall(boolean b) { autoProgressConnecting = b; } public void - setNextDialFailImmediately(boolean b) - { + setNextDialFailImmediately(boolean b) { nextDialFailImmediately = b; } @@ -293,8 +274,7 @@ class SimulatedGsmCallState extends Handler * returns true if call was hung up, false if not */ public boolean - triggerHangupForeground() - { + triggerHangupForeground() { synchronized (this) { boolean found; @@ -333,8 +313,7 @@ class SimulatedGsmCallState extends Handler * returns true if call was hung up, false if not */ public boolean - triggerHangupBackground() - { + triggerHangupBackground() { synchronized (this) { boolean found = false; @@ -356,8 +335,7 @@ class SimulatedGsmCallState extends Handler * returns true if call was hung up, false if not */ public boolean - triggerHangupAll() - { + triggerHangupAll() { synchronized(this) { boolean found = false; @@ -376,8 +354,7 @@ class SimulatedGsmCallState extends Handler } public boolean - onAnswer() - { + onAnswer() { synchronized (this) { for (int i = 0 ; i < calls.length ; i++) { CallInfo call = calls[i]; @@ -395,8 +372,7 @@ class SimulatedGsmCallState extends Handler } public boolean - onHangup() - { + onHangup() { boolean found = false; for (int i = 0 ; i < calls.length ; i++) { @@ -412,8 +388,7 @@ class SimulatedGsmCallState extends Handler } public boolean - onChld(char c0, char c1) - { + onChld(char c0, char c1) { boolean ret; int callIndex = 0; @@ -499,8 +474,7 @@ class SimulatedGsmCallState extends Handler public boolean - releaseActiveAcceptHeldOrWaiting() - { + releaseActiveAcceptHeldOrWaiting() { boolean foundHeld = false; boolean foundActive = false; @@ -555,8 +529,7 @@ class SimulatedGsmCallState extends Handler } public boolean - switchActiveAndHeldOrWaiting() - { + switchActiveAndHeldOrWaiting() { boolean hasHeld = false; // first, are there held calls? @@ -589,8 +562,7 @@ class SimulatedGsmCallState extends Handler public boolean - separateCall(int index) - { + separateCall(int index) { try { CallInfo c; @@ -631,8 +603,7 @@ class SimulatedGsmCallState extends Handler public boolean - conference() - { + conference() { int countCalls = 0; // if there's connecting calls, we can't do this yet @@ -662,8 +633,7 @@ class SimulatedGsmCallState extends Handler } public boolean - explicitCallTransfer() - { + explicitCallTransfer() { int countCalls = 0; // if there's connecting calls, we can't do this yet @@ -684,8 +654,7 @@ class SimulatedGsmCallState extends Handler } public boolean - onDial(String address) - { + onDial(String address) { CallInfo call; int freeSlot = -1; @@ -758,8 +727,7 @@ class SimulatedGsmCallState extends Handler } public List<DriverCall> - getDriverCalls() - { + getDriverCalls() { ArrayList<DriverCall> ret = new ArrayList<DriverCall>(calls.length); for (int i = 0 ; i < calls.length ; i++) { @@ -779,8 +747,7 @@ class SimulatedGsmCallState extends Handler } public List<String> - getClccLines() - { + getClccLines() { ArrayList<String> ret = new ArrayList<String>(calls.length); for (int i = 0 ; i < calls.length ; i++) { @@ -795,8 +762,7 @@ class SimulatedGsmCallState extends Handler } private int - countActiveLines() throws InvalidStateEx - { + countActiveLines() throws InvalidStateEx { boolean hasMpty = false; boolean hasHeld = false; boolean hasActive = false; diff --git a/telephony/jni/cdmasms/Android.mk b/telephony/jni/cdmasms/Android.mk new file mode 100644 index 0000000..b0c96b4 --- /dev/null +++ b/telephony/jni/cdmasms/Android.mk @@ -0,0 +1,24 @@ +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES:= \ + cdma_sms_jni.cpp + +LOCAL_SHARED_LIBRARIES := \ + libcutils \ + libutils \ + libandroid_runtime \ + libnativehelper + +LOCAL_MODULE:= libcdma_sms_jni + +LOCAL_C_INCLUDES += \ + $(JNI_H_INCLUDE) \ + hardware/ril/include/telephony + +LOCAL_C_INCLUDES += hardware/ril/reference-cdma-sms +LOCAL_SHARED_LIBRARIES += libreference-cdma-sms +LOCAL_CFLAGS += -DREFERENCE_CDMA_SMS + +LOCAL_PRELINK_MODULE := false +include $(BUILD_SHARED_LIBRARY) diff --git a/telephony/jni/cdmasms/cdma_sms_jni.cpp b/telephony/jni/cdmasms/cdma_sms_jni.cpp new file mode 100644 index 0000000..2a8e825 --- /dev/null +++ b/telephony/jni/cdmasms/cdma_sms_jni.cpp @@ -0,0 +1,1300 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file cdma_sms_jni.cpp + * + * This file implement the Java Native Interface + * for encoding and decoding of SMS + */ + + +#include <nativehelper/jni.h> +#include <nativehelper/JNIHelp.h> +#include <android_runtime/AndroidRuntime.h> +#include <cdma_sms_jni.h> + + +#ifdef __cplusplus +extern "C" { +#endif //__cplusplus + +#include <reference-cdma-sms.h> + +#ifdef __cplusplus +} +#endif //__cplusplus + +#undef LOG_TAG +#define LOG_TAG "CDMA" +#include <utils/Log.h> + +static RIL_CDMA_SMS_ClientBd *clientBdData = NULL; + + +static jint getObjectIntField(JNIEnv * env, jobject obj, const char *name, jint * value) +{ + jclass clazz; + jfieldID field; + +#ifdef DBG_LOG_LEVEL_B + LOGD("getObjectIntField():"); +#endif + + clazz = env->GetObjectClass(obj); + if (NULL == clazz) { + jniThrowException(env, "java/lang/Exception", NULL); + return JNI_FAILURE; + } + + field = env->GetFieldID(clazz, name, "I"); + env->DeleteLocalRef(clazz); + + if (NULL == field) { + jniThrowException(env, "java/lang/NoSuchFieldException", name); + return JNI_FAILURE; + } + + *value = env->GetIntField(obj, field); + +#ifdef DBG_LOG_LEVEL_B + LOGD(" %s = %d\n", name, *value); +#endif + + return JNI_SUCCESS; +} + +static jint setObjectIntField(JNIEnv * env, jobject obj, const char *name, jint value) +{ + jclass clazz; + jfieldID field; + +#ifdef DBG_LOG_LEVEL_B + LOGD("setObjectIntField(): %s = %d\n", name, value); +#endif + + clazz = env->GetObjectClass(obj); + if (NULL == clazz) { + jniThrowException(env, "java/lang/Exception", NULL); + return JNI_FAILURE; + } + + field = env->GetFieldID(clazz, name, "I"); + env->DeleteLocalRef(clazz); + + if (NULL == field) { + jniThrowException(env, "java/lang/NoSuchFieldException", name); + return JNI_FAILURE; + } + + env->SetIntField(obj, field, value); + + return JNI_SUCCESS; +} + +static jint getObjectByteField(JNIEnv * env, jobject obj, const char *name, jbyte * value) +{ + jclass clazz; + jfieldID field; + +#ifdef DBG_LOG_LEVEL_B + LOGD("getObjectByteField():"); +#endif + + clazz = env->GetObjectClass(obj); + if (NULL == clazz) { + jniThrowException(env, "java/lang/Exception", NULL); + return JNI_FAILURE; + } + + field = env->GetFieldID(clazz, name, "B"); + env->DeleteLocalRef(clazz); + + if (NULL == field) { + jniThrowException(env, "java/lang/NoSuchFieldException", name); + return JNI_FAILURE; + } + + *value = env->GetByteField(obj, field); + +#ifdef DBG_LOG_LEVEL_B + LOGD(" %s = %02x\n", name, *value); +#endif + + return JNI_SUCCESS; +} + +static jint setObjectByteField(JNIEnv * env, jobject obj, const char *name, jbyte value) +{ + jclass clazz; + jfieldID field; +#ifdef DBG_LOG_LEVEL_B + LOGD("setObjectByteField(): %s = 0x%02x\n", name, value); +#endif + + clazz = env->GetObjectClass(obj); + if (NULL == clazz) { + jniThrowException(env, "java/lang/Exception", NULL); + return JNI_FAILURE; + } + + field = env->GetFieldID(clazz, name, "B"); + env->DeleteLocalRef(clazz); + + if (NULL == field) { + jniThrowException(env, "java/lang/NoSuchFieldException", name); + return JNI_FAILURE; + } + + env->SetByteField(obj, field, value); + + return JNI_SUCCESS; +} + +static jint getObjectBooleanField(JNIEnv * env, jobject obj, const char *name, jboolean * value) +{ + jclass clazz; + jfieldID field; + +#ifdef DBG_LOG_LEVEL_B + LOGD("getObjectBooleanField():"); +#endif + + clazz = env->GetObjectClass(obj); + if (NULL == clazz) { + jniThrowException(env, "java/lang/Exception", NULL); + return JNI_FAILURE; + } + + field = env->GetFieldID(clazz, name, "Z"); + env->DeleteLocalRef(clazz); + + if (NULL == field) { + jniThrowException(env, "java/lang/NoSuchFieldException", name); + return JNI_FAILURE; + } + + *value = env->GetBooleanField(obj, field); + +#ifdef DBG_LOG_LEVEL_B + LOGD(" %s = %d\n", name, *value); +#endif + + return JNI_SUCCESS; +} + +static jint setObjectBooleanField(JNIEnv * env, jobject obj, const char *name, jboolean value) +{ + jclass clazz; + jfieldID field; + +#ifdef DBG_LOG_LEVEL_B + LOGD("setObjectBooleanField(): %s = %d\n", name, value); +#endif + + clazz = env->GetObjectClass(obj); + if (NULL == clazz) { + jniThrowException(env, "java/lang/Exception", NULL); + return JNI_FAILURE; + } + + field = env->GetFieldID(clazz, name, "Z"); + env->DeleteLocalRef(clazz); + + if (NULL == field) { + jniThrowException(env, "java/lang/NoSuchFieldException", name); + return JNI_FAILURE; + } + + env->SetBooleanField(obj, field, value); + + return JNI_SUCCESS; +} + +static jint getObjectByteArrayField(JNIEnv * env, jobject obj, const char *name, jbyte* arrData, int* length) +{ + jclass clazz; + jfieldID field; + jbyte * data_buf; + +#ifdef DBG_LOG_LEVEL_B + LOGD("getObjectByteArrayField(): %s\n", name); +#endif + + clazz = env->GetObjectClass(obj); + if (NULL == clazz) { + jniThrowException(env, "java/lang/Exception", NULL); + return JNI_FAILURE; + } + + field = env->GetFieldID(clazz, name, "[B"); + env->DeleteLocalRef(clazz); + + if (NULL == field) { + jniThrowException(env, "java/lang/NoSuchFieldException", name); + return JNI_FAILURE; + } + + jbyteArray buffer = (jbyteArray)(env->GetObjectField(obj, field)); + if (buffer != NULL) { + int len = env->GetArrayLength(buffer); + data_buf = env->GetByteArrayElements(buffer, NULL); + for (int i=0; i<len; i++) { + *arrData++ = data_buf[i]; +#ifdef DBG_LOG_LEVEL_B + LOGD(" [%d] = 0x%02x\n", i, data_buf[i]); +#endif + } + *length = len; + } else { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return JNI_FAILURE; + } + + return JNI_SUCCESS; +} + +static jint setObjectByteArrayField(JNIEnv * env, jobject obj, const char *name, jbyte* arrData, int length) +{ + jclass clazz; + jfieldID field; + jbyte* byte_buf; + +#ifdef DBG_LOG_LEVEL_B + LOGD("setObjectByteArrayField(): %s\n", name); +#endif + + clazz = env->GetObjectClass(obj); + if (NULL == clazz) { + jniThrowException(env, "java/lang/Exception", NULL); + return JNI_FAILURE; + } + + field = env->GetFieldID(clazz, name, "[B"); + env->DeleteLocalRef(clazz); + + if (NULL == field) { + jniThrowException(env, "java/lang/NoSuchFieldException", name); + return JNI_FAILURE; + } + + jbyteArray buffer = (jbyteArray)(env->GetObjectField(obj, field)); + if (buffer == NULL) { +#ifdef DBG_LOG_LEVEL_B + LOGD("setObjectByteArrayField(): %s = null\n", name); +#endif + buffer = env->NewByteArray(length); + env->SetObjectField(obj, field, buffer); + } + + if (buffer != NULL) { +#ifdef DBG_LOG_LEVEL_B + for (int i=0; i<length; i++) { + LOGD(" [%d] = 0x%02x\n", i, arrData[i]); + } +#endif + env->SetByteArrayRegion(buffer, 0, length, arrData); + } else { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return JNI_FAILURE; + } + + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jint JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsConstructClientBD + (JNIEnv * env, jobject obj) +{ +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsConstructClientBD()...\n"); +#endif + + clientBdData = (RIL_CDMA_SMS_ClientBd *)malloc(sizeof(RIL_CDMA_SMS_ClientBd)); + if (NULL == clientBdData) { + jniThrowException(env, "java/lang/OutOfMemoryError", "clientBdData memory allocation failed"); + return JNI_FAILURE; + } + memset(clientBdData, 0, sizeof(RIL_CDMA_SMS_ClientBd)); + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jint JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsDestructClientBD + (JNIEnv * env, jobject obj) +{ +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsDestructClientBD()...\n"); +#endif + + if (clientBdData == NULL) { + jniThrowException(env, "java/lang/NullPointerException", "clientBdData is null"); + return JNI_FAILURE; + } + free(clientBdData); + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jint JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetBearerDataPrimitives + (JNIEnv * env, jobject obj, jobject bearerData) +{ + jbyteArray mc_time = NULL; + jbyte mctime_buffer[6]; + int length; + jint intData; + jbyte byteData; + jboolean booleanData; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsSetBearerDataPrimitives()...\n"); +#endif + + // mask + if (getObjectIntField(env, bearerData, "mask", &intData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->mask = intData; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->mask = 0x%x\n", clientBdData->mask); +#endif + + // message_id.type + if (getObjectByteField(env, bearerData, "messageType", &byteData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->message_id.type = (RIL_CDMA_SMS_BdMessageType)(byteData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->message_id.type = 0x%02x\n", clientBdData->message_id.type); +#endif + + // message_id.id_number + if ((clientBdData->mask & WMS_MASK_BD_MSG_ID) == WMS_MASK_BD_MSG_ID) { + if (getObjectIntField(env, bearerData, "messageID", &intData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->message_id.id_number = (RIL_CDMA_SMS_MessageNumber)(intData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->message_id.id_number = %d\n", clientBdData->message_id.id_number); +#endif + } + + // message_id.udh_present + if (getObjectBooleanField(env, bearerData, "hasUserDataHeader", &booleanData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->message_id.udh_present = (unsigned char)(booleanData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->message_id.udh_present = %d\n", clientBdData->message_id.udh_present); +#endif + + // user_response + // TODO + + // mc_time + if ((clientBdData->mask & WMS_MASK_BD_MC_TIME) == WMS_MASK_BD_MC_TIME) { + if (getObjectByteArrayField(env, bearerData, "timeStamp", mctime_buffer, &length) != JNI_SUCCESS) + return JNI_FAILURE; + if (mctime_buffer != NULL) { + clientBdData->mc_time.year = mctime_buffer[0]; + clientBdData->mc_time.month = mctime_buffer[1]; + clientBdData->mc_time.day = mctime_buffer[2]; + clientBdData->mc_time.hour = mctime_buffer[3]; + clientBdData->mc_time.minute = mctime_buffer[4]; + clientBdData->mc_time.second = mctime_buffer[5]; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->mc_time.year = %d\n", clientBdData->mc_time.year); + LOGD("clientBdData->mc_time.month = %d\n", clientBdData->mc_time.month); + LOGD("clientBdData->mc_time.day = %d\n", clientBdData->mc_time.day); + LOGD("clientBdData->mc_time.hour = %d\n", clientBdData->mc_time.hour); + LOGD("clientBdData->mc_time.minute = %d\n", clientBdData->mc_time.minute); + LOGD("clientBdData->mc_time.second = %d\n", clientBdData->mc_time.second); +#endif + } + } + + // clientBdData->mc_time.timezone + // TODO + + // validity_absolute; + // TODO + + // validity_relative; + // TODO + + // deferred_absolute + // TODO + + // deferred_relative; + // TODO + + // priority + // TODO + + // privacy + // TODO + + if ((clientBdData->mask & WMS_MASK_BD_REPLY_OPTION) == WMS_MASK_BD_REPLY_OPTION) { + // reply_option.user_ack_requested + if (getObjectBooleanField(env, bearerData, "userAckReq", &booleanData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->reply_option.user_ack_requested = (unsigned char)(booleanData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->reply_option.user_ack_requested = %d\n", clientBdData->reply_option.user_ack_requested); +#endif + // reply_option.user_ack_requested + if (getObjectBooleanField(env, bearerData, "deliveryAckReq", &booleanData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->reply_option.delivery_ack_requested = (unsigned char)(booleanData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->reply_option.delivery_ack_requested = %d\n", clientBdData->reply_option.delivery_ack_requested); +#endif + // reply_option.user_ack_requested + if (getObjectBooleanField(env, bearerData, "readAckReq", &booleanData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->reply_option.read_ack_requested = (unsigned char)(booleanData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->reply_option.read_ack_requested = %d\n", clientBdData->reply_option.read_ack_requested); +#endif + } + + // num_messages + if ((clientBdData->mask & WMS_MASK_BD_NUM_OF_MSGS) == WMS_MASK_BD_NUM_OF_MSGS) { + if (getObjectIntField(env, bearerData, "numberOfMessages", &intData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->num_messages = (unsigned char)(intData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->num_messages = %d\n", clientBdData->num_messages); +#endif + } + + // alert_mode + // TODO + + // language + // TODO + + // display_mode + if ((clientBdData->mask & WMS_MASK_BD_DISPLAY_MODE) == WMS_MASK_BD_DISPLAY_MODE) { + if (getObjectByteField(env, bearerData, "displayMode", &byteData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->display_mode = (RIL_CDMA_SMS_DisplayMode)(byteData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->display_mode = 0x%02x\n", clientBdData->display_mode); +#endif + } + + // delivery_status + if ((clientBdData->mask & WMS_MASK_BD_DELIVERY_STATUS) == WMS_MASK_BD_DELIVERY_STATUS) { + // delivery_status.error_class + if (getObjectIntField(env, bearerData, "errorClass", &intData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->delivery_status.error_class = (RIL_CDMA_SMS_ErrorClass)(intData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->delivery_status.error_class = %d\n", clientBdData->delivery_status.error_class); +#endif + // delivery_status.status + if (getObjectIntField(env, bearerData, "messageStatus", &intData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->delivery_status.status = (RIL_CDMA_SMS_DeliveryStatusE)(intData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->delivery_status.status = %d\n", clientBdData->delivery_status.status); +#endif + } + + // deposit_index + // TODO + + // ip_address + // TODO + + // rsn_no_notify + // TODO + + // other + // TODO + + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jint JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetBearerDataPrimitives + (JNIEnv * env, jobject obj, jobject bearerData) +{ + jclass BearerDataClass; + jfieldID field; + jbyte mctime_buffer[6]; + jbyteArray addr_array; + int length; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsGetBearerDataPrimitives()...\n"); +#endif + + // mask +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->mask = 0x%x\n", clientBdData->mask); +#endif + if (setObjectIntField(env, bearerData, "mask", clientBdData->mask) != JNI_SUCCESS) + return JNI_FAILURE; + + // message_id.type +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->message_id.type = 0x%02x\n", clientBdData->message_id.type); +#endif + if (setObjectByteField(env, bearerData, "messageType", (jbyte)clientBdData->message_id.type) != JNI_SUCCESS) + return JNI_FAILURE; + + // message_id.id_number + if ((clientBdData->mask & WMS_MASK_BD_MSG_ID) == WMS_MASK_BD_MSG_ID) { +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->message_id.id_number = %d\n", clientBdData->message_id.id_number); +#endif + if (setObjectIntField(env, bearerData, "messageID", clientBdData->message_id.id_number) != JNI_SUCCESS) + return JNI_FAILURE; + } + + // message_id.udh_present +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->message_id.udh_present = %d\n", clientBdData->message_id.udh_present); +#endif + if (setObjectBooleanField(env, bearerData, "hasUserDataHeader", (jboolean)clientBdData->message_id.udh_present) != JNI_SUCCESS) + return JNI_FAILURE; + + // user_response + // TODO + + // mc_time + if ((clientBdData->mask & WMS_MASK_BD_MC_TIME) == WMS_MASK_BD_MC_TIME) { + jclass clazz= env->GetObjectClass(bearerData); + if (NULL == clazz) + return JNI_FAILURE; + jfieldID field = env->GetFieldID(clazz, "timeStamp", "[B"); + env->DeleteLocalRef(clazz); + + addr_array = env->NewByteArray((jsize)6); + env->SetObjectField(bearerData, field, addr_array); + +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->mc_time.year = %d\n", clientBdData->mc_time.year); + LOGD("clientBdData->mc_time.month = %d\n", clientBdData->mc_time.month); + LOGD("clientBdData->mc_time.day = %d\n", clientBdData->mc_time.day); + LOGD("clientBdData->mc_time.hour = %d\n", clientBdData->mc_time.hour); + LOGD("clientBdData->mc_time.minute = %d\n", clientBdData->mc_time.minute); + LOGD("clientBdData->mc_time.second = %d\n", clientBdData->mc_time.second); +#endif + mctime_buffer[0] = clientBdData->mc_time.year; + mctime_buffer[1] = clientBdData->mc_time.month; + mctime_buffer[2] = clientBdData->mc_time.day; + mctime_buffer[3] = clientBdData->mc_time.hour; + mctime_buffer[4] = clientBdData->mc_time.minute; + mctime_buffer[5] = clientBdData->mc_time.second; + length = sizeof(mctime_buffer) / sizeof(jbyte); + if (setObjectByteArrayField(env, bearerData, "timeStamp", mctime_buffer, length) != JNI_SUCCESS) + return JNI_FAILURE; + } + + // clientBdData->mc_time.timezone + // TODO + + // validity_absolute; + // TODO + + // validity_relative; + // TODO + + // deferred_absolute + // TODO + + // deferred_relative; + // TODO + + // priority + // TODO + + // privacy + // TODO + + if ((clientBdData->mask & WMS_MASK_BD_REPLY_OPTION) == WMS_MASK_BD_REPLY_OPTION) { + // reply_option.user_ack_requested +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->reply_option.user_ack_requested = %d\n", clientBdData->reply_option.user_ack_requested); +#endif + if (setObjectBooleanField(env, bearerData, "userAckReq", (jboolean)clientBdData->reply_option.user_ack_requested) != JNI_SUCCESS) + return JNI_FAILURE; + + // reply_option.user_ack_requested +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->reply_option.delivery_ack_requested = %d\n", clientBdData->reply_option.delivery_ack_requested); +#endif + if (setObjectBooleanField(env, bearerData, "deliveryAckReq", (jboolean)clientBdData->reply_option.delivery_ack_requested) != JNI_SUCCESS) + return JNI_FAILURE; + + // reply_option.user_ack_requested +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->reply_option.read_ack_requested = %d\n", clientBdData->reply_option.read_ack_requested); +#endif + if (setObjectBooleanField(env, bearerData, "readAckReq", (jboolean)clientBdData->reply_option.read_ack_requested) != JNI_SUCCESS) + return JNI_FAILURE; + } + + // num_messages + if ((clientBdData->mask & WMS_MASK_BD_NUM_OF_MSGS) == WMS_MASK_BD_NUM_OF_MSGS) { +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->num_messages = %d\n", clientBdData->num_messages); +#endif + if (setObjectIntField(env, bearerData, "numberOfMessages", (int)clientBdData->num_messages) != JNI_SUCCESS) + return JNI_FAILURE; + } + + // alert_mode + // TODO + + // language + // TODO + + // display_mode + if ((clientBdData->mask & WMS_MASK_BD_DISPLAY_MODE) == WMS_MASK_BD_DISPLAY_MODE) { +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->display_mode = 0x%02x\n", clientBdData->display_mode); +#endif + if (setObjectByteField(env, bearerData, "displayMode", (jbyte)clientBdData->display_mode) != JNI_SUCCESS) + return JNI_FAILURE; + } + + // delivery_status + if ((clientBdData->mask & WMS_MASK_BD_DELIVERY_STATUS) == WMS_MASK_BD_DELIVERY_STATUS) { +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->delivery_status.error_class = %d\n", clientBdData->delivery_status.error_class); +#endif + // delivery_status.error_class + if (setObjectIntField(env, bearerData, "errorClass", (int)clientBdData->delivery_status.error_class) != JNI_SUCCESS) + return JNI_FAILURE; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->delivery_status.status = %d\n", clientBdData->delivery_status.status); +#endif + // delivery_status.status + if (setObjectIntField(env, bearerData, "messageStatus", (int)clientBdData->delivery_status.status) != JNI_SUCCESS) + return JNI_FAILURE; + } + + // deposit_index + // TODO + + // ip_address + // TODO + + // rsn_no_notify + // TODO + + // other + // TODO + + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jint JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetUserData + (JNIEnv * env, jobject obj, jobject userData) +{ + jclass UserDataClass; + jfieldID field; + jbyteArray arrData = NULL; + jbyte data_buf[RIL_CDMA_SMS_USER_DATA_MAX]; + int length; + jint intData; + jbyte byteData; + jboolean booleanData; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsSetUserData()...\n"); +#endif + + // set num_headers to 0 here, increment later + clientBdData->user_data.num_headers = 0; + + // user_data.encoding + if (getObjectIntField(env, userData, "userDataEncoding", &intData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->user_data.encoding = (RIL_CDMA_SMS_UserDataEncoding)(intData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.encoding = %d\n", clientBdData->user_data.encoding); +#endif + + // is91ep_type + // TODO + + // user_data.padding_bits + if (getObjectIntField(env, userData, "paddingBits", &intData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->user_data.padding_bits = (unsigned char)(intData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.padding_bits = %d\n", clientBdData->user_data.padding_bits); +#endif + + // user_data.data + if (getObjectByteArrayField(env, userData, "userData", data_buf, &length) != JNI_SUCCESS ) + return JNI_FAILURE; + for (int i = 0; i < length; i++) { + clientBdData->user_data.data[i] = data_buf[i]; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.data[%d] = 0x%02x\n", i, clientBdData->user_data.data[i]); +#endif + } + + // user_data.data_len + // TODO + + // number_of_digits + clientBdData->user_data.number_of_digits = (unsigned char)(length); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.number_of_digits = %d\n", clientBdData->user_data.number_of_digits); +#endif + + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jint JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetUserData + (JNIEnv * env, jobject obj, jobject userData) +{ + jclass UserDataClass; + jfieldID field; + jbyte *data_buf; + int length; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsGetUserData()...\n"); +#endif + + // user_data.num_headers +// if (setObjectIntField(env, userData, "mNumberOfHeaders", (int)clientBdData->user_data.num_headers) != JNI_SUCCESS) +// return JNI_FAILURE; + + // user_data.encoding +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.encoding = %d\n", clientBdData->user_data.encoding); +#endif + if (setObjectIntField(env, userData, "userDataEncoding", clientBdData->user_data.encoding) != JNI_SUCCESS) + return JNI_FAILURE; + + // is91ep_type + // TODO + + // user_data.data_len +// if (setObjectIntField(env, userData, "mDataLength", (int)clientBdData->user_data.data_len) != JNI_SUCCESS) +// return JNI_FAILURE; + + // user_data.padding_bits +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.padding_bits = %d\n", clientBdData->user_data.padding_bits); +#endif + if (setObjectIntField(env, userData, "paddingBits", (int)clientBdData->user_data.padding_bits) != JNI_SUCCESS) + return JNI_FAILURE; + + // user_data.data +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.data_len = %d\n", clientBdData->user_data.data_len); +#endif + length = clientBdData->user_data.data_len; +#ifdef DBG_LOG_LEVEL_A + for (int i = 0; i < length; i++) { + LOGD("clientBdData->user_data.data[%d] = 0x%02x\n", i, clientBdData->user_data.data[i]); + } +#endif + data_buf = (jbyte*)clientBdData->user_data.data; + if (setObjectByteArrayField(env, userData, "userData", data_buf, length) != JNI_SUCCESS) + return JNI_FAILURE; + + // number_of_digits + // TODO + + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetUserDataHeader + (JNIEnv * env, jobject obj, jint ID, jbyteArray data, jint length, jint index) +{ + jbyte data_buf[length]; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsSetUserDataHeader()...\n"); +#endif + + env->GetByteArrayRegion(data, 0, length, data_buf); + + // user_data.headers[index].header_id + clientBdData->user_data.headers[index].header_id = (RIL_CDMA_SMS_UdhId)(ID); + + // user_data.headers[index].u + // TODO: add support for all udh id's + switch(clientBdData->user_data.headers[index].header_id) + { + case RIL_CDMA_SMS_UDH_CONCAT_8: + clientBdData->user_data.headers[index].u.concat_8.msg_ref = data_buf[0]; + clientBdData->user_data.headers[index].u.concat_8.total_sm = data_buf[1]; + clientBdData->user_data.headers[index].u.concat_8.seq_num = data_buf[2]; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.concat_8.msg_ref = 0x%02x\n", index, clientBdData->user_data.headers[index].u.concat_8.msg_ref); + LOGD("clientBdData->user_data.headers[%d].u.concat_8.total_sm = 0x%02x\n", index, clientBdData->user_data.headers[index].u.concat_8.total_sm); + LOGD("clientBdData->user_data.headers[%d].u.concat_8.seq_num = 0x%02x\n", index, clientBdData->user_data.headers[index].u.concat_8.seq_num); +#endif + break; + case RIL_CDMA_SMS_UDH_SPECIAL_SM: + clientBdData->user_data.headers[index].u.special_sm.msg_waiting = (RIL_CDMA_SMS_GWMsgWaiting)( + (data_buf[0] << 23) | (data_buf[1] << 15) | + (data_buf[2] << 7) | data_buf[3]); + clientBdData->user_data.headers[index].u.special_sm.msg_waiting_kind = (RIL_CDMA_SMS_GWMsgWaitingKind)( + (data_buf[4] << 23) | (data_buf[5] << 15) | + (data_buf[6] << 7) | data_buf[7]); + clientBdData->user_data.headers[index].u.special_sm.message_count = data_buf[8]; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.special_sm.msg_waiting = 0x%04x\n", index, clientBdData->user_data.headers[index].u.special_sm.msg_waiting); + LOGD("clientBdData->user_data.headers[%d].u.special_sm.msg_waiting_kind = 0x%04x\n", index, clientBdData->user_data.headers[index].u.special_sm.msg_waiting_kind); + LOGD("clientBdData->user_data.headers[%d].u.special_sm.message_count = 0x%02x\n", index, clientBdData->user_data.headers[index].u.special_sm.message_count); +#endif + break; + case RIL_CDMA_SMS_UDH_PORT_8: + clientBdData->user_data.headers[index].u.wap_8.dest_port = data_buf[0]; + clientBdData->user_data.headers[index].u.wap_8.orig_port = data_buf[1]; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.wap_8.dest_port = 0x%02x\n", index, clientBdData->user_data.headers[index].u.wap_8.dest_port); + LOGD("clientBdData->user_data.headers[%d].u.wap_8.orig_port = 0x%02x\n", index, clientBdData->user_data.headers[index].u.wap_8.orig_port); +#endif + break; + case RIL_CDMA_SMS_UDH_PORT_16: + clientBdData->user_data.headers[index].u.wap_16.dest_port = (data_buf[0] << 7) | data_buf[1]; // unsigned short + clientBdData->user_data.headers[index].u.wap_16.orig_port = (data_buf[2] << 7) | data_buf[3]; // unsigned short +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.wap_16.dest_port = 0x%04x\n", index, clientBdData->user_data.headers[index].u.wap_16.dest_port); + LOGD("clientBdData->user_data.headers[%d].u.wap_16.orig_port = 0x%04x\n", index, clientBdData->user_data.headers[index].u.wap_16.orig_port); +#endif + break; + case RIL_CDMA_SMS_UDH_CONCAT_16: + clientBdData->user_data.headers[index].u.concat_16.msg_ref = (data_buf[0] << 7) | data_buf[1]; // unsigned short + clientBdData->user_data.headers[index].u.concat_16.total_sm = data_buf[2]; + clientBdData->user_data.headers[index].u.concat_16.seq_num = data_buf[3]; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.concat_16.msg_ref = 0x%04x\n", index, clientBdData->user_data.headers[index].u.concat_16.msg_ref); + LOGD("clientBdData->user_data.headers[%d].u.concat_16.total_sm = 0x%04x\n", index, clientBdData->user_data.headers[index].u.concat_16.total_sm); + LOGD("clientBdData->user_data.headers[%d].u.concat_16.seq_num = 0x%04x\n", index, clientBdData->user_data.headers[index].u.concat_16.seq_num); +#endif + break; + default: + break; + } + + // increment num_of_headers + clientBdData->user_data.num_headers++; + + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jbyteArray JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetUserDataHeader + (JNIEnv * env, jobject obj) +{ + jbyteArray arrData = NULL; + jbyte data_buf[sizeof(clientBdData->user_data.headers)]; + int length = 0; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsGetUserDataHeader()...\n"); +#endif + +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.num_headers = %d, size = %d\n", clientBdData->user_data.num_headers, sizeof(clientBdData->user_data.headers)); +#endif + + for (int index = 0; index < clientBdData->user_data.num_headers; index++) { + // user_data.headers[index].header_id + data_buf[length++] = (jbyte)clientBdData->user_data.headers[index].header_id; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].header_id = %d", index, clientBdData->user_data.headers[index].header_id); +#endif + + // user_data.headers[index].u + // TODO: add support for all udh id's + switch(clientBdData->user_data.headers[index].header_id) + { + case RIL_CDMA_SMS_UDH_CONCAT_8: +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.concat_8.msg_ref = 0x%02x\n", index, clientBdData->user_data.headers[index].u.concat_8.msg_ref); + LOGD("clientBdData->user_data.headers[%d].u.concat_8.total_sm = 0x%02x\n", index, clientBdData->user_data.headers[index].u.concat_8.total_sm); + LOGD("clientBdData->user_data.headers[%d].u.concat_8.seq_num = 0x%02x\n", index, clientBdData->user_data.headers[index].u.concat_8.seq_num); +#endif + data_buf[length++] = 3; + data_buf[length++] = clientBdData->user_data.headers[index].u.concat_8.msg_ref; + data_buf[length++] = clientBdData->user_data.headers[index].u.concat_8.total_sm; + data_buf[length++] = clientBdData->user_data.headers[index].u.concat_8.seq_num; + break; + case RIL_CDMA_SMS_UDH_SPECIAL_SM: +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.special_sm.msg_waiting = 0x%04x\n", index, clientBdData->user_data.headers[index].u.special_sm.msg_waiting); + LOGD("clientBdData->user_data.headers[%d].u.special_sm.msg_waiting_kind = 0x%04x\n", index, clientBdData->user_data.headers[index].u.special_sm.msg_waiting_kind); + LOGD("clientBdData->user_data.headers[%d].u.special_sm.message_count = 0x%02x\n", index, clientBdData->user_data.headers[index].u.special_sm.message_count); +#endif + data_buf[length++] = 9; + data_buf[length++] = (clientBdData->user_data.headers[index].u.special_sm.msg_waiting & 0xFF000000) >> 23; // int + data_buf[length++] = (clientBdData->user_data.headers[index].u.special_sm.msg_waiting & 0x00FF0000) >> 15; + data_buf[length++] = (clientBdData->user_data.headers[index].u.special_sm.msg_waiting & 0x0000FF00) >> 7; + data_buf[length++] = clientBdData->user_data.headers[index].u.special_sm.msg_waiting & 0x000000FF; + data_buf[length++] = (clientBdData->user_data.headers[index].u.special_sm.msg_waiting_kind & 0xFF000000) >> 23; // int + data_buf[length++] = (clientBdData->user_data.headers[index].u.special_sm.msg_waiting_kind & 0x00FF0000) >> 15; + data_buf[length++] = (clientBdData->user_data.headers[index].u.special_sm.msg_waiting_kind & 0x0000FF00) >> 7; + data_buf[length++] = clientBdData->user_data.headers[index].u.special_sm.msg_waiting_kind & 0x000000FF; + data_buf[length++] = clientBdData->user_data.headers[index].u.special_sm.message_count; + break; + case RIL_CDMA_SMS_UDH_PORT_8: +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.wap_8.dest_port = 0x%02x\n", index, clientBdData->user_data.headers[index].u.wap_8.dest_port); + LOGD("clientBdData->user_data.headers[%d].u.wap_8.orig_port = 0x%02x\n", index, clientBdData->user_data.headers[index].u.wap_8.orig_port); +#endif + data_buf[length++] = 2; + data_buf[length++] = clientBdData->user_data.headers[index].u.wap_8.dest_port; + data_buf[length++] = clientBdData->user_data.headers[index].u.wap_8.orig_port; + break; + case RIL_CDMA_SMS_UDH_PORT_16: +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.wap_16.dest_port = 0x%04x\n", index, clientBdData->user_data.headers[index].u.wap_16.dest_port); + LOGD("clientBdData->user_data.headers[%d].u.wap_16.orig_port = 0x%04x\n", index, clientBdData->user_data.headers[index].u.wap_16.orig_port); +#endif + data_buf[length++] = 4; + data_buf[length++] = (clientBdData->user_data.headers[index].u.wap_16.dest_port & 0xFF00) >> 7; // unsigned short + data_buf[length++] = clientBdData->user_data.headers[index].u.wap_16.dest_port & 0x00FF; + data_buf[length++] = (clientBdData->user_data.headers[index].u.wap_16.orig_port & 0xFF00) >> 7; // unsigned short + data_buf[length++] = clientBdData->user_data.headers[index].u.wap_16.orig_port & 0x00FF; + break; + case RIL_CDMA_SMS_UDH_CONCAT_16: +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->user_data.headers[%d].u.concat_16.msg_ref = 0x%04x\n", index, clientBdData->user_data.headers[index].u.concat_16.msg_ref); + LOGD("clientBdData->user_data.headers[%d].u.concat_16.total_sm = 0x%04x\n", index, clientBdData->user_data.headers[index].u.concat_16.total_sm); + LOGD("clientBdData->user_data.headers[%d].u.concat_16.seq_num = 0x%04x\n", index, clientBdData->user_data.headers[index].u.concat_16.seq_num); +#endif + data_buf[length++] = 4; + data_buf[length++] = (clientBdData->user_data.headers[index].u.concat_16.msg_ref & 0xFF00) >> 7; // unsigned short + data_buf[length++] = clientBdData->user_data.headers[index].u.concat_16.msg_ref & 0x00FF; + data_buf[length++] = clientBdData->user_data.headers[index].u.concat_16.total_sm; + data_buf[length++] = clientBdData->user_data.headers[index].u.concat_16.seq_num; + break; + default: + break; + } + } + + if (length != 0) { + arrData = env->NewByteArray((jsize)length); + env->SetByteArrayRegion(arrData, 0, length, data_buf); + } + + return arrData; +} + + +/* native interface */ +JNIEXPORT jint JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetSmsAddress + (JNIEnv * env, jobject obj, jobject smsAddress) +{ + jclass SmsAddressClass; + jfieldID field; + jbyteArray arrData = NULL; + jbyte byte_buf[RIL_CDMA_SMS_ADDRESS_MAX]; + int length; + jint intData; + jbyte byteData; + jboolean booleanData; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsSetSmsAddress()...\n"); +#endif + + // callback.digit_mode + if (getObjectByteField(env, smsAddress, "digitMode", &byteData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->callback.digit_mode = (RIL_CDMA_SMS_DigitMode)(byteData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.digit_mode = 0x%02x\n", clientBdData->callback.digit_mode); +#endif + + // callback.number_mode + if (getObjectByteField(env, smsAddress, "numberMode", &byteData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->callback.number_mode = (RIL_CDMA_SMS_NumberMode)(byteData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.number_mode = 0x%02x\n", clientBdData->callback.number_mode); +#endif + + // callback.number_type + if (getObjectIntField(env, smsAddress, "ton", &intData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->callback.number_type = (RIL_CDMA_SMS_NumberType)(intData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.number_type = %d\n", clientBdData->callback.number_type); +#endif + + // callback.number_plan + if (getObjectByteField(env, smsAddress, "numberPlan", &byteData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->callback.number_plan = (RIL_CDMA_SMS_NumberPlan)(byteData); +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.number_plan = 0x%02x\n", clientBdData->callback.number_plan); +#endif + + // callback.number_of_digits + if (getObjectByteField(env, smsAddress, "numberOfDigits", &byteData) != JNI_SUCCESS) + return JNI_FAILURE; + clientBdData->callback.number_of_digits = byteData; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.number_of_digits = %d\n",clientBdData->callback.number_of_digits); +#endif + + // callback.digits + if (getObjectByteArrayField(env, smsAddress, "origBytes", byte_buf, &length) != JNI_SUCCESS) + return JNI_FAILURE; + for (int i = 0; i < clientBdData->callback.number_of_digits; i++) { + clientBdData->callback.digits[i] = byte_buf[i]; +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.digits[%d] = 0x%02x\n", i, clientBdData->callback.digits[i]); +#endif + } + + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jint JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetSmsAddress + (JNIEnv * env, jobject obj, jobject smsAddress) +{ + jclass SmsAddressClass; + jfieldID field; + jbyteArray arrData = NULL; + jbyte *byte_buf; + int length; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsGetSmsAddress()...\n"); +#endif + + // callback.digit_mode +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.digit_mode = 0x%02x\n", clientBdData->callback.digit_mode); +#endif + if (setObjectByteField(env, smsAddress, "digitMode", (jbyte)clientBdData->callback.digit_mode) != JNI_SUCCESS) + return JNI_FAILURE; + + // callback.number_mode +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.number_mode = 0x%02x\n", clientBdData->callback.number_mode); +#endif + if (setObjectByteField(env, smsAddress, "numberMode", (jbyte)clientBdData->callback.number_mode) != JNI_SUCCESS) + return JNI_FAILURE; + + // callback.number_type +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.number_type = %d\n", clientBdData->callback.number_type); +#endif + if (setObjectIntField(env, smsAddress, "ton", (jint)clientBdData->callback.number_type) != JNI_SUCCESS) + return JNI_FAILURE; + + // callback.number_plan +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.number_plan = 0x%02x\n", clientBdData->callback.number_plan); +#endif + if (setObjectByteField(env, smsAddress, "numberPlan", (jbyte)clientBdData->callback.number_plan) != JNI_SUCCESS) + return JNI_FAILURE; + + // callback.number_of_digits +#ifdef DBG_LOG_LEVEL_A + LOGD("clientBdData->callback.number_of_digits = %d\n", clientBdData->callback.number_of_digits); +#endif + if (setObjectByteField(env, smsAddress, "numberOfDigits", (jbyte)clientBdData->callback.number_of_digits) != JNI_SUCCESS) + return JNI_FAILURE; + + // callback.digits + byte_buf = (jbyte*)clientBdData->callback.digits; + length = clientBdData->callback.number_of_digits; +#ifdef DBG_LOG_LEVEL_A + for (int i = 0; i < length; i++) { + LOGD("clientBdData->callback.digits[%d] = 0x%02x\n", i, clientBdData->callback.digits[i]); + } +#endif + + if (setObjectByteArrayField(env, smsAddress, "origBytes", byte_buf, length) != JNI_SUCCESS) + return JNI_FAILURE; + + return JNI_SUCCESS; +} + + +/* native interface */ +JNIEXPORT jbyteArray JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsEncodeSms + (JNIEnv * env, jobject obj) +{ + RIL_CDMA_Encoded_SMS *encoded_sms = (RIL_CDMA_Encoded_SMS *)malloc(sizeof(RIL_CDMA_Encoded_SMS)); + jbyte* data_buf; + jint result = JNI_SUCCESS; + jbyteArray encodedSMS; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsEncodeSms(): entry\n"); +#endif + + if (NULL == encoded_sms) { + jniThrowException(env, "java/lang/NullPointerException", "encoded_sms is null"); + return NULL; + } + memset(encoded_sms, 0, sizeof(RIL_CDMA_Encoded_SMS)); + + // call CDMA SMS encode function + if(wmsts_ril_cdma_encode_sms(clientBdData, encoded_sms) != RIL_E_SUCCESS) { + jniThrowException(env, "java/lang/Exception", "CDMA SMS Encoding failed"); + return NULL; + } + +#ifdef DBG_LOG_LEVEL_A + LOGD(" EncodeSMS: length = %i\n", encoded_sms->length); +#endif + encodedSMS = env->NewByteArray((jsize)encoded_sms->length); + env->SetByteArrayRegion(encodedSMS, 0, encoded_sms->length, (jbyte*)encoded_sms->data); + free(encoded_sms); + + return encodedSMS; +} + + +/* native interface */ +JNIEXPORT jint JNICALL +Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsDecodeSms + (JNIEnv * env, jobject obj, jbyteArray encodedSMS) +{ + RIL_CDMA_Encoded_SMS *encoded_sms = (RIL_CDMA_Encoded_SMS *)malloc(sizeof(RIL_CDMA_Encoded_SMS)); + jbyte* data_buf; + jint result = JNI_SUCCESS; + jsize length; + +#ifdef DBG_LOG_LEVEL_B + LOGD("nativeCdmaSmsDecodeSms(): entry\n"); +#endif + + if (NULL == encoded_sms) { + jniThrowException(env, "java/lang/NullPointerException", "encoded_sms is null"); + return JNI_FAILURE; + } + memset(encoded_sms, 0, sizeof(RIL_CDMA_Encoded_SMS)); + + length = env->GetArrayLength(encodedSMS); + if (length < 0 || length > 255) { + jniThrowException(env, "java/lang/ArrayIndexOutOfBounds", "wrong encoded SMS data length"); + return JNI_FAILURE; + } + encoded_sms->length = length; +#ifdef DBG_LOG_LEVEL_A + LOGD(" DecodeSMS: arrayLength = %d\n", encoded_sms->length); +#endif + data_buf = env->GetByteArrayElements(encodedSMS, NULL); + encoded_sms->data = (unsigned char*)data_buf; + env->ReleaseByteArrayElements(encodedSMS, data_buf, 0); + + // call CDMA SMS decode function + if(wmsts_ril_cdma_decode_sms(encoded_sms, clientBdData) != RIL_E_SUCCESS) { + jniThrowException(env, "java/lang/Exception", "CDMA SMS Decoding failed"); + result = JNI_FAILURE; + } + + free(encoded_sms); + + return result; +} + + +// --------------------------------------------------------------------------- + +static const char *classPathName = "com/android/internal/telephony/cdma/sms/SmsDataCoding"; + +static JNINativeMethod methods[] = { + /* name, signature, funcPtr */ + {"nativeCdmaSmsConstructClientBD", "()I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsConstructClientBD }, + {"nativeCdmaSmsDestructClientBD", "()I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsDestructClientBD }, + {"nativeCdmaSmsSetBearerDataPrimitives", "(Lcom/android/internal/telephony/cdma/sms/BearerData;)I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetBearerDataPrimitives }, + {"nativeCdmaSmsGetBearerDataPrimitives", "(Lcom/android/internal/telephony/cdma/sms/BearerData;)I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetBearerDataPrimitives }, + {"nativeCdmaSmsSetUserData", "(Lcom/android/internal/telephony/cdma/sms/UserData;)I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetUserData }, + {"nativeCdmaSmsGetUserData", "(Lcom/android/internal/telephony/cdma/sms/UserData;)I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetUserData }, + {"nativeCdmaSmsSetUserDataHeader", "(I[BII)I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetUserDataHeader }, + {"nativeCdmaSmsGetUserDataHeader", "()[B", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetUserDataHeader }, + {"nativeCdmaSmsSetSmsAddress", "(Lcom/android/internal/telephony/cdma/sms/CdmaSmsAddress;)I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetSmsAddress }, + {"nativeCdmaSmsGetSmsAddress", "(Lcom/android/internal/telephony/cdma/sms/CdmaSmsAddress;)I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetSmsAddress }, + {"nativeCdmaSmsEncodeSms", "()[B", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsEncodeSms }, + {"nativeCdmaSmsDecodeSms", "([B)I", + (void*)Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsDecodeSms }, +}; + +int register_android_cdma_sms_methods(JNIEnv *_env) +{ + return android::AndroidRuntime::registerNativeMethods( + _env, classPathName, methods, NELEM(methods)); +} + +// --------------------------------------------------------------------------- + +jint JNI_OnLoad(JavaVM* vm, void* reserved) +{ + JNIEnv* env = NULL; + jint result = -1; + + if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) { + LOGE("ERROR: GetEnv failed\n"); + goto bail; + } + assert(env != NULL); + + if (register_android_cdma_sms_methods(env) < 0) { + LOGE("ERROR: CDMA SMS native registration failed\n"); + goto bail; + } + + /* success -- return valid version number */ + result = JNI_VERSION_1_4; + +bail: + return result; +} diff --git a/telephony/jni/cdmasms/cdma_sms_jni.h b/telephony/jni/cdmasms/cdma_sms_jni.h new file mode 100644 index 0000000..253c006 --- /dev/null +++ b/telephony/jni/cdmasms/cdma_sms_jni.h @@ -0,0 +1,159 @@ +/* + * Copyright (C) 2008 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include <jni.h> +/* Header for class com_android_internal_telephony_cdma_sms_SmsDataCoding */ + +#ifndef _Included_com_android_internal_telephony_cdma_sms_SmsDataCoding +#define _Included_com_android_internal_telephony_cdma_sms_SmsDataCoding +#ifdef __cplusplus +extern "C" { +#endif +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_NULL +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_NULL 0L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_MSG_ID +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_MSG_ID 1L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_USER_DATA +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_USER_DATA 2L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_MC_TIME +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_MC_TIME 8L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_NUM_OF_MSGS +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_NUM_OF_MSGS 2048L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_CALLBACK +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_CALLBACK 16384L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_DISPLAY_MODE +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_CDMA_SMS_WMS_MASK_BD_DISPLAY_MODE 32768L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_SUCCESS +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_SUCCESS 0L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_FAILURE +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_FAILURE 1L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_DATA_LEN_OUT_OF_RANGE +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_DATA_LEN_OUT_OF_RANGE 2L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_CLASS_UNKNOWN +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_CLASS_UNKNOWN 3L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_FIELD_ID_UNKNOWN +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_FIELD_ID_UNKNOWN 4L +#undef com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_OUT_OF_MEMORY +#define com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_OUT_OF_MEMORY 5L +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsConstructClientBD + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsConstructClientBD + (JNIEnv *, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsDestructClientBD + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsDestructClientBD + (JNIEnv *, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsSetBearerDataPrimitives + * Signature: (Lcom/android/internal/telephony/cdma/sms/BearerData;)I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetBearerDataPrimitives + (JNIEnv *, jobject, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsGetBearerDataPrimitives + * Signature: (Lcom/android/internal/telephony/cdma/sms/BearerData;)I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetBearerDataPrimitives + (JNIEnv *, jobject, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsSetUserData + * Signature: (Lcom/android/internal/telephony/cdma/sms/UserData;)I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetUserData + (JNIEnv *, jobject, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsGetUserData + * Signature: (Lcom/android/internal/telephony/cdma/sms/UserData;)I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetUserData + (JNIEnv *, jobject, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsSetUserDataHeader + * Signature: (I[BII)I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetUserDataHeader + (JNIEnv *, jobject, jint, jbyteArray, jint, jint); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsGetUserDataHeader + * Signature: ()[B + */ +JNIEXPORT jbyteArray JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetUserDataHeader + (JNIEnv *, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsSetSmsAddress + * Signature: (Lcom/android/internal/telephony/cdma/sms/CdmaSmsAddress;)I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsSetSmsAddress + (JNIEnv *, jobject, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsGetSmsAddress + * Signature: (Lcom/android/internal/telephony/cdma/sms/CdmaSmsAddress;)I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsGetSmsAddress + (JNIEnv *, jobject, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsEncodeSms + * Signature: ()[B + */ +JNIEXPORT jbyteArray JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsEncodeSms + (JNIEnv *, jobject); + +/* + * Class: com_android_internal_telephony_cdma_sms_SmsDataCoding + * Method: nativeCdmaSmsDecodeSms + * Signature: ([B)I + */ +JNIEXPORT jint JNICALL Java_com_android_internal_telephony_cdma_sms_SmsDataCoding_nativeCdmaSmsDecodeSms + (JNIEnv *, jobject, jbyteArray); + +/** + * CDMA SMS return value defines + */ +#define JNI_SUCCESS \ +com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_SUCCESS /**< Successful operation */ +#define JNI_FAILURE \ +com_android_internal_telephony_cdma_sms_SmsDataCoding_JNI_CDMA_SMS_FAILURE /**< General failure */ + +#ifdef __cplusplus +} +#endif +#endif |