telephony/java/android/telephony/CellSignalStrengthLte.java

   1 /*
   2  * Copyright (C) 2012 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 android.telephony.Rlog;
  22
  23 /**
  24  * LTE signal strength related information.
  25  */
  26 public final class CellSignalStrengthLte extends CellSignalStrength implements Parcelable {
  27
  28     private static final String LOG_TAG = "CellSignalStrengthLte";
  29     private static final boolean DBG = false;
  30
  31     private int mSignalStrength;
  32     private int mRsrp;
  33     private int mRsrq;
  34     private int mRssnr;
  35     private int mCqi;
  36     private int mTimingAdvance;
  37
  38     /**
  39      * Empty constructor
  40      *
  41      * @hide
  42      */
  43     public CellSignalStrengthLte() {
  44         setDefaultValues();
  45     }
  46
  47     /**
  48      * Constructor
  49      *
  50      * @hide
  51      */
  52     public CellSignalStrengthLte(int signalStrength, int rsrp, int rsrq, int rssnr, int cqi,
  53             int timingAdvance) {
  54         initialize(signalStrength, rsrp, rsrq, rssnr, cqi, timingAdvance);
  55     }
  56
  57     /**
  58      * Copy constructors
  59      *
  60      * @param s Source SignalStrength
  61      *
  62      * @hide
  63      */
  64     public CellSignalStrengthLte(CellSignalStrengthLte s) {
  65         copyFrom(s);
  66     }
  67
  68     /**
  69      * Initialize all the values
  70      *
  71      * @param lteSignalStrength
  72      * @param rsrp
  73      * @param rsrq
  74      * @param rssnr
  75      * @param cqi
  76      *
  77      * @hide
  78      */
  79     public void initialize(int lteSignalStrength, int rsrp, int rsrq, int rssnr, int cqi,
  80             int timingAdvance) {
  81         mSignalStrength = lteSignalStrength;
  82         mRsrp = rsrp;
  83         mRsrq = rsrq;
  84         mRssnr = rssnr;
  85         mCqi = cqi;
  86         mTimingAdvance = timingAdvance;
  87     }
  88
  89     /**
  90      * Initialize from the SignalStrength structure.
  91      *
  92      * @param ss
  93      *
  94      * @hide
  95      */
  96     public void initialize(SignalStrength ss, int timingAdvance) {
  97         mSignalStrength = ss.getLteSignalStrength();
  98         mRsrp = ss.getLteRsrp();
  99         mRsrq = ss.getLteRsrq();
 100         mRssnr = ss.getLteRssnr();
 101         mCqi = ss.getLteCqi();
 102         mTimingAdvance = timingAdvance;
 103     }
 104
 105     /**
 106      * @hide
 107      */
 108     protected void copyFrom(CellSignalStrengthLte s) {
 109         mSignalStrength = s.mSignalStrength;
 110         mRsrp = s.mRsrp;
 111         mRsrq = s.mRsrq;
 112         mRssnr = s.mRssnr;
 113         mCqi = s.mCqi;
 114         mTimingAdvance = s.mTimingAdvance;
 115     }
 116
 117     /**
 118      * @hide
 119      */
 120     @Override
 121     public CellSignalStrengthLte copy() {
 122         return new CellSignalStrengthLte(this);
 123     }
 124
 125     /** @hide */
 126     @Override
 127     public void setDefaultValues() {
 128         mSignalStrength = Integer.MAX_VALUE;
 129         mRsrp = Integer.MAX_VALUE;
 130         mRsrq = Integer.MAX_VALUE;
 131         mRssnr = Integer.MAX_VALUE;
 132         mCqi = Integer.MAX_VALUE;
 133         mTimingAdvance = Integer.MAX_VALUE;
 134     }
 135
 136     /**
 137      * Get signal level as an int from 0..4
 138      */
 139     @Override
 140     public int getLevel() {
 141         int levelRsrp = 0;
 142         int levelRssnr = 0;
 143
 144         if (mRsrp == Integer.MAX_VALUE) levelRsrp = 0;
 145         else if (mRsrp >= -95) levelRsrp = SIGNAL_STRENGTH_GREAT;
 146         else if (mRsrp >= -105) levelRsrp = SIGNAL_STRENGTH_GOOD;
 147         else if (mRsrp >= -115) levelRsrp = SIGNAL_STRENGTH_MODERATE;
 148         else levelRsrp = SIGNAL_STRENGTH_POOR;
 149
 150         // See RIL_LTE_SignalStrength in ril.h
 151         if (mRssnr == Integer.MAX_VALUE) levelRssnr = 0;
 152         else if (mRssnr >= 45) levelRssnr = SIGNAL_STRENGTH_GREAT;
 153         else if (mRssnr >= 10) levelRssnr = SIGNAL_STRENGTH_GOOD;
 154         else if (mRssnr >= -30) levelRssnr = SIGNAL_STRENGTH_MODERATE;
 155         else levelRssnr = SIGNAL_STRENGTH_POOR;
 156
 157         int level;
 158         if (mRsrp == Integer.MAX_VALUE)
 159             level = levelRssnr;
 160         else if (mRssnr == Integer.MAX_VALUE)
 161             level = levelRsrp;
 162         else
 163             level = (levelRssnr < levelRsrp) ? levelRssnr : levelRsrp;
 164
 165         if (DBG) log("Lte rsrp level: " + levelRsrp
 166                 + " snr level: " + levelRssnr + " level: " + level);
 167         return level;
 168     }
 169
 170     /**
 171      * Get signal strength as dBm
 172      */
 173     @Override
 174     public int getDbm() {
 175         return mRsrp;
 176     }
 177
 178     /**
 179      * Get the LTE signal level as an asu value between 0..97, 99 is unknown
 180      * Asu is calculated based on 3GPP RSRP. Refer to 3GPP 27.007 (Ver 10.3.0) Sec 8.69
 181      */
 182     @Override
 183     public int getAsuLevel() {
 184         int lteAsuLevel = 99;
 185         int lteDbm = getDbm();
 186         if (lteDbm <= -140) lteAsuLevel = 0;
 187         else if (lteDbm >= -43) lteAsuLevel = 97;
 188         else lteAsuLevel = lteDbm + 140;
 189         if (DBG) log("Lte Asu level: "+lteAsuLevel);
 190         return lteAsuLevel;
 191     }
 192
 193     /**
 194      * Get the timing advance value for LTE.
 195      * See 3GPP xxxx
 196      */
 197     public int getTimingAdvance() {
 198         return mTimingAdvance;
 199     }
 200
 201     @Override
 202     public int hashCode() {
 203         int primeNum = 31;
 204         return (mSignalStrength * primeNum) + (mRsrp * primeNum)
 205                 + (mRsrq * primeNum) + (mRssnr * primeNum) + (mCqi * primeNum)
 206                 + (mTimingAdvance * primeNum);
 207     }
 208
 209     @Override
 210     public boolean equals (Object o) {
 211         CellSignalStrengthLte s;
 212
 213         try {
 214             s = (CellSignalStrengthLte) o;
 215         } catch (ClassCastException ex) {
 216             return false;
 217         }
 218
 219         if (o == null) {
 220             return false;
 221         }
 222
 223         return mSignalStrength == s.mSignalStrength
 224                 && mRsrp == s.mRsrp
 225                 && mRsrq == s.mRsrq
 226                 && mRssnr == s.mRssnr
 227                 && mCqi == s.mCqi
 228                 && mTimingAdvance == s.mTimingAdvance;
 229     }
 230
 231     /**
 232      * @return string representation.
 233      */
 234     @Override
 235     public String toString() {
 236         return "CellSignalStrengthLte:"
 237                 + " ss=" + mSignalStrength
 238                 + " rsrp=" + mRsrp
 239                 + " rsrq=" + mRsrq
 240                 + " rssnr=" + mRssnr
 241                 + " cqi=" + mCqi
 242                 + " ta=" + mTimingAdvance;
 243     }
 244
 245     /** Implement the Parcelable interface */
 246     @Override
 247     public void writeToParcel(Parcel dest, int flags) {
 248         if (DBG) log("writeToParcel(Parcel, int): " + toString());
 249         dest.writeInt(mSignalStrength);
 250         // Need to multiply rsrp and rsrq by -1
 251         // to ensure consistency when reading values written here
 252         dest.writeInt(mRsrp * -1);
 253         dest.writeInt(mRsrq * -1);
 254         dest.writeInt(mRssnr);
 255         dest.writeInt(mCqi);
 256         dest.writeInt(mTimingAdvance);
 257     }
 258
 259     /**
 260      * Construct a SignalStrength object from the given parcel
 261      * where the token is already been processed.
 262      */
 263     private CellSignalStrengthLte(Parcel in) {
 264         mSignalStrength = in.readInt();
 265         // rsrp and rsrq are written into the parcel as positive values.
 266         // Need to convert into negative values
 267         mRsrp = in.readInt() * -1;
 268         mRsrq = in.readInt() * -1;
 269         mRssnr = in.readInt();
 270         mCqi = in.readInt();
 271         mTimingAdvance = in.readInt();
 272         if (DBG) log("CellSignalStrengthLte(Parcel): " + toString());
 273     }
 274
 275     /** Implement the Parcelable interface */
 276     @Override
 277     public int describeContents() {
 278         return 0;
 279     }
 280
 281     /** Implement the Parcelable interface */
 282     @SuppressWarnings("hiding")
 283     public static final Parcelable.Creator<CellSignalStrengthLte> CREATOR =
 284             new Parcelable.Creator<CellSignalStrengthLte>() {
 285         @Override
 286         public CellSignalStrengthLte createFromParcel(Parcel in) {
 287             return new CellSignalStrengthLte(in);
 288         }
 289
 290         @Override
 291         public CellSignalStrengthLte[] newArray(int size) {
 292             return new CellSignalStrengthLte[size];
 293         }
 294     };
 295
 296     /**
 297      * log
 298      */
 299     private static void log(String s) {
 300         Rlog.w(LOG_TAG, s);
 301     }
 302 }