diff options
Diffstat (limited to 'android/telephony/NetworkRegistrationState.java')
| -rw-r--r-- | android/telephony/NetworkRegistrationState.java | 258 |
1 files changed, 258 insertions, 0 deletions
diff --git a/android/telephony/NetworkRegistrationState.java b/android/telephony/NetworkRegistrationState.java new file mode 100644 index 00000000..e0510694 --- /dev/null +++ b/android/telephony/NetworkRegistrationState.java @@ -0,0 +1,258 @@ +/* + * Copyright 2017 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.IntDef; +import android.annotation.Nullable; +import android.annotation.SystemApi; +import android.os.Parcel; +import android.os.Parcelable; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.util.Arrays; +import java.util.Objects; + +/** + * Description of a mobile network registration state + * @hide + */ +@SystemApi +public class NetworkRegistrationState implements Parcelable { + /** + * Network domain + * @hide + */ + @Retention(RetentionPolicy.SOURCE) + @IntDef(prefix = "DOMAIN_", value = {DOMAIN_CS, DOMAIN_PS}) + public @interface Domain {} + + /** Circuit switching domain */ + public static final int DOMAIN_CS = 1; + /** Packet switching domain */ + public static final int DOMAIN_PS = 2; + + /** + * Registration state + * @hide + */ + @Retention(RetentionPolicy.SOURCE) + @IntDef(prefix = "REG_STATE_", + value = {REG_STATE_NOT_REG_NOT_SEARCHING, REG_STATE_HOME, REG_STATE_NOT_REG_SEARCHING, + REG_STATE_DENIED, REG_STATE_UNKNOWN, REG_STATE_ROAMING}) + public @interface RegState {} + + /** Not registered. The device is not currently searching a new operator to register */ + public static final int REG_STATE_NOT_REG_NOT_SEARCHING = 0; + /** Registered on home network */ + public static final int REG_STATE_HOME = 1; + /** Not registered. The device is currently searching a new operator to register */ + public static final int REG_STATE_NOT_REG_SEARCHING = 2; + /** Registration denied */ + public static final int REG_STATE_DENIED = 3; + /** Registration state is unknown */ + public static final int REG_STATE_UNKNOWN = 4; + /** Registered on roaming network */ + public static final int REG_STATE_ROAMING = 5; + + /** + * Supported service type + * @hide + */ + @Retention(RetentionPolicy.SOURCE) + @IntDef(prefix = "SERVICE_TYPE_", + value = {SERVICE_TYPE_VOICE, SERVICE_TYPE_DATA, SERVICE_TYPE_SMS, SERVICE_TYPE_VIDEO, + SERVICE_TYPE_EMERGENCY}) + public @interface ServiceType {} + + public static final int SERVICE_TYPE_VOICE = 1; + public static final int SERVICE_TYPE_DATA = 2; + public static final int SERVICE_TYPE_SMS = 3; + public static final int SERVICE_TYPE_VIDEO = 4; + public static final int SERVICE_TYPE_EMERGENCY = 5; + + /** {@link AccessNetworkConstants.TransportType}*/ + private final int mTransportType; + + @Domain + private final int mDomain; + + @RegState + private final int mRegState; + + private final int mAccessNetworkTechnology; + + private final int mReasonForDenial; + + private final boolean mEmergencyOnly; + + private final int[] mAvailableServices; + + @Nullable + private final CellIdentity mCellIdentity; + + + /** + * @param transportType Transport type. Must be {@link AccessNetworkConstants.TransportType} + * @param domain Network domain. Must be DOMAIN_CS or DOMAIN_PS. + * @param regState Network registration state. + * @param accessNetworkTechnology See TelephonyManager NETWORK_TYPE_XXXX. + * @param reasonForDenial Reason for denial if the registration state is DENIED. + * @param availableServices The supported service. + * @param cellIdentity The identity representing a unique cell + */ + public NetworkRegistrationState(int transportType, int domain, int regState, + int accessNetworkTechnology, int reasonForDenial, boolean emergencyOnly, + int[] availableServices, @Nullable CellIdentity cellIdentity) { + mTransportType = transportType; + mDomain = domain; + mRegState = regState; + mAccessNetworkTechnology = accessNetworkTechnology; + mReasonForDenial = reasonForDenial; + mAvailableServices = availableServices; + mCellIdentity = cellIdentity; + mEmergencyOnly = emergencyOnly; + } + + protected NetworkRegistrationState(Parcel source) { + mTransportType = source.readInt(); + mDomain = source.readInt(); + mRegState = source.readInt(); + mAccessNetworkTechnology = source.readInt(); + mReasonForDenial = source.readInt(); + mEmergencyOnly = source.readBoolean(); + mAvailableServices = source.createIntArray(); + mCellIdentity = source.readParcelable(CellIdentity.class.getClassLoader()); + } + + /** + * @return The transport type. + */ + public int getTransportType() { return mTransportType; } + + /** + * @return The network domain. + */ + public @Domain int getDomain() { return mDomain; } + + /** + * @return The registration state. + */ + public @RegState int getRegState() { + return mRegState; + } + + /** + * @return Whether emergency is enabled. + */ + public boolean isEmergencyEnabled() { return mEmergencyOnly; } + + /** + * @return List of available service types. + */ + public int[] getAvailableServices() { return mAvailableServices; } + + /** + * @return The access network technology. Must be one of TelephonyManager.NETWORK_TYPE_XXXX. + */ + public int getAccessNetworkTechnology() { + return mAccessNetworkTechnology; + } + + @Override + public int describeContents() { + return 0; + } + + private static String regStateToString(int regState) { + switch (regState) { + case REG_STATE_NOT_REG_NOT_SEARCHING: return "NOT_REG_NOT_SEARCHING"; + case REG_STATE_HOME: return "HOME"; + case REG_STATE_NOT_REG_SEARCHING: return "NOT_REG_SEARCHING"; + case REG_STATE_DENIED: return "DENIED"; + case REG_STATE_UNKNOWN: return "UNKNOWN"; + case REG_STATE_ROAMING: return "ROAMING"; + } + return "Unknown reg state " + regState; + } + + @Override + public String toString() { + return new StringBuilder("NetworkRegistrationState{") + .append("transportType=").append(mTransportType) + .append(" domain=").append((mDomain == DOMAIN_CS) ? "CS" : "PS") + .append(" regState=").append(regStateToString(mRegState)) + .append(" accessNetworkTechnology=") + .append(TelephonyManager.getNetworkTypeName(mAccessNetworkTechnology)) + .append(" reasonForDenial=").append(mReasonForDenial) + .append(" emergencyEnabled=").append(mEmergencyOnly) + .append(" supportedServices=").append(mAvailableServices) + .append(" cellIdentity=").append(mCellIdentity) + .append("}").toString(); + } + + @Override + public int hashCode() { + return Objects.hash(mTransportType, mDomain, mRegState, mAccessNetworkTechnology, + mReasonForDenial, mEmergencyOnly, mAvailableServices, mCellIdentity); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + + if (o == null || !(o instanceof NetworkRegistrationState)) { + return false; + } + + NetworkRegistrationState other = (NetworkRegistrationState) o; + return mTransportType == other.mTransportType + && mDomain == other.mDomain + && mRegState == other.mRegState + && mAccessNetworkTechnology == other.mAccessNetworkTechnology + && mReasonForDenial == other.mReasonForDenial + && mEmergencyOnly == other.mEmergencyOnly + && (mAvailableServices == other.mAvailableServices + || Arrays.equals(mAvailableServices, other.mAvailableServices)) + && mCellIdentity == other.mCellIdentity; + } + + @Override + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(mTransportType); + dest.writeInt(mDomain); + dest.writeInt(mRegState); + dest.writeInt(mAccessNetworkTechnology); + dest.writeInt(mReasonForDenial); + dest.writeBoolean(mEmergencyOnly); + dest.writeIntArray(mAvailableServices); + dest.writeParcelable(mCellIdentity, 0); + } + + public static final Parcelable.Creator<NetworkRegistrationState> CREATOR = + new Parcelable.Creator<NetworkRegistrationState>() { + @Override + public NetworkRegistrationState createFromParcel(Parcel source) { + return new NetworkRegistrationState(source); + } + + @Override + public NetworkRegistrationState[] newArray(int size) { + return new NetworkRegistrationState[size]; + } + }; +} |