From cfa5d2485228f8cc0cf9b5acaba6f3d2b0775962 Mon Sep 17 00:00:00 2001 From: Sooraj Sasindran Date: Mon, 26 Oct 2020 19:53:58 -0700 Subject: [PATCH] Provide API to retrive dual connected bandwidth Provide API to retrive bandwidth per primary carrier and secondary carrier Bug: 162373679 Test: New CTS test, unit test, build Change-Id: I3e8152d22fb9602c7d2ffdee681ac5d69c5dd3fd --- api/system-current.txt | 12 + core/api/system-current.txt | 12 + .../android/telephony/CarrierBandwidth.aidl | 17 ++ .../android/telephony/CarrierBandwidth.java | 208 ++++++++++++++++++ .../android/telephony/TelephonyManager.java | 27 +++ .../internal/telephony/ITelephony.aidl | 7 + 6 files changed, 283 insertions(+) create mode 100644 telephony/java/android/telephony/CarrierBandwidth.aidl create mode 100644 telephony/java/android/telephony/CarrierBandwidth.java diff --git a/api/system-current.txt b/api/system-current.txt index b28e7afddbe31..ba71e187aac70 100644 --- a/api/system-current.txt +++ b/api/system-current.txt @@ -11137,6 +11137,17 @@ package android.telephony { field @NonNull public static final android.os.Parcelable.Creator CREATOR; } + public final class CarrierBandwidth implements android.os.Parcelable { + ctor public CarrierBandwidth(int, int, int, int); + method public int describeContents(); + method public int getPrimaryDownlinkCapacityKbps(); + method public int getPrimaryUplinkCapacityKbps(); + method public int getSecondaryDownlinkCapacityKbps(); + method public int getSecondaryUplinkCapacityKbps(); + field @NonNull public static final android.os.Parcelable.Creator CREATOR; + field public static final int INVALID = -1; // 0xffffffff + } + public class CarrierConfigManager { method @NonNull @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public String getDefaultCarrierServicePackageName(); method @NonNull public static android.os.PersistableBundle getDefaultConfig(); @@ -11790,6 +11801,7 @@ package android.telephony { method @Nullable @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS) public android.content.ComponentName getAndUpdateDefaultRespondViaMessageApplication(); method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void getCallForwarding(int, @NonNull java.util.concurrent.Executor, @NonNull android.telephony.TelephonyManager.CallForwardingInfoCallback); method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void getCallWaitingStatus(@NonNull java.util.concurrent.Executor, @NonNull java.util.function.Consumer); + method @NonNull @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public android.telephony.CarrierBandwidth getCarrierBandwidth(); method @Nullable @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public android.telephony.ImsiEncryptionInfo getCarrierInfoForImsiEncryption(int); method public java.util.List getCarrierPackageNamesForIntent(android.content.Intent); method public java.util.List getCarrierPackageNamesForIntentAndPhone(android.content.Intent, int); diff --git a/core/api/system-current.txt b/core/api/system-current.txt index 8b15ec3b19214..87dff7f7fa558 100644 --- a/core/api/system-current.txt +++ b/core/api/system-current.txt @@ -9979,6 +9979,17 @@ package android.telephony { field @NonNull public static final android.os.Parcelable.Creator CREATOR; } + public final class CarrierBandwidth implements android.os.Parcelable { + ctor public CarrierBandwidth(int, int, int, int); + method public int describeContents(); + method public int getPrimaryDownlinkCapacityKbps(); + method public int getPrimaryUplinkCapacityKbps(); + method public int getSecondaryDownlinkCapacityKbps(); + method public int getSecondaryUplinkCapacityKbps(); + field @NonNull public static final android.os.Parcelable.Creator CREATOR; + field public static final int INVALID = -1; // 0xffffffff + } + public class CarrierConfigManager { method @NonNull @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public String getDefaultCarrierServicePackageName(); method @NonNull public static android.os.PersistableBundle getDefaultConfig(); @@ -10632,6 +10643,7 @@ package android.telephony { method @Nullable @RequiresPermission(android.Manifest.permission.INTERACT_ACROSS_USERS) public android.content.ComponentName getAndUpdateDefaultRespondViaMessageApplication(); method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void getCallForwarding(int, @NonNull java.util.concurrent.Executor, @NonNull android.telephony.TelephonyManager.CallForwardingInfoCallback); method @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public void getCallWaitingStatus(@NonNull java.util.concurrent.Executor, @NonNull java.util.function.Consumer); + method @NonNull @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public android.telephony.CarrierBandwidth getCarrierBandwidth(); method @Nullable @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) public android.telephony.ImsiEncryptionInfo getCarrierInfoForImsiEncryption(int); method public java.util.List getCarrierPackageNamesForIntent(android.content.Intent); method public java.util.List getCarrierPackageNamesForIntentAndPhone(android.content.Intent, int); diff --git a/telephony/java/android/telephony/CarrierBandwidth.aidl b/telephony/java/android/telephony/CarrierBandwidth.aidl new file mode 100644 index 0000000000000..d0861b88e7373 --- /dev/null +++ b/telephony/java/android/telephony/CarrierBandwidth.aidl @@ -0,0 +1,17 @@ +/* + * Copyright 2020 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; +parcelable CarrierBandwidth; \ No newline at end of file diff --git a/telephony/java/android/telephony/CarrierBandwidth.java b/telephony/java/android/telephony/CarrierBandwidth.java new file mode 100644 index 0000000000000..17747a3919ee6 --- /dev/null +++ b/telephony/java/android/telephony/CarrierBandwidth.java @@ -0,0 +1,208 @@ +/* + * Copyright (C) 2020 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.annotation.NonNull; +import android.annotation.Nullable; +import android.annotation.SystemApi; +import android.os.Parcel; +import android.os.Parcelable; + +import java.util.Objects; + +/** + * Defines downlink and uplink capacity of a network in kbps + * @hide + */ +@SystemApi +public final class CarrierBandwidth implements Parcelable { + /** + * Any field that is not reported shall be set to INVALID + */ + public static final int INVALID = -1; + + /** + * Estimated downlink capacity in kbps of the primary carrier. + * This bandwidth estimate shall be the estimated maximum sustainable link bandwidth. + * This will be {@link #INVALID} if the network is not connected + */ + private int mPrimaryDownlinkCapacityKbps; + + /** + * Estimated uplink capacity in kbps of the primary carrier. + * This bandwidth estimate shall be the estimated maximum sustainable link bandwidth. + * This will be {@link #INVALID} if the network is not connected + */ + private int mPrimaryUplinkCapacityKbps; + + /** + * Estimated downlink capacity in kbps of the secondary carrier in a dual connected network. + * This bandwidth estimate shall be the estimated maximum sustainable link bandwidth. + * This will be {@link #INVALID} if the network is not connected + */ + private int mSecondaryDownlinkCapacityKbps; + + /** + * Estimated uplink capacity in kbps of the secondary carrier in a dual connected network. + * This bandwidth estimate shall be the estimated maximum sustainable link bandwidth. + * This will be {@link #INVALID} if the network is not connected + */ + private int mSecondaryUplinkCapacityKbps; + + /** @hide **/ + public CarrierBandwidth(Parcel in) { + mPrimaryDownlinkCapacityKbps = in.readInt(); + mPrimaryUplinkCapacityKbps = in.readInt(); + mSecondaryDownlinkCapacityKbps = in.readInt(); + mSecondaryUplinkCapacityKbps = in.readInt(); + } + + /** @hide **/ + public CarrierBandwidth() { + mPrimaryDownlinkCapacityKbps = INVALID; + mPrimaryUplinkCapacityKbps = INVALID; + mSecondaryDownlinkCapacityKbps = INVALID; + mSecondaryUplinkCapacityKbps = INVALID; + } + + /** + * Constructor. + * + * @param primaryDownlinkCapacityKbps Estimated downlink capacity in kbps of + * the primary carrier. + * @param primaryUplinkCapacityKbps Estimated uplink capacity in kbps of + * the primary carrier. + * @param secondaryDownlinkCapacityKbps Estimated downlink capacity in kbps of + * the secondary carrier + * @param secondaryUplinkCapacityKbps Estimated uplink capacity in kbps of + * the secondary carrier + */ + public CarrierBandwidth(int primaryDownlinkCapacityKbps, int primaryUplinkCapacityKbps, + int secondaryDownlinkCapacityKbps, int secondaryUplinkCapacityKbps) { + mPrimaryDownlinkCapacityKbps = primaryDownlinkCapacityKbps; + mPrimaryUplinkCapacityKbps = primaryUplinkCapacityKbps; + mSecondaryDownlinkCapacityKbps = secondaryDownlinkCapacityKbps; + mSecondaryUplinkCapacityKbps = secondaryUplinkCapacityKbps; + } + + /** + * Retrieves the upstream bandwidth for the primary network in Kbps. This always only refers to + * the estimated first hop transport bandwidth. + * This will be INVALID if the network is not connected + * + * @return The estimated first hop upstream (device to network) bandwidth. + */ + public int getPrimaryDownlinkCapacityKbps() { + return mPrimaryDownlinkCapacityKbps; + } + + /** + * Retrieves the downstream bandwidth for the primary network in Kbps. This always only refers + * to the estimated first hop transport bandwidth. + * This will be INVALID if the network is not connected + * + * @return The estimated first hop downstream (network to device) bandwidth. + */ + public int getPrimaryUplinkCapacityKbps() { + return mPrimaryUplinkCapacityKbps; + } + + /** + * Retrieves the upstream bandwidth for the secondary network in Kbps. This always only refers + * to the estimated first hop transport bandwidth. + * This will be INVALID if the network is not connected + * + * @return The estimated first hop upstream (device to network) bandwidth. + */ + public int getSecondaryDownlinkCapacityKbps() { + return mSecondaryDownlinkCapacityKbps; + } + + /** + * Retrieves the downstream bandwidth for the secondary network in Kbps. This always only + * refers to the estimated first hop transport bandwidth. + * This will be INVALID if the network is not connected + * + * @return The estimated first hop downstream (network to device) bandwidth. + */ + public int getSecondaryUplinkCapacityKbps() { + return mSecondaryUplinkCapacityKbps; + } + + @NonNull + @Override + public String toString() { + return "CarrierBandwidth: {primaryDownlinkCapacityKbps=" + mPrimaryDownlinkCapacityKbps + + " primaryUplinkCapacityKbps=" + mPrimaryUplinkCapacityKbps + + " secondaryDownlinkCapacityKbps=" + mSecondaryDownlinkCapacityKbps + + " secondaryUplinkCapacityKbps=" + mSecondaryUplinkCapacityKbps + + "}"; + } + + @Override + public int hashCode() { + return Objects.hash( + mPrimaryDownlinkCapacityKbps, + mPrimaryUplinkCapacityKbps, + mSecondaryDownlinkCapacityKbps, + mSecondaryUplinkCapacityKbps); + } + + @Override + public boolean equals(@Nullable Object o) { + if (o == null || !(o instanceof CallQuality) || hashCode() != o.hashCode()) { + return false; + } + if (this == o) { + return true; + } + CarrierBandwidth s = (CarrierBandwidth) o; + return (mPrimaryDownlinkCapacityKbps == s.mPrimaryDownlinkCapacityKbps + && mPrimaryUplinkCapacityKbps == s.mPrimaryUplinkCapacityKbps + && mSecondaryDownlinkCapacityKbps == s.mSecondaryDownlinkCapacityKbps + && mSecondaryDownlinkCapacityKbps == s.mSecondaryDownlinkCapacityKbps); + } + + /** + * {@link Parcelable#describeContents} + */ + public int describeContents() { + return 0; + } + + /** + * {@link Parcelable#writeToParcel} + * @hide + */ + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(mPrimaryDownlinkCapacityKbps); + dest.writeInt(mPrimaryUplinkCapacityKbps); + dest.writeInt(mSecondaryDownlinkCapacityKbps); + dest.writeInt(mSecondaryUplinkCapacityKbps); + } + + public static final @android.annotation.NonNull Parcelable.Creator CREATOR = + new Parcelable.Creator() { + public CarrierBandwidth createFromParcel(Parcel in) { + return new CarrierBandwidth(in); + } + + public CarrierBandwidth[] newArray(int size) { + return new CarrierBandwidth[size]; + } + }; +} diff --git a/telephony/java/android/telephony/TelephonyManager.java b/telephony/java/android/telephony/TelephonyManager.java index 425addc70daea..2c8d613a7b854 100644 --- a/telephony/java/android/telephony/TelephonyManager.java +++ b/telephony/java/android/telephony/TelephonyManager.java @@ -13657,6 +13657,33 @@ public class TelephonyManager { return 0; } + /** + * Get carrier bandwidth. In case of Dual connected network this will report + * bandwidth per primary and secondary network. + * @return CarrierBandwidth with bandwidth of both primary and secondary carrier. + * @throws IllegalStateException if the Telephony process is not currently available. + * @hide + */ + @SystemApi + @RequiresPermission(android.Manifest.permission.READ_PRIVILEGED_PHONE_STATE) + @NonNull + public CarrierBandwidth getCarrierBandwidth() { + try { + ITelephony service = getITelephony(); + if (service != null) { + return service.getCarrierBandwidth(getSubId()); + } else { + throw new IllegalStateException("telephony service is null."); + } + } catch (RemoteException ex) { + Log.e(TAG, "getCarrierBandwidth RemoteException", ex); + ex.rethrowFromSystemServer(); + } + + //Should not reach. Adding return statement to make compiler happy + return null; + } + /** * Called when userActivity is signalled in the power manager. * This should only be called from system Uid. diff --git a/telephony/java/com/android/internal/telephony/ITelephony.aidl b/telephony/java/com/android/internal/telephony/ITelephony.aidl index a38d5b6f21419..dc23190455877 100644 --- a/telephony/java/com/android/internal/telephony/ITelephony.aidl +++ b/telephony/java/com/android/internal/telephony/ITelephony.aidl @@ -31,6 +31,7 @@ import android.service.carrier.CarrierIdentifier; import android.telecom.PhoneAccount; import android.telecom.PhoneAccountHandle; import android.telephony.CallForwardingInfo; +import android.telephony.CarrierBandwidth; import android.telephony.CarrierRestrictionRules; import android.telephony.CellIdentity; import android.telephony.CellInfo; @@ -2232,4 +2233,10 @@ interface ITelephony { * @return true if dual connectivity is enabled else false */ boolean isNrDualConnectivityEnabled(int subId); + + /** + * Get carrier bandwidth per primary and secondary carrier + * @return CarrierBandwidth with bandwidth of both primary and secondary carrier. + */ + CarrierBandwidth getCarrierBandwidth(int subId); }