content: /*
   * 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.util.ArrayList;
  import java.util.Arrays;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  
  /**
   * 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<String> 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<String> 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<String>) 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<String> getPlmns() {
          return (ArrayList<String>) 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();
          mSpecifiers = (RadioAccessSpecifier[]) in.readParcelableArray(
                  Object.class.getClassLoader(),
                  RadioAccessSpecifier.class);
          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<NetworkScanRequest> CREATOR =
              new Creator<NetworkScanRequest>() {
                  @Override
                  public NetworkScanRequest createFromParcel(Parcel in) {
                      return new NetworkScanRequest(in);
                  }
  
                  @Override
                  public NetworkScanRequest[] newArray(int size) {
                      return new NetworkScanRequest[size];
                  }
              };
  }
  