src.android.telephony.NetworkScanRequest Maven / Gradle / Ivy
/*
* Copyright (C) 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.os.Parcel;
import android.os.Parcelable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Arrays;
/**
* Defines a request to peform a network scan.
*
* This class defines whether the network scan will be performed only once or periodically until
* cancelled, when the scan is performed periodically, the time interval is not controlled by the
* user but defined by the modem vendor.
*/
public final class NetworkScanRequest implements Parcelable {
// Below size limits for RAN/Band/Channel are for pre-treble modems and will be removed later.
/** @hide */
public static final int MAX_RADIO_ACCESS_NETWORKS = 8;
/** @hide */
public static final int MAX_BANDS = 8;
/** @hide */
public static final int MAX_CHANNELS = 32;
/** @hide */
public static final int MAX_MCC_MNC_LIST_SIZE = 20;
/** @hide */
public static final int MIN_SEARCH_PERIODICITY_SEC = 5;
/** @hide */
public static final int MAX_SEARCH_PERIODICITY_SEC = 300;
/** @hide */
public static final int MIN_SEARCH_MAX_SEC = 60;
/** @hide */
public static final int MAX_SEARCH_MAX_SEC = 3600;
/** @hide */
public static final int MIN_INCREMENTAL_PERIODICITY_SEC = 1;
/** @hide */
public static final int MAX_INCREMENTAL_PERIODICITY_SEC = 10;
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@IntDef({
SCAN_TYPE_ONE_SHOT,
SCAN_TYPE_PERIODIC,
})
public @interface ScanType {}
/** Performs the scan only once */
public static final int SCAN_TYPE_ONE_SHOT = 0;
/**
* Performs the scan periodically until cancelled
*
* The modem will start new scans periodically, and the interval between two scans is usually
* multiple minutes.
*/
public static final int SCAN_TYPE_PERIODIC = 1;
/** Defines the type of the scan. */
private int mScanType;
/**
* Search periodicity (in seconds).
* Expected range for the input is [5s - 300s]
* This value must be less than or equal to mMaxSearchTime
*/
private int mSearchPeriodicity;
/**
* Maximum duration of the periodic search (in seconds).
* Expected range for the input is [60s - 3600s]
* If the search lasts this long, it will be terminated.
*/
private int mMaxSearchTime;
/**
* Indicates whether the modem should report incremental
* results of the network scan to the client.
* FALSE – Incremental results are not reported.
* TRUE (default) – Incremental results are reported
*/
private boolean mIncrementalResults;
/**
* Indicates the periodicity with which the modem should
* report incremental results to the client (in seconds).
* Expected range for the input is [1s - 10s]
* This value must be less than or equal to mMaxSearchTime
*/
private int mIncrementalResultsPeriodicity;
/** Describes the radio access technologies with bands or channels that need to be scanned. */
private RadioAccessSpecifier[] mSpecifiers;
/**
* Describes the List of PLMN ids (MCC-MNC)
* If any PLMN of this list is found, search should end at that point and
* results with all PLMN found till that point should be sent as response.
* If list not sent, search to be completed till end and all PLMNs found to be reported.
* Max size of array is MAX_MCC_MNC_LIST_SIZE
*/
private ArrayList mMccMncs;
/**
* Creates a new NetworkScanRequest with mScanType and network mSpecifiers
*
* @param scanType The type of the scan, can be either one shot or periodic
* @param specifiers the radio network with bands / channels to be scanned
* @param searchPeriodicity The modem will restart the scan every searchPeriodicity seconds if
* no network has been found, until it reaches the maxSearchTime. Only
* valid when scan type is periodic scan.
* @param maxSearchTime Maximum duration of the search (in seconds)
* @param incrementalResults Indicates whether the modem should report incremental
* results of the network scan to the client
* @param incrementalResultsPeriodicity Indicates the periodicity with which the modem should
* report incremental results to the client (in seconds),
* only valid when incrementalResults is true
* @param mccMncs Describes the list of PLMN ids (MCC-MNC), once any network in the list has
* been found, the scan will be terminated by the modem.
*/
public NetworkScanRequest(int scanType, RadioAccessSpecifier[] specifiers,
int searchPeriodicity,
int maxSearchTime,
boolean incrementalResults,
int incrementalResultsPeriodicity,
ArrayList mccMncs) {
this.mScanType = scanType;
if (specifiers != null) {
this.mSpecifiers = specifiers.clone();
} else {
this.mSpecifiers = null;
}
this.mSearchPeriodicity = searchPeriodicity;
this.mMaxSearchTime = maxSearchTime;
this.mIncrementalResults = incrementalResults;
this.mIncrementalResultsPeriodicity = incrementalResultsPeriodicity;
if (mccMncs != null) {
this.mMccMncs = (ArrayList) mccMncs.clone();
} else {
this.mMccMncs = new ArrayList<>();
}
}
/** Returns the type of the scan. */
@ScanType
public int getScanType() {
return mScanType;
}
/** Returns the search periodicity in seconds. */
public int getSearchPeriodicity() {
return mSearchPeriodicity;
}
/** Returns maximum duration of the periodic search in seconds. */
public int getMaxSearchTime() {
return mMaxSearchTime;
}
/**
* Returns whether incremental result is enabled.
* FALSE – Incremental results is not enabled.
* TRUE – Incremental results is reported.
*/
public boolean getIncrementalResults() {
return mIncrementalResults;
}
/** Returns the periodicity in seconds of incremental results. */
public int getIncrementalResultsPeriodicity() {
return mIncrementalResultsPeriodicity;
}
/** Returns the radio access technologies with bands or channels that need to be scanned. */
public RadioAccessSpecifier[] getSpecifiers() {
return mSpecifiers == null ? null : mSpecifiers.clone();
}
/**
* Returns the List of PLMN ids (MCC-MNC) for early termination of scan.
* If any PLMN of this list is found, search should end at that point and
* results with all PLMN found till that point should be sent as response.
*/
public ArrayList getPlmns() {
return (ArrayList) mMccMncs.clone();
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(mScanType);
dest.writeParcelableArray(mSpecifiers, flags);
dest.writeInt(mSearchPeriodicity);
dest.writeInt(mMaxSearchTime);
dest.writeBoolean(mIncrementalResults);
dest.writeInt(mIncrementalResultsPeriodicity);
dest.writeStringList(mMccMncs);
}
private NetworkScanRequest(Parcel in) {
mScanType = in.readInt();
Parcelable[] tempSpecifiers = in.readParcelableArray(Object.class.getClassLoader(),
RadioAccessSpecifier.class);
if (tempSpecifiers != null) {
mSpecifiers = new RadioAccessSpecifier[tempSpecifiers.length];
for (int i = 0; i < tempSpecifiers.length; i++) {
mSpecifiers[i] = (RadioAccessSpecifier) tempSpecifiers[i];
}
} else {
mSpecifiers = null;
}
mSearchPeriodicity = in.readInt();
mMaxSearchTime = in.readInt();
mIncrementalResults = in.readBoolean();
mIncrementalResultsPeriodicity = in.readInt();
mMccMncs = new ArrayList<>();
in.readStringList(mMccMncs);
}
@Override
public boolean equals (Object o) {
NetworkScanRequest nsr;
try {
nsr = (NetworkScanRequest) o;
} catch (ClassCastException ex) {
return false;
}
if (o == null) {
return false;
}
return (mScanType == nsr.mScanType
&& Arrays.equals(mSpecifiers, nsr.mSpecifiers)
&& mSearchPeriodicity == nsr.mSearchPeriodicity
&& mMaxSearchTime == nsr.mMaxSearchTime
&& mIncrementalResults == nsr.mIncrementalResults
&& mIncrementalResultsPeriodicity == nsr.mIncrementalResultsPeriodicity
&& (((mMccMncs != null)
&& mMccMncs.equals(nsr.mMccMncs))));
}
@Override
public int hashCode () {
return ((mScanType * 31)
+ (Arrays.hashCode(mSpecifiers)) * 37
+ (mSearchPeriodicity * 41)
+ (mMaxSearchTime * 43)
+ ((mIncrementalResults == true? 1 : 0) * 47)
+ (mIncrementalResultsPeriodicity * 53)
+ (mMccMncs.hashCode() * 59));
}
public static final @android.annotation.NonNull Creator CREATOR =
new Creator() {
@Override
public NetworkScanRequest createFromParcel(Parcel in) {
return new NetworkScanRequest(in);
}
@Override
public NetworkScanRequest[] newArray(int size) {
return new NetworkScanRequest[size];
}
};
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy