diff options
26 files changed, 755 insertions, 135 deletions
diff --git a/config/hiddenapi-greylist.txt b/config/hiddenapi-greylist.txt index caac8ae5492d..0c561e683307 100644 --- a/config/hiddenapi-greylist.txt +++ b/config/hiddenapi-greylist.txt @@ -2878,7 +2878,6 @@ Lcom/android/internal/telephony/dataconnection/DataConnection;->mNetworkInfo:Lan Lcom/android/internal/telephony/dataconnection/DataConnection;->mPhone:Lcom/android/internal/telephony/Phone; Lcom/android/internal/telephony/dataconnection/DataConnection;->mRilRat:I Lcom/android/internal/telephony/dataconnection/DataConnection;->notifyAllOfConnected(Ljava/lang/String;)V -Lcom/android/internal/telephony/dataconnection/DataConnection;->notifyAllOfDisconnectDcRetrying(Ljava/lang/String;)V Lcom/android/internal/telephony/dataconnection/DataConnection;->notifyDisconnectCompleted(Lcom/android/internal/telephony/dataconnection/DataConnection$DisconnectParams;Z)V Lcom/android/internal/telephony/dataconnection/DataConnection;->onConnect(Lcom/android/internal/telephony/dataconnection/DataConnection$ConnectionParams;)V Lcom/android/internal/telephony/dataconnection/DataConnection;->tearDownData(Ljava/lang/Object;)V @@ -2916,8 +2915,6 @@ Lcom/android/internal/telephony/dataconnection/DcTracker;->mProvisioningSpinner: Lcom/android/internal/telephony/dataconnection/DcTracker;->mResolver:Landroid/content/ContentResolver; Lcom/android/internal/telephony/dataconnection/DcTracker;->mState:Lcom/android/internal/telephony/DctConstants$State; Lcom/android/internal/telephony/dataconnection/DcTracker;->mSubscriptionManager:Landroid/telephony/SubscriptionManager; -Lcom/android/internal/telephony/dataconnection/DcTracker;->notifyDataConnection(Ljava/lang/String;)V -Lcom/android/internal/telephony/dataconnection/DcTracker;->notifyOffApnsOfAvailability(Ljava/lang/String;)V Lcom/android/internal/telephony/dataconnection/DcTracker;->onActionIntentDataStallAlarm(Landroid/content/Intent;)V Lcom/android/internal/telephony/dataconnection/DcTracker;->onActionIntentProvisioningApnAlarm(Landroid/content/Intent;)V Lcom/android/internal/telephony/dataconnection/DcTracker;->onRecordsLoadedOrSubIdChanged()V @@ -2946,7 +2943,6 @@ Lcom/android/internal/telephony/DctConstants$State;->DISCONNECTING:Lcom/android/ Lcom/android/internal/telephony/DctConstants$State;->FAILED:Lcom/android/internal/telephony/DctConstants$State; Lcom/android/internal/telephony/DctConstants$State;->IDLE:Lcom/android/internal/telephony/DctConstants$State; Lcom/android/internal/telephony/DctConstants$State;->RETRYING:Lcom/android/internal/telephony/DctConstants$State; -Lcom/android/internal/telephony/DctConstants$State;->SCANNING:Lcom/android/internal/telephony/DctConstants$State; Lcom/android/internal/telephony/DctConstants$State;->values()[Lcom/android/internal/telephony/DctConstants$State; Lcom/android/internal/telephony/DefaultPhoneNotifier;->mRegistry:Lcom/android/internal/telephony/ITelephonyRegistry; Lcom/android/internal/telephony/DriverCall$State;->ACTIVE:Lcom/android/internal/telephony/DriverCall$State; @@ -3370,7 +3366,7 @@ Lcom/android/internal/telephony/ITelephonyRegistry$Stub;->asInterface(Landroid/o Lcom/android/internal/telephony/ITelephonyRegistry;->listen(Ljava/lang/String;Lcom/android/internal/telephony/IPhoneStateListener;IZ)V Lcom/android/internal/telephony/ITelephonyRegistry;->notifyCallState(ILjava/lang/String;)V Lcom/android/internal/telephony/ITelephonyRegistry;->notifyCellInfo(Ljava/util/List;)V -Lcom/android/internal/telephony/ITelephonyRegistry;->notifyDataConnectionFailed(Ljava/lang/String;Ljava/lang/String;)V +Lcom/android/internal/telephony/ITelephonyRegistry;->notifyDataConnectionFailed(Ljava/lang/String;)V Lcom/android/internal/telephony/IWapPushManager$Stub;->asInterface(Landroid/os/IBinder;)Lcom/android/internal/telephony/IWapPushManager; Lcom/android/internal/telephony/IWapPushManager;->addPackage(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IZZ)Z Lcom/android/internal/telephony/IWapPushManager;->deletePackage(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z diff --git a/core/java/android/view/AccessibilityIterators.java b/core/java/android/view/AccessibilityIterators.java index 9f7560c79166..54cfc00cb5b3 100644 --- a/core/java/android/view/AccessibilityIterators.java +++ b/core/java/android/view/AccessibilityIterators.java @@ -147,6 +147,9 @@ public final class AccessibilityIterators { @Override public void onConfigurationChanged(Configuration globalConfig) { final Locale locale = globalConfig.getLocales().get(0); + if (locale == null) { + return; + } if (!mLocale.equals(locale)) { mLocale = locale; onLocaleChanged(locale); diff --git a/services/core/java/com/android/server/TelephonyRegistry.java b/services/core/java/com/android/server/TelephonyRegistry.java index 190e99f7b221..6d10632a08cd 100644 --- a/services/core/java/com/android/server/TelephonyRegistry.java +++ b/services/core/java/com/android/server/TelephonyRegistry.java @@ -1313,16 +1313,17 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { } } - public void notifyDataConnection(int state, boolean isDataAllowed, - String reason, String apn, String apnType, LinkProperties linkProperties, - NetworkCapabilities networkCapabilities, int networkType, boolean roaming) { + public void notifyDataConnection(int state, boolean isDataAllowed, String apn, String apnType, + LinkProperties linkProperties, + NetworkCapabilities networkCapabilities, int networkType, + boolean roaming) { notifyDataConnectionForSubscriber(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, state, - isDataAllowed,reason, apn, apnType, linkProperties, - networkCapabilities, networkType, roaming); + isDataAllowed, apn, apnType, linkProperties, + networkCapabilities, networkType, roaming); } - public void notifyDataConnectionForSubscriber(int subId, int state, - boolean isDataAllowed, String reason, String apn, String apnType, + public void notifyDataConnectionForSubscriber(int subId, int state, boolean isDataAllowed, + String apn, String apnType, LinkProperties linkProperties, NetworkCapabilities networkCapabilities, int networkType, boolean roaming) { if (!checkNotifyPermission("notifyDataConnection()" )) { @@ -1331,7 +1332,6 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { if (VDBG) { log("notifyDataConnectionForSubscriber: subId=" + subId + " state=" + state + " isDataAllowed=" + isDataAllowed - + " reason='" + reason + "' apn='" + apn + "' apnType=" + apnType + " networkType=" + networkType + " mRecords.size()=" + mRecords.size()); } @@ -1366,7 +1366,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { mDataConnectionNetworkType[phoneId] = networkType; } mPreciseDataConnectionState = new PreciseDataConnectionState(state, networkType, - apnType, apn, reason, linkProperties, ""); + apnType, apn, linkProperties, ""); for (Record r : mRecords) { if (r.matchPhoneStateListenerEvent( PhoneStateListener.LISTEN_PRECISE_DATA_CONNECTION_STATE)) { @@ -1381,30 +1381,29 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { } handleRemoveListLocked(); } - broadcastDataConnectionStateChanged(state, isDataAllowed, reason, apn, - apnType, linkProperties, networkCapabilities, roaming, subId); - broadcastPreciseDataConnectionStateChanged(state, networkType, apnType, apn, reason, + broadcastDataConnectionStateChanged(state, isDataAllowed, apn, apnType, linkProperties, + networkCapabilities, roaming, subId); + broadcastPreciseDataConnectionStateChanged(state, networkType, apnType, apn, linkProperties, ""); } - public void notifyDataConnectionFailed(String reason, String apnType) { + public void notifyDataConnectionFailed(String apnType) { notifyDataConnectionFailedForSubscriber(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID, - reason, apnType); + apnType); } - public void notifyDataConnectionFailedForSubscriber(int subId, - String reason, String apnType) { + public void notifyDataConnectionFailedForSubscriber(int subId, String apnType) { if (!checkNotifyPermission("notifyDataConnectionFailed()")) { return; } if (VDBG) { log("notifyDataConnectionFailedForSubscriber: subId=" + subId - + " reason=" + reason + " apnType=" + apnType); + + " apnType=" + apnType); } synchronized (mRecords) { mPreciseDataConnectionState = new PreciseDataConnectionState( TelephonyManager.DATA_UNKNOWN,TelephonyManager.NETWORK_TYPE_UNKNOWN, - apnType, "", reason, null, ""); + apnType, "", null, ""); for (Record r : mRecords) { if (r.matchPhoneStateListenerEvent( PhoneStateListener.LISTEN_PRECISE_DATA_CONNECTION_STATE)) { @@ -1417,9 +1416,9 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { } handleRemoveListLocked(); } - broadcastDataConnectionFailed(reason, apnType, subId); + broadcastDataConnectionFailed(apnType, subId); broadcastPreciseDataConnectionStateChanged(TelephonyManager.DATA_UNKNOWN, - TelephonyManager.NETWORK_TYPE_UNKNOWN, apnType, "", reason, null, ""); + TelephonyManager.NETWORK_TYPE_UNKNOWN, apnType, "", null, ""); } public void notifyCellLocation(Bundle cellLocation) { @@ -1529,15 +1528,14 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { } } - public void notifyPreciseDataConnectionFailed(String reason, String apnType, - String apn, String failCause) { + public void notifyPreciseDataConnectionFailed(String apnType, String apn, String failCause) { if (!checkNotifyPermission("notifyPreciseDataConnectionFailed()")) { return; } synchronized (mRecords) { mPreciseDataConnectionState = new PreciseDataConnectionState( TelephonyManager.DATA_UNKNOWN, TelephonyManager.NETWORK_TYPE_UNKNOWN, - apnType, apn, reason, null, failCause); + apnType, apn, null, failCause); for (Record r : mRecords) { if (r.matchPhoneStateListenerEvent( PhoneStateListener.LISTEN_PRECISE_DATA_CONNECTION_STATE)) { @@ -1551,7 +1549,7 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { handleRemoveListLocked(); } broadcastPreciseDataConnectionStateChanged(TelephonyManager.DATA_UNKNOWN, - TelephonyManager.NETWORK_TYPE_UNKNOWN, apnType, apn, reason, null, failCause); + TelephonyManager.NETWORK_TYPE_UNKNOWN, apnType, apn, null, failCause); } @Override @@ -1882,10 +1880,10 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { android.Manifest.permission.READ_CALL_LOG}); } - private void broadcastDataConnectionStateChanged(int state, - boolean isDataAllowed, - String reason, String apn, String apnType, LinkProperties linkProperties, - NetworkCapabilities networkCapabilities, boolean roaming, int subId) { + private void broadcastDataConnectionStateChanged(int state, boolean isDataAllowed, String apn, + String apnType, LinkProperties linkProperties, + NetworkCapabilities networkCapabilities, + boolean roaming, int subId) { // Note: not reporting to the battery stats service here, because the // status bar takes care of that after taking into account all of the // required info. @@ -1895,9 +1893,6 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { if (!isDataAllowed) { intent.putExtra(PhoneConstants.NETWORK_UNAVAILABLE_KEY, true); } - if (reason != null) { - intent.putExtra(PhoneConstants.STATE_CHANGE_REASON_KEY, reason); - } if (linkProperties != null) { intent.putExtra(PhoneConstants.DATA_LINK_PROPERTIES_KEY, linkProperties); String iface = linkProperties.getInterfaceName(); @@ -1916,17 +1911,15 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { mContext.sendStickyBroadcastAsUser(intent, UserHandle.ALL); } - private void broadcastDataConnectionFailed(String reason, String apnType, - int subId) { + private void broadcastDataConnectionFailed(String apnType, int subId) { Intent intent = new Intent(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED); - intent.putExtra(PhoneConstants.FAILURE_REASON_KEY, reason); intent.putExtra(PhoneConstants.DATA_APN_TYPE_KEY, apnType); intent.putExtra(PhoneConstants.SUBSCRIPTION_KEY, subId); mContext.sendStickyBroadcastAsUser(intent, UserHandle.ALL); } private void broadcastPreciseCallStateChanged(int ringingCallState, int foregroundCallState, - int backgroundCallState) { + int backgroundCallState) { Intent intent = new Intent(TelephonyManager.ACTION_PRECISE_CALL_STATE_CHANGED); intent.putExtra(TelephonyManager.EXTRA_RINGING_CALL_STATE, ringingCallState); intent.putExtra(TelephonyManager.EXTRA_FOREGROUND_CALL_STATE, foregroundCallState); @@ -1936,16 +1929,16 @@ public class TelephonyRegistry extends ITelephonyRegistry.Stub { } private void broadcastPreciseDataConnectionStateChanged(int state, int networkType, - String apnType, String apn, String reason, LinkProperties linkProperties, - String failCause) { + String apnType, String apn, + LinkProperties linkProperties, + String failCause) { Intent intent = new Intent(TelephonyManager.ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED); intent.putExtra(PhoneConstants.STATE_KEY, state); intent.putExtra(PhoneConstants.DATA_NETWORK_TYPE_KEY, networkType); - if (reason != null) intent.putExtra(PhoneConstants.STATE_CHANGE_REASON_KEY, reason); if (apnType != null) intent.putExtra(PhoneConstants.DATA_APN_TYPE_KEY, apnType); if (apn != null) intent.putExtra(PhoneConstants.DATA_APN_KEY, apn); if (linkProperties != null) { - intent.putExtra(PhoneConstants.DATA_LINK_PROPERTIES_KEY,linkProperties); + intent.putExtra(PhoneConstants.DATA_LINK_PROPERTIES_KEY, linkProperties); } if (failCause != null) intent.putExtra(PhoneConstants.DATA_FAILURE_CAUSE_KEY, failCause); diff --git a/telephony/java/android/telephony/CarrierConfigManager.java b/telephony/java/android/telephony/CarrierConfigManager.java index 4561ea33bb95..89b646fa0728 100644 --- a/telephony/java/android/telephony/CarrierConfigManager.java +++ b/telephony/java/android/telephony/CarrierConfigManager.java @@ -2242,7 +2242,7 @@ public class CarrierConfigManager { * e.g.) To use RSCP by default, set the value to "rscp". The signal strength level will * then be determined by #KEY_WCDMA_RSCP_THRESHOLDS_INT_ARRAY * <p> - * Currently this only supports the value "rscp" + * Currently this supports the value "rscp" and "rssi". * @hide */ // FIXME: this key and related keys must not be exposed without a consistent philosophy for @@ -2690,7 +2690,7 @@ public class CarrierConfigManager { -95, /* SIGNAL_STRENGTH_GOOD */ -85 /* SIGNAL_STRENGTH_GREAT */ }); - sDefaults.putString(KEY_WCDMA_DEFAULT_SIGNAL_STRENGTH_MEASUREMENT_STRING, ""); + sDefaults.putString(KEY_WCDMA_DEFAULT_SIGNAL_STRENGTH_MEASUREMENT_STRING, "rssi"); sDefaults.putBoolean(KEY_CONFIG_SHOW_ORIG_DIAL_STRING_FOR_CDMA_BOOL, false); sDefaults.putBoolean(KEY_SHOW_CALL_BLOCKING_DISABLED_NOTIFICATION_ALWAYS_BOOL, false); sDefaults.putBoolean(KEY_CALL_FORWARDING_OVER_UT_WARNING_BOOL, false); diff --git a/telephony/java/android/telephony/CellSignalStrength.java b/telephony/java/android/telephony/CellSignalStrength.java index a18275f95f9d..7d07a730f78b 100644 --- a/telephony/java/android/telephony/CellSignalStrength.java +++ b/telephony/java/android/telephony/CellSignalStrength.java @@ -42,6 +42,9 @@ public abstract class CellSignalStrength { public static final int NUM_SIGNAL_STRENGTH_BINS = 5; /** @hide */ + protected static final int NUM_SIGNAL_STRENGTH_THRESHOLDS = NUM_SIGNAL_STRENGTH_BINS - 1; + + /** @hide */ public static final String[] SIGNAL_STRENGTH_NAMES = { "none", "poor", "moderate", "good", "great" }; diff --git a/telephony/java/android/telephony/CellSignalStrengthWcdma.java b/telephony/java/android/telephony/CellSignalStrengthWcdma.java index 88f6fbc4464d..0760407171ae 100644 --- a/telephony/java/android/telephony/CellSignalStrengthWcdma.java +++ b/telephony/java/android/telephony/CellSignalStrengthWcdma.java @@ -21,6 +21,7 @@ import android.os.Parcel; import android.os.Parcelable; import android.os.PersistableBundle; import android.telephony.Rlog; +import android.text.TextUtils; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; @@ -41,8 +42,18 @@ public final class CellSignalStrengthWcdma extends CellSignalStrength implements private static final int WCDMA_RSSI_POOR = -107; private static final int WCDMA_RSSI_MIN = -113; - private static final int WCDMA_RSCP_MIN = -120; + private static final int[] sRssiThresholds = new int[]{ + WCDMA_RSSI_POOR, WCDMA_RSSI_MODERATE, WCDMA_RSSI_GOOD, WCDMA_RSSI_GREAT}; + private static final int WCDMA_RSCP_MAX = -24; + private static final int WCDMA_RSCP_GREAT = -85; + private static final int WCDMA_RSCP_GOOD = -95; + private static final int WCDMA_RSCP_MODERATE = -105; + private static final int WCDMA_RSCP_POOR = -115; + private static final int WCDMA_RSCP_MIN = -120; + + private static final int[] sRscpThresholds = new int[] { + WCDMA_RSCP_POOR, WCDMA_RSCP_MODERATE, WCDMA_RSCP_GOOD, WCDMA_RSCP_GREAT}; // TODO: Because these are used as values in CarrierConfig, they should be exposed somehow. /** @hide */ @@ -54,6 +65,9 @@ public final class CellSignalStrengthWcdma extends CellSignalStrength implements /** @hide */ public static final String LEVEL_CALCULATION_METHOD_RSCP = "rscp"; + // Default to RSSI for backwards compatibility with older devices + private static final String sLevelCalculationMethod = LEVEL_CALCULATION_METHOD_RSSI; + private int mRssi; // in dBm [-113, 51] or CellInfo.UNAVAILABLE if unknown private int mBitErrorRate; // bit error rate (0-7, 99) as defined in TS 27.007 8.5 or // CellInfo.UNAVAILABLE if unknown @@ -121,10 +135,6 @@ public final class CellSignalStrengthWcdma extends CellSignalStrength implements mLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; } - private static final String sLevelCalculationMethod = LEVEL_CALCULATION_METHOD_RSSI; - private static final int[] sThresholds = new int[]{ - WCDMA_RSSI_POOR, WCDMA_RSSI_GOOD, WCDMA_RSSI_GOOD, WCDMA_RSSI_GREAT}; - /** * Retrieve an abstract level value for the overall signal strength. * @@ -140,41 +150,46 @@ public final class CellSignalStrengthWcdma extends CellSignalStrength implements @Override public void updateLevel(PersistableBundle cc, ServiceState ss) { String calcMethod; - int[] thresholds; + int[] rscpThresholds; if (cc == null) { calcMethod = sLevelCalculationMethod; - thresholds = sThresholds; + rscpThresholds = sRscpThresholds; } else { // TODO: abstract this entire thing into a series of functions calcMethod = cc.getString( CarrierConfigManager.KEY_WCDMA_DEFAULT_SIGNAL_STRENGTH_MEASUREMENT_STRING, sLevelCalculationMethod); - thresholds = cc.getIntArray( + if (TextUtils.isEmpty(calcMethod)) calcMethod = sLevelCalculationMethod; + rscpThresholds = cc.getIntArray( CarrierConfigManager.KEY_WCDMA_RSCP_THRESHOLDS_INT_ARRAY); - if (thresholds == null) thresholds = sThresholds; + if (rscpThresholds == null || rscpThresholds.length != NUM_SIGNAL_STRENGTH_THRESHOLDS) { + rscpThresholds = sRscpThresholds; + } } - int level = thresholds.length; + int level = NUM_SIGNAL_STRENGTH_THRESHOLDS; switch (calcMethod) { case LEVEL_CALCULATION_METHOD_RSCP: if (mRscp < WCDMA_RSCP_MIN || mRscp > WCDMA_RSCP_MAX) { mLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; return; } - while (level > 0 && mRscp < thresholds[level - 1]) level--; + while (level > 0 && mRscp < rscpThresholds[level - 1]) level--; mLevel = level; return; + default: + loge("Invalid Level Calculation Method for CellSignalStrengthWcdma = " + + calcMethod); + /** fall through */ case LEVEL_CALCULATION_METHOD_RSSI: if (mRssi < WCDMA_RSSI_MIN || mRssi > WCDMA_RSSI_MAX) { mLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; return; } - while (level > 0 && mRssi < thresholds[level - 1]) level--; + while (level > 0 && mRssi < sRssiThresholds[level - 1]) level--; mLevel = level; return; - default: - mLevel = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; } } @@ -204,7 +219,7 @@ public final class CellSignalStrengthWcdma extends CellSignalStrength implements } /** - * Get the signal strength as dBm + * Get the RSSI as dBm * * @hide */ @@ -214,12 +229,32 @@ public final class CellSignalStrengthWcdma extends CellSignalStrength implements /** * Get the RSCP as dBm + * * @hide */ public int getRscp() { return mRscp; } + /** + * Get the Ec/No as dB + * + * @hide + */ + public int getEcNo() { + return mEcNo; + } + + /** + * Return the Bit Error Rate + * + * @returns the bit error rate (0-7, 99) as defined in TS 27.007 8.5 or UNAVAILABLE. + * @hide + */ + public int getBitErrorRate() { + return mBitErrorRate; + } + @Override public int hashCode() { return Objects.hash(mRssi, mBitErrorRate, mRscp, mEcNo, mLevel); @@ -304,9 +339,16 @@ public final class CellSignalStrengthWcdma extends CellSignalStrength implements }; /** - * log + * log warning */ private static void log(String s) { Rlog.w(LOG_TAG, s); } + + /** + * log error + */ + private static void loge(String s) { + Rlog.e(LOG_TAG, s); + } } diff --git a/telephony/java/android/telephony/PreciseDataConnectionState.java b/telephony/java/android/telephony/PreciseDataConnectionState.java index b258f52d58ec..83738997a067 100644 --- a/telephony/java/android/telephony/PreciseDataConnectionState.java +++ b/telephony/java/android/telephony/PreciseDataConnectionState.java @@ -17,10 +17,11 @@ package android.telephony; import android.annotation.UnsupportedAppUsage; +import android.net.LinkProperties; import android.os.Parcel; import android.os.Parcelable; -import android.telephony.TelephonyManager; -import android.net.LinkProperties; + +import java.util.Objects; /** * Contains precise data connection state. @@ -32,7 +33,6 @@ import android.net.LinkProperties; * <li>Network type of the connection. * <li>APN type. * <li>APN. - * <li>Data connection change reason. * <li>The properties of the network link. * <li>Data connection fail cause. * </ul> @@ -45,7 +45,6 @@ public class PreciseDataConnectionState implements Parcelable { private int mNetworkType = TelephonyManager.NETWORK_TYPE_UNKNOWN; private String mAPNType = ""; private String mAPN = ""; - private String mReason = ""; private LinkProperties mLinkProperties = null; private String mFailCause = ""; @@ -55,14 +54,12 @@ public class PreciseDataConnectionState implements Parcelable { * @hide */ @UnsupportedAppUsage - public PreciseDataConnectionState(int state, int networkType, - String apnType, String apn, String reason, - LinkProperties linkProperties, String failCause) { + public PreciseDataConnectionState(int state, int networkType, String apnType, String apn, + LinkProperties linkProperties, String failCause) { mState = state; mNetworkType = networkType; mAPNType = apnType; mAPN = apn; - mReason = reason; mLinkProperties = linkProperties; mFailCause = failCause; } @@ -83,7 +80,6 @@ public class PreciseDataConnectionState implements Parcelable { mNetworkType = in.readInt(); mAPNType = in.readString(); mAPN = in.readString(); - mReason = in.readString(); mLinkProperties = (LinkProperties)in.readParcelable(null); mFailCause = in.readString(); } @@ -144,14 +140,6 @@ public class PreciseDataConnectionState implements Parcelable { } /** - * Get data connection change reason. - */ - @UnsupportedAppUsage - public String getDataConnectionChangeReason() { - return mReason; - } - - /** * Get the properties of the network link. */ @UnsupportedAppUsage @@ -178,7 +166,6 @@ public class PreciseDataConnectionState implements Parcelable { out.writeInt(mNetworkType); out.writeString(mAPNType); out.writeString(mAPN); - out.writeString(mReason); out.writeParcelable(mLinkProperties, flags); out.writeString(mFailCause); } @@ -197,16 +184,7 @@ public class PreciseDataConnectionState implements Parcelable { @Override public int hashCode() { - final int prime = 31; - int result = 1; - result = prime * result + mState; - result = prime * result + mNetworkType; - result = prime * result + ((mAPNType == null) ? 0 : mAPNType.hashCode()); - result = prime * result + ((mAPN == null) ? 0 : mAPN.hashCode()); - result = prime * result + ((mReason == null) ? 0 : mReason.hashCode()); - result = prime * result + ((mLinkProperties == null) ? 0 : mLinkProperties.hashCode()); - result = prime * result + ((mFailCause == null) ? 0 : mFailCause.hashCode()); - return result; + return Objects.hash(mState, mNetworkType, mAPNType, mAPN, mLinkProperties, mFailCause); } @Override @@ -252,13 +230,6 @@ public class PreciseDataConnectionState implements Parcelable { if (mNetworkType != other.mNetworkType) { return false; } - if (mReason == null) { - if (other.mReason != null) { - return false; - } - } else if (!mReason.equals(other.mReason)) { - return false; - } if (mState != other.mState) { return false; } @@ -273,7 +244,6 @@ public class PreciseDataConnectionState implements Parcelable { sb.append(", Network type: " + mNetworkType); sb.append(", APN type: " + mAPNType); sb.append(", APN: " + mAPN); - sb.append(", Change reason: " + mReason); sb.append(", Link properties: " + mLinkProperties); sb.append(", Fail cause: " + mFailCause); diff --git a/telephony/java/android/telephony/TelephonyManager.java b/telephony/java/android/telephony/TelephonyManager.java index 2286ce29b4d3..739c80fd9d97 100644 --- a/telephony/java/android/telephony/TelephonyManager.java +++ b/telephony/java/android/telephony/TelephonyManager.java @@ -772,7 +772,6 @@ public class TelephonyManager { * The {@link #EXTRA_DATA_NETWORK_TYPE} extra indicates the connection network type. * The {@link #EXTRA_DATA_APN_TYPE} extra indicates the APN type. * The {@link #EXTRA_DATA_APN} extra indicates the APN. - * The {@link #EXTRA_DATA_CHANGE_REASON} extra indicates the connection change reason. * The {@link #EXTRA_DATA_IFACE_PROPERTIES} extra indicates the connection interface. * The {@link #EXTRA_DATA_FAILURE_CAUSE} extra indicates the connection fail cause. * @@ -783,7 +782,6 @@ public class TelephonyManager { * @see #EXTRA_DATA_NETWORK_TYPE * @see #EXTRA_DATA_APN_TYPE * @see #EXTRA_DATA_APN - * @see #EXTRA_DATA_CHANGE_REASON * @see #EXTRA_DATA_IFACE * @see #EXTRA_DATA_FAILURE_CAUSE * @hide @@ -872,18 +870,6 @@ public class TelephonyManager { /** * The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast - * for an String representation of the change reason. - * - * <p class="note"> - * Retrieve with - * {@link android.content.Intent#getStringExtra(String name)}. - * - * @hide - */ - public static final String EXTRA_DATA_CHANGE_REASON = PhoneConstants.STATE_CHANGE_REASON_KEY; - - /** - * The lookup key used with the {@link #ACTION_PRECISE_DATA_CONNECTION_STATE_CHANGED} broadcast * for an String representation of the data interface. * * <p class="note"> diff --git a/telephony/java/android/telephony/ims/Rcs1To1Thread.java b/telephony/java/android/telephony/ims/Rcs1To1Thread.java index 5122c7daafe6..709b3aa0f804 100644 --- a/telephony/java/android/telephony/ims/Rcs1To1Thread.java +++ b/telephony/java/android/telephony/ims/Rcs1To1Thread.java @@ -23,6 +23,10 @@ import android.os.Parcel; * @hide - TODO(sahinc) make this public */ public class Rcs1To1Thread extends RcsThread { + public Rcs1To1Thread(int threadId) { + super(threadId); + } + public static final Creator<Rcs1To1Thread> CREATOR = new Creator<Rcs1To1Thread>() { @Override public Rcs1To1Thread createFromParcel(Parcel in) { @@ -36,6 +40,7 @@ public class Rcs1To1Thread extends RcsThread { }; protected Rcs1To1Thread(Parcel in) { + super(in); } @Override @@ -45,5 +50,7 @@ public class Rcs1To1Thread extends RcsThread { @Override public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(RCS_1_TO_1_TYPE); + super.writeToParcel(dest, flags); } } diff --git a/telephony/java/android/telephony/ims/RcsGroupThread.java b/telephony/java/android/telephony/ims/RcsGroupThread.java index 150c4d49757c..d954b2d70ac3 100644 --- a/telephony/java/android/telephony/ims/RcsGroupThread.java +++ b/telephony/java/android/telephony/ims/RcsGroupThread.java @@ -36,6 +36,7 @@ public class RcsGroupThread extends RcsThread { }; protected RcsGroupThread(Parcel in) { + super(in); } @Override @@ -45,5 +46,7 @@ public class RcsGroupThread extends RcsThread { @Override public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(RCS_GROUP_TYPE); + super.writeToParcel(dest, flags); } } diff --git a/telephony/java/android/telephony/ims/RcsMessageStore.java b/telephony/java/android/telephony/ims/RcsMessageStore.java index 4198c78a8191..1bf6ffd81ca0 100644 --- a/telephony/java/android/telephony/ims/RcsMessageStore.java +++ b/telephony/java/android/telephony/ims/RcsMessageStore.java @@ -16,6 +16,8 @@ package android.telephony.ims; +import android.annotation.Nullable; +import android.annotation.WorkerThread; import android.os.RemoteException; import android.os.ServiceManager; import android.telephony.Rlog; @@ -27,26 +29,93 @@ import android.telephony.ims.aidl.IRcs; * @hide - TODO make this public */ public class RcsMessageStore { - private static final String TAG = "RcsMessageStore"; - private static final boolean VDBG = false; + static final String TAG = "RcsMessageStore"; /** - * Delete the RcsThread identified by the given threadId. + * Returns the first chunk of existing {@link RcsThread}s in the common storage. + * @param queryParameters Parameters to specify to return a subset of all RcsThreads. + * Passing a value of null will return all threads. + */ + @WorkerThread + public RcsThreadQueryResult getRcsThreads(@Nullable RcsThreadQueryParameters queryParameters) { + try { + IRcs iRcs = IRcs.Stub.asInterface(ServiceManager.getService("ircs")); + if (iRcs != null) { + return iRcs.getRcsThreads(queryParameters); + } + } catch (RemoteException re) { + Rlog.e(TAG, "RcsMessageStore: Exception happened during getRcsThreads", re); + } + + return null; + } + + /** + * Returns the next chunk of {@link RcsThread}s in the common storage. + * @param continuationToken A token to continue the query to get the next chunk. This is + * obtained through {@link RcsThreadQueryResult#nextChunkToken}. + */ + @WorkerThread + public RcsThreadQueryResult getRcsThreads(RcsThreadQueryContinuationToken continuationToken) { + try { + IRcs iRcs = IRcs.Stub.asInterface(ServiceManager.getService("ircs")); + if (iRcs != null) { + return iRcs.getRcsThreadsWithToken(continuationToken); + } + } catch (RemoteException re) { + Rlog.e(TAG, "RcsMessageStore: Exception happened during getRcsThreads", re); + } + + return null; + } + + /** + * Creates a new 1 to 1 thread with the given participant and persists it in the storage. + */ + @WorkerThread + public Rcs1To1Thread createRcs1To1Thread(RcsParticipant recipient) { + try { + IRcs iRcs = IRcs.Stub.asInterface(ServiceManager.getService("ircs")); + if (iRcs != null) { + return iRcs.createRcs1To1Thread(recipient); + } + } catch (RemoteException re) { + Rlog.e(TAG, "RcsMessageStore: Exception happened during createRcs1To1Thread", re); + } + + return null; + } + + /** + * Delete the {@link RcsThread} identified by the given threadId. * @param threadId threadId of the thread to be deleted. */ + @WorkerThread public void deleteThread(int threadId) { - if (VDBG) logd("deleteThread: threadId: " + threadId); try { IRcs iRcs = IRcs.Stub.asInterface(ServiceManager.getService("ircs")); if (iRcs != null) { iRcs.deleteThread(threadId); } } catch (RemoteException re) { - + Rlog.e(TAG, "RcsMessageStore: Exception happened during deleteThread", re); } } - private static void logd(String msg) { - Rlog.d(TAG, msg); + /** + * Creates a new participant and persists it in the storage. + * @param canonicalAddress The defining address (e.g. phone number) of the participant. + */ + public RcsParticipant createRcsParticipant(String canonicalAddress) { + try { + IRcs iRcs = IRcs.Stub.asInterface(ServiceManager.getService("ircs")); + if (iRcs != null) { + return iRcs.createRcsParticipant(canonicalAddress); + } + } catch (RemoteException re) { + Rlog.e(TAG, "RcsMessageStore: Exception happened during createRcsParticipant", re); + } + + return null; } } diff --git a/telephony/java/android/telephony/ims/RcsParticipant.java b/telephony/java/android/telephony/ims/RcsParticipant.java index 318dba3fcbca..70500aaa2e8b 100644 --- a/telephony/java/android/telephony/ims/RcsParticipant.java +++ b/telephony/java/android/telephony/ims/RcsParticipant.java @@ -23,6 +23,16 @@ import android.os.Parcelable; * @hide - TODO(sahinc) make this public */ public class RcsParticipant implements Parcelable { + /** + * Returns the row id of this participant. + * + * TODO(sahinc) implement + * @hide + */ + public int getId() { + return 12345; + } + public static final Creator<RcsParticipant> CREATOR = new Creator<RcsParticipant>() { @Override public RcsParticipant createFromParcel(Parcel in) { diff --git a/telephony/java/android/telephony/ims/RcsThread.java b/telephony/java/android/telephony/ims/RcsThread.java index 2969ffdda0e8..c0a0d946d204 100644 --- a/telephony/java/android/telephony/ims/RcsThread.java +++ b/telephony/java/android/telephony/ims/RcsThread.java @@ -16,7 +16,9 @@ package android.telephony.ims; +import android.os.Parcel; import android.os.Parcelable; +import android.util.Log; /** * RcsThread represents a single RCS conversation thread. It holds messages that were sent and @@ -24,5 +26,50 @@ import android.os.Parcelable; * @hide - TODO(sahinc) make this public */ public abstract class RcsThread implements Parcelable { + // Since this is an abstract class that gets parcelled, the sub-classes need to write these + // magic values into the parcel so that we know which type to unparcel into. + protected static final int RCS_1_TO_1_TYPE = 998; + protected static final int RCS_GROUP_TYPE = 999; + protected int mThreadId; + + protected RcsThread(int threadId) { + mThreadId = threadId; + } + + protected RcsThread(Parcel in) { + mThreadId = in.readInt(); + } + + public static final Creator<RcsThread> CREATOR = new Creator<RcsThread>() { + @Override + public RcsThread createFromParcel(Parcel in) { + int type = in.readInt(); + + switch (type) { + case RCS_1_TO_1_TYPE: + return new Rcs1To1Thread(in); + case RCS_GROUP_TYPE: + return new RcsGroupThread(in); + default: + Log.e(RcsMessageStore.TAG, "Cannot unparcel RcsThread, wrong type: " + type); + } + return null; + } + + @Override + public RcsThread[] newArray(int size) { + return new RcsThread[0]; + } + }; + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(mThreadId); + } } diff --git a/telephony/java/android/telephony/ims/RcsThreadQueryContinuationToken.aidl b/telephony/java/android/telephony/ims/RcsThreadQueryContinuationToken.aidl new file mode 100644 index 000000000000..7bcebfa08fcb --- /dev/null +++ b/telephony/java/android/telephony/ims/RcsThreadQueryContinuationToken.aidl @@ -0,0 +1,20 @@ +/* +** +** Copyright 2018, 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.ims; + +parcelable RcsThreadQueryContinuationToken; diff --git a/telephony/java/android/telephony/ims/RcsThreadQueryContinuationToken.java b/telephony/java/android/telephony/ims/RcsThreadQueryContinuationToken.java new file mode 100644 index 000000000000..931e93dc8bf1 --- /dev/null +++ b/telephony/java/android/telephony/ims/RcsThreadQueryContinuationToken.java @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2018 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.ims; + +import android.os.Parcel; +import android.os.Parcelable; + +/** + * A continuation token to provide for {@link RcsMessageStore#getRcsThreads}. Use this token to + * break large queries into manageable chunks + * @hide - TODO make this public + */ +public class RcsThreadQueryContinuationToken implements Parcelable { + protected RcsThreadQueryContinuationToken(Parcel in) { + } + + public static final Creator<RcsThreadQueryContinuationToken> CREATOR = + new Creator<RcsThreadQueryContinuationToken>() { + @Override + public RcsThreadQueryContinuationToken createFromParcel(Parcel in) { + return new RcsThreadQueryContinuationToken(in); + } + + @Override + public RcsThreadQueryContinuationToken[] newArray(int size) { + return new RcsThreadQueryContinuationToken[size]; + } + }; + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + } +} diff --git a/telephony/java/android/telephony/ims/RcsThreadQueryParameters.aidl b/telephony/java/android/telephony/ims/RcsThreadQueryParameters.aidl new file mode 100644 index 000000000000..feb2d4dec094 --- /dev/null +++ b/telephony/java/android/telephony/ims/RcsThreadQueryParameters.aidl @@ -0,0 +1,20 @@ +/* +** +** Copyright 2018, 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.ims; + +parcelable RcsThreadQueryParameters; diff --git a/telephony/java/android/telephony/ims/RcsThreadQueryParameters.java b/telephony/java/android/telephony/ims/RcsThreadQueryParameters.java new file mode 100644 index 000000000000..f2c4ab1884ca --- /dev/null +++ b/telephony/java/android/telephony/ims/RcsThreadQueryParameters.java @@ -0,0 +1,225 @@ +/* + * Copyright (C) 2018 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.ims; + +import android.annotation.CheckResult; +import android.os.Parcel; +import android.os.Parcelable; + +import java.security.InvalidParameterException; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Set; + +/** + * The parameters to pass into {@link RcsMessageStore#getRcsThreads(RcsThreadQueryParameters)} in + * order to select a subset of {@link RcsThread}s present in the message store. + * @hide TODO - make the Builder and builder() public. The rest should stay internal only. + */ +public class RcsThreadQueryParameters implements Parcelable { + private final boolean mIsGroup; + private final Set<RcsParticipant> mRcsParticipants; + private final int mLimit; + private final boolean mIsAscending; + + RcsThreadQueryParameters(boolean isGroup, Set<RcsParticipant> participants, int limit, + boolean isAscending) { + mIsGroup = isGroup; + mRcsParticipants = participants; + mLimit = limit; + mIsAscending = isAscending; + } + + /** + * Returns a new builder to build a query with. + * TODO - make public + */ + public static Builder builder() { + return new Builder(); + } + + /** + * This is used in {@link com.android.internal.telephony.ims.RcsMessageStoreController} to get + * the list of participants. + * @hide + */ + public Set<RcsParticipant> getRcsParticipants() { + return mRcsParticipants; + } + + /** + * This is used in {@link com.android.internal.telephony.ims.RcsMessageStoreController} to get + * whether group threads should be queried + * @hide + */ + public boolean isGroupThread() { + return mIsGroup; + } + + /** + * This is used in {@link com.android.internal.telephony.ims.RcsMessageStoreController} to get + * the number of tuples the result query should be limited to. + */ + public int getLimit() { + return mLimit; + } + + /** + * This is used in {@link com.android.internal.telephony.ims.RcsMessageStoreController} to + * determine the sort order. + */ + public boolean isAscending() { + return mIsAscending; + } + + /** + * A helper class to build the {@link RcsThreadQueryParameters}. + */ + public static class Builder { + private boolean mIsGroupThread; + private Set<RcsParticipant> mParticipants; + private int mLimit = 100; + private boolean mIsAscending; + + /** + * Package private constructor for {@link RcsThreadQueryParameters.Builder}. To obtain this, + * {@link RcsThreadQueryParameters#builder()} needs to be called. + */ + Builder() { + mParticipants = new HashSet<>(); + } + + /** + * Limits the query to only return group threads. + * @param isGroupThread Whether to limit the query result to group threads. + * @return The same instance of the builder to chain parameters. + */ + @CheckResult + public Builder isGroupThread(boolean isGroupThread) { + mIsGroupThread = isGroupThread; + return this; + } + + /** + * Limits the query to only return threads that contain the given participant. + * @param participant The participant that must be included in all of the returned threads. + * @return The same instance of the builder to chain parameters. + */ + @CheckResult + public Builder withParticipant(RcsParticipant participant) { + mParticipants.add(participant); + return this; + } + + /** + * Limits the query to only return threads that contain the given list of participants. + * @param participants An iterable list of participants that must be included in all of the + * returned threads. + * @return The same instance of the builder to chain parameters. + */ + @CheckResult + public Builder withParticipants(Iterable<RcsParticipant> participants) { + for (RcsParticipant participant : participants) { + mParticipants.add(participant); + } + return this; + } + + /** + * Desired number of threads to be returned from the query. Passing in 0 will return all + * existing threads at once. The limit defaults to 100. + * @param limit The number to limit the query result to. + * @return The same instance of the builder to chain parameters. + * @throws InvalidParameterException If the given limit is negative. + */ + @CheckResult + public Builder limitResultsTo(int limit) throws InvalidParameterException { + if (limit < 0) { + throw new InvalidParameterException("The query limit must be non-negative"); + } + + mLimit = limit; + return this; + } + + /** + * Sorts the results returned from the query via thread IDs. + * + * TODO - add sorting support for other fields + * + * @param isAscending whether to sort in ascending order or not + * @return The same instance of the builder to chain parameters. + */ + @CheckResult + public Builder sort(boolean isAscending) { + mIsAscending = isAscending; + return this; + } + + /** + * Builds the {@link RcsThreadQueryParameters} to use in + * {@link RcsMessageStore#getRcsThreads(RcsThreadQueryParameters)} + * + * @return An instance of {@link RcsThreadQueryParameters} to use with the thread query. + */ + public RcsThreadQueryParameters build() { + return new RcsThreadQueryParameters( + mIsGroupThread, mParticipants, mLimit, mIsAscending); + } + } + + /** + * Parcelable boilerplate below. + */ + protected RcsThreadQueryParameters(Parcel in) { + mIsGroup = in.readBoolean(); + + ArrayList<RcsParticipant> participantArrayList = new ArrayList<>(); + in.readTypedList(participantArrayList, RcsParticipant.CREATOR); + mRcsParticipants = new HashSet<>(participantArrayList); + + mLimit = in.readInt(); + mIsAscending = in.readBoolean(); + } + + public static final Creator<RcsThreadQueryParameters> CREATOR = + new Creator<RcsThreadQueryParameters>() { + @Override + public RcsThreadQueryParameters createFromParcel(Parcel in) { + return new RcsThreadQueryParameters(in); + } + + @Override + public RcsThreadQueryParameters[] newArray(int size) { + return new RcsThreadQueryParameters[size]; + } + }; + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeBoolean(mIsGroup); + dest.writeTypedList(new ArrayList<>(mRcsParticipants)); + dest.writeInt(mLimit); + dest.writeBoolean(mIsAscending); + } + +} diff --git a/telephony/java/android/telephony/ims/RcsThreadQueryResult.aidl b/telephony/java/android/telephony/ims/RcsThreadQueryResult.aidl new file mode 100644 index 000000000000..4b06529d1294 --- /dev/null +++ b/telephony/java/android/telephony/ims/RcsThreadQueryResult.aidl @@ -0,0 +1,20 @@ +/* +** +** Copyright 2018, 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.ims; + +parcelable RcsThreadQueryResult; diff --git a/telephony/java/android/telephony/ims/RcsThreadQueryResult.java b/telephony/java/android/telephony/ims/RcsThreadQueryResult.java new file mode 100644 index 000000000000..47715f8410d6 --- /dev/null +++ b/telephony/java/android/telephony/ims/RcsThreadQueryResult.java @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2018 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.ims; + +import android.os.Parcel; +import android.os.Parcelable; + +import java.util.List; + +/** + * The result of a {@link RcsMessageStore#getRcsThreads(RcsThreadQueryContinuationToken, + * RcsThreadQueryParameters)} + * call. This class allows getting the token for querying the next batch of threads in order to + * prevent handling large amounts of data at once. + * + * @hide + */ +public class RcsThreadQueryResult implements Parcelable { + private RcsThreadQueryContinuationToken mContinuationToken; + private List<RcsThread> mRcsThreads; + + /** + * Internal constructor for {@link com.android.internal.telephony.ims.RcsMessageStoreController} + * to create query results + * + * @hide + */ + public RcsThreadQueryResult( + RcsThreadQueryContinuationToken continuationToken, List<RcsThread> rcsThreads) { + mContinuationToken = continuationToken; + mRcsThreads = rcsThreads; + } + + /** + * Returns a token to call + * {@link RcsMessageStore#getRcsThreads(RcsThreadQueryContinuationToken)} + * to get the next batch of {@link RcsThread}s. + */ + public RcsThreadQueryContinuationToken nextChunkToken() { + return mContinuationToken; + } + + /** + * Returns all the RcsThreads in the current query result. Call {@link + * RcsMessageStore#getRcsThreads(RcsThreadQueryContinuationToken)} to get the next batch of + * {@link RcsThread}s. + */ + public List<RcsThread> getThreads() { + return mRcsThreads; + } + + protected RcsThreadQueryResult(Parcel in) { + // TODO - implement + } + + public static final Creator<RcsThreadQueryResult> CREATOR = + new Creator<RcsThreadQueryResult>() { + @Override + public RcsThreadQueryResult createFromParcel(Parcel in) { + return new RcsThreadQueryResult(in); + } + + @Override + public RcsThreadQueryResult[] newArray(int size) { + return new RcsThreadQueryResult[size]; + } + }; + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + // TODO - implement + } +} diff --git a/telephony/java/android/telephony/ims/aidl/IRcs.aidl b/telephony/java/android/telephony/ims/aidl/IRcs.aidl index b2e2fadca138..9badac5be230 100644 --- a/telephony/java/android/telephony/ims/aidl/IRcs.aidl +++ b/telephony/java/android/telephony/ims/aidl/IRcs.aidl @@ -16,14 +16,29 @@ package android.telephony.ims.aidl; +import android.telephony.ims.RcsParticipant; +import android.telephony.ims.Rcs1To1Thread; +import android.telephony.ims.RcsThreadQueryContinuationToken; +import android.telephony.ims.RcsThreadQueryParameters; +import android.telephony.ims.RcsThreadQueryResult; + /** * RPC definition between RCS storage APIs and phone process. * {@hide} */ interface IRcs { // RcsMessageStore APIs + RcsThreadQueryResult getRcsThreads(in RcsThreadQueryParameters queryParameters); + + RcsThreadQueryResult getRcsThreadsWithToken( + in RcsThreadQueryContinuationToken continuationToken); + void deleteThread(int threadId); + Rcs1To1Thread createRcs1To1Thread(in RcsParticipant participant); + + RcsParticipant createRcsParticipant(String canonicalAddress); + // RcsThread APIs int getMessageCount(int rcsThreadId); }
\ No newline at end of file diff --git a/telephony/java/com/android/internal/telephony/DctConstants.java b/telephony/java/com/android/internal/telephony/DctConstants.java index 0fdca5d24a20..96f7a1bc22a0 100644 --- a/telephony/java/com/android/internal/telephony/DctConstants.java +++ b/telephony/java/com/android/internal/telephony/DctConstants.java @@ -24,7 +24,7 @@ public class DctConstants { /** * IDLE: ready to start data connection setup, default state * CONNECTING: state of issued startPppd() but not finish yet - * SCANNING: data connection fails with one apn but other apns are available + * RETRYING: 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 @@ -34,19 +34,16 @@ public class DctConstants { * * getDataConnectionState() maps State to DataState * FAILED or IDLE : DISCONNECTED - * RETRYING or CONNECTING or SCANNING: CONNECTING + * RETRYING or CONNECTING: CONNECTING * CONNECTED : CONNECTED or DISCONNECTING */ public enum State { IDLE, CONNECTING, - SCANNING, + RETRYING, CONNECTED, DISCONNECTING, FAILED, - RETRYING // After moving retry manager to ApnContext, we'll never enter this state! - // Todo: Remove this state and other places that use this state and then - // rename SCANNING to RETRYING. } public enum Activity { @@ -81,7 +78,6 @@ public class DctConstants { public static final int EVENT_RESTART_RADIO = BASE + 26; public static final int EVENT_CLEAN_UP_ALL_CONNECTIONS = BASE + 29; public static final int EVENT_ICC_CHANGED = BASE + 33; - public static final int EVENT_DISCONNECT_DC_RETRYING = BASE + 34; public static final int EVENT_DATA_SETUP_COMPLETE_ERROR = BASE + 35; public static final int CMD_SET_ENABLE_FAIL_FAST_MOBILE_DATA = BASE + 36; public static final int CMD_ENABLE_MOBILE_PROVISIONING = BASE + 37; diff --git a/telephony/java/com/android/internal/telephony/ITelephonyRegistry.aidl b/telephony/java/com/android/internal/telephony/ITelephonyRegistry.aidl index d9f5c3f6d0fa..02a6f311c1da 100644 --- a/telephony/java/com/android/internal/telephony/ITelephonyRegistry.aidl +++ b/telephony/java/com/android/internal/telephony/ITelephonyRegistry.aidl @@ -50,13 +50,13 @@ interface ITelephonyRegistry { void notifyDataActivity(int state); void notifyDataActivityForSubscriber(in int subId, int state); void notifyDataConnection(int state, boolean isDataConnectivityPossible, - String reason, String apn, String apnType, in LinkProperties linkProperties, + String apn, String apnType, in LinkProperties linkProperties, in NetworkCapabilities networkCapabilities, int networkType, boolean roaming); void notifyDataConnectionForSubscriber(int subId, int state, boolean isDataConnectivityPossible, - String reason, String apn, String apnType, in LinkProperties linkProperties, + String apn, String apnType, in LinkProperties linkProperties, in NetworkCapabilities networkCapabilities, int networkType, boolean roaming); - void notifyDataConnectionFailed(String reason, String apnType); - void notifyDataConnectionFailedForSubscriber(int subId, String reason, String apnType); + void notifyDataConnectionFailed(String apnType); + void notifyDataConnectionFailedForSubscriber(int subId, String apnType); void notifyCellLocation(in Bundle cellLocation); void notifyCellLocationForSubscriber(in int subId, in Bundle cellLocation); void notifyOtaspChanged(in int otaspMode); @@ -67,7 +67,7 @@ interface ITelephonyRegistry { void notifyPreciseCallState(int ringingCallState, int foregroundCallState, int backgroundCallState); void notifyDisconnectCause(int disconnectCause, int preciseDisconnectCause); - void notifyPreciseDataConnectionFailed(String reason, String apnType, String apn, + void notifyPreciseDataConnectionFailed(String apnType, String apn, String failCause); void notifyCellInfoForSubscriber(in int subId, in List<CellInfo> cellInfo); void notifySrvccStateChanged(in int subId, in int lteState); diff --git a/telephony/java/com/android/internal/telephony/PhoneConstants.java b/telephony/java/com/android/internal/telephony/PhoneConstants.java index 21f3b92c6c4f..e87d28c6f9e9 100644 --- a/telephony/java/com/android/internal/telephony/PhoneConstants.java +++ b/telephony/java/com/android/internal/telephony/PhoneConstants.java @@ -79,8 +79,6 @@ public class PhoneConstants { public static final int SIM_ACTIVATION_TYPE_DATA = 1; public static final String PHONE_NAME_KEY = "phoneName"; - public static final String FAILURE_REASON_KEY = "reason"; - public static final String STATE_CHANGE_REASON_KEY = "reason"; public static final String DATA_NETWORK_TYPE_KEY = "networkType"; public static final String DATA_FAILURE_CAUSE_KEY = "failCause"; public static final String DATA_APN_TYPE_KEY = "apnType"; diff --git a/tests/RcsTests/Android.mk b/tests/RcsTests/Android.mk index adc7cab91389..7b348d73747a 100644 --- a/tests/RcsTests/Android.mk +++ b/tests/RcsTests/Android.mk @@ -11,7 +11,7 @@ LOCAL_PRIVATE_PLATFORM_APIS := true LOCAL_CERTIFICATE := platform LOCAL_JAVA_LIBRARIES := android.test.runner android.test.base -LOCAL_STATIC_JAVA_LIBRARIES := junit android-support-test mockito-target-minus-junit4 +LOCAL_STATIC_JAVA_LIBRARIES := junit android-support-test mockito-target-minus-junit4 truth-prebuilt include $(BUILD_PACKAGE) diff --git a/tests/RcsTests/src/com/android/tests/rcs/RcsMessageStoreTest.java b/tests/RcsTests/src/com/android/tests/ims/RcsMessageStoreTest.java index 290e04ce8abb..44277edcdb8c 100644 --- a/tests/RcsTests/src/com/android/tests/rcs/RcsMessageStoreTest.java +++ b/tests/RcsTests/src/com/android/tests/ims/RcsMessageStoreTest.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.android.tests.rcs; +package com.android.tests.ims; import android.support.test.runner.AndroidJUnit4; import android.telephony.ims.RcsMessageStore; diff --git a/tests/RcsTests/src/com/android/tests/ims/RcsThreadQueryParametersTest.java b/tests/RcsTests/src/com/android/tests/ims/RcsThreadQueryParametersTest.java new file mode 100644 index 000000000000..a890a389bdfc --- /dev/null +++ b/tests/RcsTests/src/com/android/tests/ims/RcsThreadQueryParametersTest.java @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2018 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.tests.ims; + +import static com.google.common.truth.Truth.assertThat; + +import android.os.Bundle; +import android.support.test.runner.AndroidJUnit4; +import android.telephony.ims.RcsParticipant; +import android.telephony.ims.RcsThreadQueryParameters; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; + +@RunWith(AndroidJUnit4.class) +public class RcsThreadQueryParametersTest { + private RcsThreadQueryParameters mRcsThreadQueryParameters; + @Mock RcsParticipant mMockParticipant; + + @Test + public void testUnparceling() { + String key = "some key"; + mRcsThreadQueryParameters = RcsThreadQueryParameters.builder() + .isGroupThread(true) + .withParticipant(mMockParticipant) + .limitResultsTo(50) + .sort(true) + .build(); + + Bundle bundle = new Bundle(); + bundle.putParcelable(key, mRcsThreadQueryParameters); + mRcsThreadQueryParameters = bundle.getParcelable(key); + + assertThat(mRcsThreadQueryParameters.isGroupThread()).isTrue(); + assertThat(mRcsThreadQueryParameters.getRcsParticipants()).contains(mMockParticipant); + assertThat(mRcsThreadQueryParameters.getLimit()).isEqualTo(50); + assertThat(mRcsThreadQueryParameters.isAscending()).isTrue(); + } +} |