telephony/java/android/telephony/NeighboringCellInfo.java

   1 /*
   2  * Copyright (C) 2006 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.telephony;
  18
  19 import android.os.Parcel;
  20 import android.os.Parcelable;
  21 import static android.telephony.TelephonyManager.NETWORK_TYPE_UNKNOWN;
  22 import static android.telephony.TelephonyManager.NETWORK_TYPE_EDGE;
  23 import static android.telephony.TelephonyManager.NETWORK_TYPE_GPRS;
  24 import static android.telephony.TelephonyManager.NETWORK_TYPE_UMTS;
  25 import static android.telephony.TelephonyManager.NETWORK_TYPE_HSDPA;
  26 import static android.telephony.TelephonyManager.NETWORK_TYPE_HSUPA;
  27 import static android.telephony.TelephonyManager.NETWORK_TYPE_HSPA;
  28
  29
  30
  31 /**
  32  * Represents the neighboring cell information, including
  33  * Received Signal Strength and Cell ID location.
  34  */
  35 public class NeighboringCellInfo implements Parcelable
  36 {
  37     /**
  38      * Signal strength is not available
  39      */
  40     static final public int UNKNOWN_RSSI = 99;
  41     /**
  42      * Cell location is not available
  43      */
  44     static final public int UNKNOWN_CID = -1;
  45
  46     /**
  47      * In GSM, mRssi is the Received RSSI;
  48      * In UMTS, mRssi is the Level index of CPICH Received Signal Code Power
  49      */
  50     private int mRssi;
  51     /**
  52      * CID in 16 bits format in GSM. Return UNKNOWN_CID in UMTS and CMDA.
  53      */
  54     private int mCid;
  55     /**
  56      * LAC in 16 bits format in GSM. Return UNKNOWN_CID in UMTS and CMDA.
  57      */
  58     private int mLac;
  59     /**
  60      * Primary Scrambling Code in 9 bits format in UMTS
  61      * Return UNKNOWN_CID in GSM and CMDA.
  62      */
  63     private int mPsc;
  64     /**
  65      * Radio network type, value is one of following
  66      * TelephonyManager.NETWORK_TYPE_XXXXXX.
  67      */
  68     private int mNetworkType;
  69
  70     /**
  71      * Empty constructor.  Initializes the RSSI and CID.
  72      *
  73      * NeighboringCellInfo is one time shot for the neighboring cells based on
  74      * the radio network type at that moment. Its constructor needs radio network
  75      * type.
  76      *
  77      * @deprecated by {@link #NeighboringCellInfo(int, String, int)}
  78      */
  79     @Deprecated
  80     public NeighboringCellInfo() {
  81         mRssi = UNKNOWN_RSSI;
  82         mLac = UNKNOWN_CID;
  83         mCid = UNKNOWN_CID;
  84         mPsc = UNKNOWN_CID;
  85         mNetworkType = NETWORK_TYPE_UNKNOWN;
  86     }
  87
  88     /**
  89      * Initialize the object from rssi and cid.
  90      *
  91      * NeighboringCellInfo is one time shot for the neighboring cells based on
  92      * the radio network type at that moment. Its constructor needs radio network
  93      * type.
  94      *
  95      * @deprecated by {@link #NeighboringCellInfo(int, String, int)}
  96      */
  97     @Deprecated
  98     public NeighboringCellInfo(int rssi, int cid) {
  99         mRssi = rssi;
 100         mCid = cid;
 101     }
 102
 103     /**
 104      * Initialize the object from rssi, location string, and radioType
 105      * radioType is one of following
 106      * {@link TelephonyManager#NETWORK_TYPE_GPRS TelephonyManager.NETWORK_TYPE_GPRS},
 107      * {@link TelephonyManager#NETWORK_TYPE_EDGE TelephonyManager.NETWORK_TYPE_EDGE},
 108      * {@link TelephonyManager#NETWORK_TYPE_UMTS TelephonyManager.NETWORK_TYPE_UMTS},
 109      * {@link TelephonyManager#NETWORK_TYPE_HSDPA TelephonyManager.NETWORK_TYPE_HSDPA},
 110      * {@link TelephonyManager#NETWORK_TYPE_HSUPA TelephonyManager.NETWORK_TYPE_HSUPA},
 111      * and {@link TelephonyManager#NETWORK_TYPE_HSPA TelephonyManager.NETWORK_TYPE_HSPA}.
 112      */
 113     public NeighboringCellInfo(int rssi, String location, int radioType) {
 114         // set default value
 115         mRssi = rssi;
 116         mNetworkType = NETWORK_TYPE_UNKNOWN;
 117         mPsc = UNKNOWN_CID;
 118         mLac = UNKNOWN_CID;
 119         mCid = UNKNOWN_CID;
 120
 121
 122         // pad location string with leading "0"
 123         int l = location.length();
 124         if (l > 8) return;
 125         if (l < 8) {
 126             for (int i = 0; i < (8-l); i++) {
 127                 location = "0" + location;
 128             }
 129         }
 130         // TODO - handle LTE and eHRPD (or find they can't be supported)
 131         try {// set LAC/CID or PSC based on radioType
 132             switch (radioType) {
 133             case NETWORK_TYPE_GPRS:
 134             case NETWORK_TYPE_EDGE:
 135                 mNetworkType = radioType;
 136                 // check if 0xFFFFFFFF for UNKNOWN_CID
 137                 if (!location.equalsIgnoreCase("FFFFFFFF")) {
 138                     mCid = Integer.valueOf(location.substring(4), 16);
 139                     mLac = Integer.valueOf(location.substring(0, 4), 16);
 140                 }
 141                 break;
 142             case NETWORK_TYPE_UMTS:
 143             case NETWORK_TYPE_HSDPA:
 144             case NETWORK_TYPE_HSUPA:
 145             case NETWORK_TYPE_HSPA:
 146                 mNetworkType = radioType;
 147                 mPsc = Integer.valueOf(location, 16);
 148                 break;
 149             }
 150         } catch (NumberFormatException e) {
 151             // parsing location error
 152             mPsc = UNKNOWN_CID;
 153             mLac = UNKNOWN_CID;
 154             mCid = UNKNOWN_CID;
 155             mNetworkType = NETWORK_TYPE_UNKNOWN;
 156         }
 157     }
 158
 159     /**
 160      * Initialize the object from a parcel.
 161      */
 162     public NeighboringCellInfo(Parcel in) {
 163         mRssi = in.readInt();
 164         mLac = in.readInt();
 165         mCid = in.readInt();
 166         mPsc = in.readInt();
 167         mNetworkType = in.readInt();
 168     }
 169
 170     /**
 171      * @return received signal strength or UNKNOWN_RSSI if unknown
 172      *
 173      * For GSM, it is in "asu" ranging from 0 to 31 (dBm = -113 + 2*asu)
 174      * 0 means "-113 dBm or less" and 31 means "-51 dBm or greater"
 175      * For UMTS, it is the Level index of CPICH RSCP defined in TS 25.125
 176      */
 177     public int getRssi() {
 178         return mRssi;
 179     }
 180
 181     /**
 182      * @return LAC in GSM, 0xffff max legal value
 183      *  UNKNOWN_CID if in UMTS or CMDA or unknown
 184      */
 185     public int getLac() {
 186         return mLac;
 187     }
 188
 189     /**
 190      * @return cell id in GSM, 0xffff max legal value
 191      *  UNKNOWN_CID if in UMTS or CDMA or unknown
 192      */
 193     public int getCid() {
 194         return mCid;
 195     }
 196
 197     /**
 198      * @return Primary Scrambling Code in 9 bits format in UMTS, 0x1ff max value
 199      *  UNKNOWN_CID if in GSM or CMDA or unknown
 200      */
 201     public int getPsc() {
 202         return mPsc;
 203     }
 204
 205     /**
 206      * @return Radio network type while neighboring cell location is stored.
 207      *
 208      * Return {@link TelephonyManager#NETWORK_TYPE_UNKNOWN TelephonyManager.NETWORK_TYPE_UNKNOWN}
 209      * means that the location information is unavailable.
 210      *
 211      * Return {@link TelephonyManager#NETWORK_TYPE_GPRS TelephonyManager.NETWORK_TYPE_GPRS} or
 212      * {@link TelephonyManager#NETWORK_TYPE_EDGE TelephonyManager.NETWORK_TYPE_EDGE}
 213      * means that Neighboring Cell information is stored for GSM network, in
 214      * which {@link NeighboringCellInfo#getLac NeighboringCellInfo.getLac} and
 215      * {@link NeighboringCellInfo#getCid NeighboringCellInfo.getCid} should be
 216      * called to access location.
 217      *
 218      * Return {@link TelephonyManager#NETWORK_TYPE_UMTS TelephonyManager.NETWORK_TYPE_UMTS},
 219      * {@link TelephonyManager#NETWORK_TYPE_HSDPA TelephonyManager.NETWORK_TYPE_HSDPA},
 220      * {@link TelephonyManager#NETWORK_TYPE_HSUPA TelephonyManager.NETWORK_TYPE_HSUPA},
 221      * or {@link TelephonyManager#NETWORK_TYPE_HSPA TelephonyManager.NETWORK_TYPE_HSPA}
 222      * means that Neighboring Cell information is stored for UMTS network, in
 223      * which {@link NeighboringCellInfo#getPsc NeighboringCellInfo.getPsc}
 224      * should be called to access location.
 225      */
 226     public int getNetworkType() {
 227         return mNetworkType;
 228     }
 229     /**
 230      * Set the cell id.
 231      *
 232      * NeighboringCellInfo is a one time shot for the neighboring cells based on
 233      * the radio network type at that moment. It shouldn't be changed after
 234      * creation.
 235      *
 236      * @deprecated cid value passed as in location parameter passed to constructor
 237      *              {@link #NeighboringCellInfo(int, String, int)}
 238      */
 239     @Deprecated
 240     public void setCid(int cid) {
 241         mCid = cid;
 242     }
 243
 244     /**
 245      * Set the signal strength of the cell.
 246      *
 247      * NeighboringCellInfo is a one time shot for the neighboring cells based on
 248      * the radio network type at that moment. It shouldn't be changed after
 249      * creation.
 250      *
 251      * @deprecated initial rssi value passed as parameter to constructor
 252      *              {@link #NeighboringCellInfo(int, String, int)}
 253      */
 254     @Deprecated
 255     public void setRssi(int rssi) {
 256         mRssi = rssi;
 257     }
 258
 259     @Override
 260     public String toString() {
 261         StringBuilder sb = new StringBuilder();
 262
 263         sb.append("[");
 264         if (mPsc != UNKNOWN_CID) {
 265             sb.append(Integer.toHexString(mPsc))
 266                     .append("@").append(((mRssi == UNKNOWN_RSSI)? "-" : mRssi));
 267         } else if(mLac != UNKNOWN_CID && mCid != UNKNOWN_CID) {
 268             sb.append(Integer.toHexString(mLac))
 269                     .append(Integer.toHexString(mCid))
 270                     .append("@").append(((mRssi == UNKNOWN_RSSI)? "-" : mRssi));
 271         }
 272         sb.append("]");
 273
 274         return sb.toString();
 275     }
 276
 277     public int describeContents() {
 278         return 0;
 279     }
 280
 281     public void writeToParcel(Parcel dest, int flags) {
 282         dest.writeInt(mRssi);
 283         dest.writeInt(mLac);
 284         dest.writeInt(mCid);
 285         dest.writeInt(mPsc);
 286         dest.writeInt(mNetworkType);
 287     }
 288
 289     public static final Parcelable.Creator<NeighboringCellInfo> CREATOR
 290     = new Parcelable.Creator<NeighboringCellInfo>() {
 291         public NeighboringCellInfo createFromParcel(Parcel in) {
 292             return new NeighboringCellInfo(in);
 293         }
 294
 295         public NeighboringCellInfo[] newArray(int size) {
 296             return new NeighboringCellInfo[size];
 297         }
 298     };
 299 }