Example usage for android.telephony TelephonyManager NETWORK_TYPE_LTE

List of usage examples for android.telephony TelephonyManager NETWORK_TYPE_LTE

  1. HOME
  2. Java
  3. android
  4. android.telephony.*
  5. TelephonyManager
  6. NETWORK_TYPE_LTE

Introduction

In this page you can find the example usage for android.telephony TelephonyManager NETWORK_TYPE_LTE.

Prototype

int NETWORK_TYPE_LTE

To view the source code for android.telephony TelephonyManager NETWORK_TYPE_LTE.

Click Source Link

Document

Current network is LTE

Usage

From source file:org.restcomm.app.utillib.ContentProvider.ContentValuesGenerator.java

/**
 * This method generates a ContentValues object from the signal object so that it may
 * be stored in the database./*from   ww w .j  a  v a2s.  c  om*/
 * @param signal
 * @param phoneType This is the phone type and must be one of {@link TelephonyManager#PHONE_TYPE_CDMA}
 * or {@link TelephonyManager#PHONE_TYPE_GSM}.
 * @param stagedEventId This is the id of the event that this signal has to be related to
 * @return
 */
public static ContentValues generateFromSignal(SignalEx signal, int phoneType, int networkType,
        int serviceState, int dataState, long stagedEventId, int wifiSignal, JSONObject serviceMode) {
    ContentValues values = new ContentValues();
    Integer dBm = 0;
    Integer signalDB = null;
    try {
        if (serviceMode != null && serviceMode.getLong("time") + 5000 < System.currentTimeMillis())
            serviceMode = null;
        if (signal == null) // as a result of a service outage
        {
            LoggerUtil.logToFile(LoggerUtil.Level.DEBUG, "ContentValues", "generateFromSignal",
                    "signal == null");
            values.put(Tables.SignalStrengths.SIGNAL, -256);
            //now do the common parameters
            values.put(Tables.SignalStrengths.TIMESTAMP, System.currentTimeMillis());
            values.put(Tables.SignalStrengths.EVENT_ID, stagedEventId);
            values.put(Tables.SignalStrengths.COVERAGE, 0);
            return values;
        }
        if (signal.getSignalStrength() == null) // as a result of a screen off (signal unknown)
            values.put(Tables.SignalStrengths.SIGNAL, (Integer) null);
        //do phone type specific actions first
        else if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) {
            boolean isEvdo = true;

            if (networkType == TelephonyManager.NETWORK_TYPE_1xRTT
                    || networkType == TelephonyManager.NETWORK_TYPE_CDMA) {
                isEvdo = false;
                dBm = signal.getCdmaDbm();
            } else {
                dBm = signal.getEvdoDbm();
                int evdoDbm = signal.getEvdoDbm();
                // If there is no EVDO signal but there is CDMA signal, then use CDMA signal
                if (evdoDbm <= -120 || evdoDbm >= -1) {
                    int cdmaDbm = signal.getCdmaDbm();
                    if (cdmaDbm <= -120 || cdmaDbm >= -1)
                        dBm = evdoDbm; // no cdma signal either, so send the evdo signal afterall
                    else {
                        dBm = cdmaDbm;
                        isEvdo = false; // display and report the CDMA signal if CDMA has signal and EVDO does not
                    }
                }
            }

            //if (dBm == -1) // When Scott had a network outage on CDMA, he got -1, we want -256
            //   dBm = -256;
            if (dBm == -120 && networkType == TelephonyManager.NETWORK_TYPE_LTE)
                dBm = null; // signal not known, this seems to happen with LTE advanced
            values.put(Tables.SignalStrengths.SIGNAL, dBm
            //isEvdo ? signal.getSignalStrength().getEvdoDbm() : signal.getSignalStrength().getCdmaDbm()
            );
            values.put(Tables.SignalStrengths.ECI0,
                    isEvdo ? signal.getEvdoEcio() / 10.0 : signal.getCdmaEcio() / 10.0);
            values.put(Tables.SignalStrengths.SNR, isEvdo ? signal.getEvdoSnr() : null);
            //if (isEvdo)
            values.put(Tables.SignalStrengths.SIGNAL2G, signal.getCdmaDbm()
            //isEvdo ? signal.getSignalStrength().getCdmaDbm() : null
            );
            signalDB = dBm;
        } else if (phoneType == TelephonyManager.PHONE_TYPE_GSM) {

            if (getPlatform() == 1) //On Android device
                signalDB = signal.getGsmSignalStrength();
            else if (getPlatform() == 3) {//On Blackberry device
                signalDB = PreferenceManager.getDefaultSharedPreferences(service.getApplicationContext())
                        .getInt(PreferenceKeys.Miscellaneous.BB_SIGNAL, 99);

            }
            if (signalDB == 99 || signalDB == -1 || signalDB == null) {
                signalDB = null;
                //            Integer signalLte = signal.getLayer3("mLteSignalStrength");
                //            if (signalLte != null && signalLte < 99)
                //            {
                //               if (signalLte == 0)
                //                  signalDB = -120;
                //               else
                //                  signalDB = -113 + signalLte*2;
                //            }

                // If signal is unknown but signal bars are known, send bars
                Integer signalBar = signal.getLayer3("mGsmSignalBar");
                if (signalBar != null && signalBar != -1) {
                    signalDB = getSignalDBFromBars(signalBar);
                    values.put(Tables.SignalStrengths.SIGNALBARS, signalBar);
                }

            } else if (getPlatform() == 1)
                signalDB = signal.getDbmValue(networkType, phoneType);

            Integer ecio = signal.getLayer3("mUmtsEcio");
            if (ecio == null)
                ecio = signal.getLayer3("mgw_ecio");
            if (ecio == null)
                ecio = signal.getLayer3("mGsmEcio");
            //         if (ecio == null)
            //         {
            //            ecio = signal.getLayer3("lastEcIoIndex");
            //            if (ecio != null)
            //               ecio = 2*signal.getLayer3Array("lastEcIoValues", ecio);
            //         }

            Integer ecno = signal.getLayer3("mUmtsEcno");
            if (ecno == null)
                ecno = signal.getLayer3("mGsmEcno");
            Integer rscp = signal.getLayer3("mUmtsRscp");
            if (rscp == null)
                rscp = signal.getLayer3("mGsmRscp");
            if (rscp == null)
                rscp = signal.getLayer3("mWcdmaRscp");
            if ((signalDB == null || signalDB <= -120) && rscp != null && rscp > -120 && rscp < -20)
                signalDB = rscp;

            values.put(Tables.SignalStrengths.ECI0, ecio);
            values.put(Tables.SignalStrengths.RSCP, rscp);
            values.put(Tables.SignalStrengths.ECN0, ecno);
            values.put(Tables.SignalStrengths.SIGNAL, signalDB);
            values.put(Tables.SignalStrengths.BER,
                    signal.getGsmBitErrorRate() == 99 ? null : signal.getGsmBitErrorRate());
        }
        values.put(Tables.SignalStrengths.WIFISIGNAL, wifiSignal);
        // check for LTE signal signal quality parameters only if connected to LTE
        if (networkType == TelephonyManager.NETWORK_TYPE_LTE) {
            Integer lteRsrp = -1, lteRsrq, lteSnr, lteCqi;

            lteRsrp = signal.getLayer3("mLteRsrp");
            lteRsrq = signal.getLayer3("mLteRsrq");
            lteSnr = signal.getLayer3("mLteRssnr");
            if (lteRsrp != null && lteRsrp >= 40 && lteRsrp < 140)
                lteRsrp = -lteRsrp;
            else if (lteRsrp != null && lteRsrp > 0 && lteRsrp <= 32)
                lteRsrp = (lteRsrp - 2) * 2 + -109;
            if (lteSnr == null || lteSnr > 1000)
                lteSnr = signal.getLayer3("mLteSnr");
            if (lteSnr == null || lteSnr < -200 || lteSnr > 1000)
                lteSnr = null;
            if (lteRsrp != null && lteRsrp > 1000)
                lteRsrp = lteRsrq = null;

            lteCqi = signal.getLayer3("mLteCqi");
            values.put(Tables.SignalStrengths.LTE_RSRP, lteRsrp);
            values.put(Tables.SignalStrengths.LTE_RSRQ, lteRsrq);
            values.put(Tables.SignalStrengths.LTE_SNR, lteSnr);
            values.put(Tables.SignalStrengths.LTE_CQI, lteCqi);

        }
        // check for the LTE signal regardless, at least it will indicate of device supports LTE
        Integer lteRssi = signal.getLayer3("mLteRssi");
        if (lteRssi == null)
            lteRssi = signal.getLayer3("mLteSignalStrength");
        if (lteRssi != null) {
            if (lteRssi >= 0 && lteRssi < 32) {
                if (lteRssi == 0)
                    lteRssi = -120; // officially 0 means -113dB or less, but since lowest possible signal on Blackberry = -120, call it -120 for consistency
                else if (lteRssi == 1)
                    lteRssi = -111; // officially 1 = -111 dB
                else if (lteRssi > 1 && lteRssi <= 31)
                    lteRssi = (lteRssi - 2) * 2 + -109;
            }

            // allow for the possibility of sending a 3G signal and LTE signal at the same time
            // but if LTE signal is present, and 3G signal says -120 or worse, ignore regular signal
            if (lteRssi > -120 && (dBm == null || dBm <= -120))
                values.put(Tables.SignalStrengths.SIGNAL, (Integer) lteRssi);

        }
        values.put(Tables.SignalStrengths.LTE_SIGNAL, lteRssi);

        if (serviceMode != null && serviceMode.getLong("time") + 20000 > System.currentTimeMillis()) {
            if (serviceMode.has("ecio") && serviceMode.getString("ecio").length() > 1) {
                int svc_ecio = Integer.parseInt(serviceMode.getString("ecio"), 10);
                if (svc_ecio <= -2 && svc_ecio >= -30) {
                    values.put(Tables.SignalStrengths.ECI0, svc_ecio);
                }
            }
            if (serviceMode.has("rscp") && serviceMode.getString("rscp").length() > 1) {
                int svc_rscp = Integer.parseInt(serviceMode.getString("rscp"), 10);
                if (svc_rscp <= -20 && svc_rscp >= -120) //  && (signalDB == null || signalDB <= -120))
                    values.put(Tables.SignalStrengths.SIGNAL, svc_rscp);
            }

            if (serviceMode.has("snr") && serviceMode.getString("snr").length() > 1) {
                float svc_fsnr = Float.parseFloat(serviceMode.getString("snr"));
                int svc_snr = (int) (svc_fsnr * 10);
                if (svc_snr > -200 && svc_snr < 2000)
                    values.put(Tables.SignalStrengths.LTE_SNR, svc_snr);
            }

            if (serviceMode.has("rsrp") && serviceMode.getString("rsrp").length() > 1) {
                int svc_rsrp = Integer.parseInt(serviceMode.getString("rsrp"), 10);
                if (svc_rsrp <= -20 && svc_rsrp >= -140)
                    values.put(Tables.SignalStrengths.LTE_RSRP, svc_rsrp);
            }

            if (serviceMode.has("rsrq") && serviceMode.getString("rsrq").length() > 1) {
                int svc_rsrq = Integer.parseInt(serviceMode.getString("rsrp"), 10);
                if (svc_rsrq <= -1 && svc_rsrq >= -30)
                    values.put(Tables.SignalStrengths.LTE_RSRQ, svc_rsrq);
            }

        }

        //now do the common parameters
        values.put(Tables.SignalStrengths.TIMESTAMP, signal.getTimestamp());
        values.put(Tables.SignalStrengths.EVENT_ID, stagedEventId);
        int coverage = 0;
        if (networkType == 0) {
            if (serviceState == ServiceState.STATE_IN_SERVICE)
                networkType = 1;
            //else if (serviceState == ServiceState.STATE_POWER_OFF)
            //   networkType = -1;
        }
        int networkTier = PhoneState.getNetworkGeneration(networkType);
        if (networkTier == 0) // dont make it 0 unless truly out of service
            networkTier = 1;
        if (serviceState == ServiceState.STATE_OUT_OF_SERVICE && (dataState != TelephonyManager.DATA_CONNECTED
                || networkType != TelephonyManager.NETWORK_TYPE_LTE)) // Sprint can be connected to LTE and say outofservice
            networkTier = 0;
        else if (serviceState == ServiceState.STATE_POWER_OFF
                || serviceState == ServiceState.STATE_EMERGENCY_ONLY
                || serviceState == ServiceState.STATE_POWER_OFF || serviceState == 9) // 9 = MMCPhoneStateListenerOld.SERVICE_STATE_AIRPLANE)
            networkTier = -1;

        // tier 5 becomes 11111, tier 1 = 00001
        coverage = networkTier; // (1 << networkTier) - 1;

        //String reflect = listSignalFields (signal);

        values.put(Tables.SignalStrengths.COVERAGE, coverage);
        //MMCLogger.logToFile(MMCLogger.Level.DEBUG, "", "onSignal.listSignalFields", reflect);
        //MMCLogger.logToFile(MMCLogger.Level.DEBUG, "", "onSignal.values", values.toString());
    } catch (Exception e) {
        LoggerUtil.logToFile(LoggerUtil.Level.ERROR, "ContentValuesGenerator", "generateFromSignal",
                "exception", e);
    }
    return values;
}

From source file:com.fallahpoor.infocenter.fragments.SimFragment.java

private String getNetworkType(TelephonyManager telephonyManager) {

    int intNetType = telephonyManager.getNetworkType();
    String netType;//from www .j a va 2s.  c  o  m

    switch (intNetType) {
    case TelephonyManager.NETWORK_TYPE_1xRTT:
        netType = getString(R.string.sim_sub_item_1xrtt);
        break;
    case TelephonyManager.NETWORK_TYPE_CDMA:
        netType = getString(R.string.sim_sub_item_cdma);
        break;
    case TelephonyManager.NETWORK_TYPE_EDGE:
        netType = getString(R.string.sim_sub_item_edge);
        break;
    case TelephonyManager.NETWORK_TYPE_EHRPD:
        netType = getString(R.string.sim_sub_item_ehrdp);
        break;
    case TelephonyManager.NETWORK_TYPE_EVDO_0:
    case TelephonyManager.NETWORK_TYPE_EVDO_A:
    case TelephonyManager.NETWORK_TYPE_EVDO_B:
        netType = getString(R.string.sim_sub_item_evdo);
        break;
    case TelephonyManager.NETWORK_TYPE_GPRS:
        netType = getString(R.string.sim_sub_item_gprs);
        break;
    case TelephonyManager.NETWORK_TYPE_HSDPA:
        netType = getString(R.string.sim_sub_item_hsdpa);
        break;
    case TelephonyManager.NETWORK_TYPE_HSPA:
        netType = getString(R.string.sim_sub_item_hspa);
        break;
    case TelephonyManager.NETWORK_TYPE_HSPAP:
        netType = getString(R.string.sim_sub_item_hspap);
        break;
    case TelephonyManager.NETWORK_TYPE_HSUPA:
        netType = getString(R.string.sim_sub_item_hsupa);
        break;
    case TelephonyManager.NETWORK_TYPE_IDEN:
        netType = getString(R.string.sim_sub_item_iden);
        break;
    case TelephonyManager.NETWORK_TYPE_LTE:
        netType = getString(R.string.sim_sub_item_lte);
        break;
    case TelephonyManager.NETWORK_TYPE_UMTS:
        netType = getString(R.string.sim_sub_item_umts);
        break;
    default:
        netType = getString(R.string.unknown);
    }

    return netType;

}

From source file:org.kei.android.phone.cellhistory.towers.MobileNetworkInfo.java

public static String getNetworkType(final int networkType, final boolean nameOnly) {
    String nt = "";
    if (!nameOnly)
        nt = " (" + networkType + ")";
    switch (networkType) {
    case TelephonyManager.NETWORK_TYPE_CDMA:
        return "CDMA" + nt;
    case TelephonyManager.NETWORK_TYPE_EDGE:
        return "EDGE" + nt;
    case TelephonyManager.NETWORK_TYPE_GPRS:
        return "GPRS" + nt;
    case TelephonyManager.NETWORK_TYPE_IDEN:
        return "IDEN" + nt;
    case TelephonyManager.NETWORK_TYPE_1xRTT:
        return "1xRTT" + nt;
    case TelephonyManager.NETWORK_TYPE_EHRPD:
        return "EHRPD" + nt;
    case TelephonyManager.NETWORK_TYPE_EVDO_0:
        return "EVDO_0" + nt;
    case TelephonyManager.NETWORK_TYPE_EVDO_A:
        return "EVDO_A" + nt;
    case TelephonyManager.NETWORK_TYPE_EVDO_B:
        return "EVDO_B" + nt;
    case TelephonyManager.NETWORK_TYPE_HSDPA:
        return "HSDPA" + nt;
    case TelephonyManager.NETWORK_TYPE_HSPA:
        return "HSPA" + nt;
    case TelephonyManager.NETWORK_TYPE_HSPAP:
        return "HSPAP" + nt;
    case TelephonyManager.NETWORK_TYPE_HSUPA:
        return "HSUPA" + nt;
    case TelephonyManager.NETWORK_TYPE_UMTS:
        return "UMTS" + nt;
    case TelephonyManager.NETWORK_TYPE_LTE:
        return "LTE" + nt;
    default://from   www  .ja v a 2 s.  c o  m
        return TowerInfo.UNKNOWN + nt;
    }
}

From source file:android_network.hetnet.vpn_service.Util.java

public static String getNetworkTypeName(int networkType) {
    switch (networkType) {
    // 2G/*w w w .ja va 2 s  .  c  o  m*/
    case TelephonyManager.NETWORK_TYPE_1xRTT:
        return "1xRTT";
    case TelephonyManager.NETWORK_TYPE_CDMA:
        return "CDMA";
    case TelephonyManager.NETWORK_TYPE_EDGE:
        return "EDGE";
    case TelephonyManager.NETWORK_TYPE_GPRS:
        return "GPRS";
    case TelephonyManager.NETWORK_TYPE_IDEN:
        return "IDEN";

    // 3G
    case TelephonyManager.NETWORK_TYPE_EHRPD:
        return "EHRPD";
    case TelephonyManager.NETWORK_TYPE_EVDO_0:
        return "EVDO_0";
    case TelephonyManager.NETWORK_TYPE_EVDO_A:
        return "EVDO_A";
    case TelephonyManager.NETWORK_TYPE_EVDO_B:
        return "EVDO_B";
    case TelephonyManager.NETWORK_TYPE_HSDPA:
        return "HSDPA";
    case TelephonyManager.NETWORK_TYPE_HSPA:
        return "HSPA";
    case TelephonyManager.NETWORK_TYPE_HSPAP:
        return "HSPAP";
    case TelephonyManager.NETWORK_TYPE_HSUPA:
        return "HSUPA";
    case TelephonyManager.NETWORK_TYPE_UMTS:
        return "UMTS";
    case NETWORK_TYPE_TD_SCDMA:
        return "TD_SCDMA";

    // 4G
    case TelephonyManager.NETWORK_TYPE_LTE:
        return "LTE";
    case NETWORK_TYPE_IWLAN:
        return "IWLAN";

    default:
        return Integer.toString(networkType);
    }
}

From source file:org.mozilla.mozstumbler.service.stumblerthread.scanners.cellscanner.CellInfo.java

static String getCellRadioTypeName(int networkType) {
    switch (networkType) {
    // If the network is either GSM or any high-data-rate variant of it, the radio
    // field should be specified as `gsm`. This includes `GSM`, `EDGE` and `GPRS`.
    case TelephonyManager.NETWORK_TYPE_GPRS:
    case TelephonyManager.NETWORK_TYPE_EDGE:
        return CELL_RADIO_GSM;

    // If the network is either UMTS or any high-data-rate variant of it, the radio
    // field should be specified as `umts`. This includes `UMTS`, `HSPA`, `HSDPA`,
    // `HSPA+` and `HSUPA`.
    case TelephonyManager.NETWORK_TYPE_UMTS:
    case TelephonyManager.NETWORK_TYPE_HSDPA:
    case TelephonyManager.NETWORK_TYPE_HSUPA:
    case TelephonyManager.NETWORK_TYPE_HSPA:
    case TelephonyManager.NETWORK_TYPE_HSPAP:
        return CELL_RADIO_UMTS;

    case TelephonyManager.NETWORK_TYPE_LTE:
        return CELL_RADIO_LTE;

    // If the network is either CDMA or one of the EVDO variants, the radio
    // field should be specified as `cdma`. This includes `1xRTT`, `CDMA`, `eHRPD`,
    // `EVDO_0`, `EVDO_A`, `EVDO_B`, `IS95A` and `IS95B`.
    case TelephonyManager.NETWORK_TYPE_EVDO_0:
    case TelephonyManager.NETWORK_TYPE_EVDO_A:
    case TelephonyManager.NETWORK_TYPE_EVDO_B:
    case TelephonyManager.NETWORK_TYPE_1xRTT:
    case TelephonyManager.NETWORK_TYPE_EHRPD:
    case TelephonyManager.NETWORK_TYPE_IDEN:
        return CELL_RADIO_CDMA;

    default:// w ww  .  j  a  v  a  2  s. c o m
        Log.e(LOG_TAG, "", new IllegalArgumentException("Unexpected network type: " + networkType));
        return String.valueOf(networkType);
    }
}

From source file:eu.faircode.netguard.Util.java

public static String getNetworkGeneration(int networkType) {
    switch (networkType) {
    case TelephonyManager.NETWORK_TYPE_1xRTT:
    case TelephonyManager.NETWORK_TYPE_CDMA:
    case TelephonyManager.NETWORK_TYPE_EDGE:
    case TelephonyManager.NETWORK_TYPE_GPRS:
    case TelephonyManager.NETWORK_TYPE_IDEN:
    case TelephonyManager.NETWORK_TYPE_GSM:
        return "2G";

    case TelephonyManager.NETWORK_TYPE_EHRPD:
    case TelephonyManager.NETWORK_TYPE_EVDO_0:
    case TelephonyManager.NETWORK_TYPE_EVDO_A:
    case TelephonyManager.NETWORK_TYPE_EVDO_B:
    case TelephonyManager.NETWORK_TYPE_HSDPA:
    case TelephonyManager.NETWORK_TYPE_HSPA:
    case TelephonyManager.NETWORK_TYPE_HSPAP:
    case TelephonyManager.NETWORK_TYPE_HSUPA:
    case TelephonyManager.NETWORK_TYPE_UMTS:
    case TelephonyManager.NETWORK_TYPE_TD_SCDMA:
        return "3G";

    case TelephonyManager.NETWORK_TYPE_LTE:
    case TelephonyManager.NETWORK_TYPE_IWLAN:
        return "4G";

    default://w w  w . ja  v a 2  s.c om
        return "?G";
    }
}

From source file:org.mozilla.mozstumbler.service.scanners.cellscanner.CellInfo.java

static String getCellRadioTypeName(int networkType) {
    switch (networkType) {
    // If the network is either GSM or any high-data-rate variant of it, the radio
    // field should be specified as `gsm`. This includes `GSM`, `EDGE` and `GPRS`.
    case TelephonyManager.NETWORK_TYPE_GPRS:
    case TelephonyManager.NETWORK_TYPE_EDGE:
        return CELL_RADIO_GSM;

    // If the network is either UMTS or any high-data-rate variant of it, the radio
    // field should be specified as `umts`. This includes `UMTS`, `HSPA`, `HSDPA`,
    // `HSPA+` and `HSUPA`.
    case TelephonyManager.NETWORK_TYPE_UMTS:
    case TelephonyManager.NETWORK_TYPE_HSDPA:
    case TelephonyManager.NETWORK_TYPE_HSUPA:
    case TelephonyManager.NETWORK_TYPE_HSPA:
    case TelephonyManager.NETWORK_TYPE_HSPAP:
        return CELL_RADIO_UMTS;

    case TelephonyManager.NETWORK_TYPE_LTE:
        return CELL_RADIO_LTE;

    // If the network is either CDMA or one of the EVDO variants, the radio
    // field should be specified as `cdma`. This includes `1xRTT`, `CDMA`, `eHRPD`,
    // `EVDO_0`, `EVDO_A`, `EVDO_B`, `IS95A` and `IS95B`.
    case TelephonyManager.NETWORK_TYPE_EVDO_0:
    case TelephonyManager.NETWORK_TYPE_EVDO_A:
    case TelephonyManager.NETWORK_TYPE_EVDO_B:
    case TelephonyManager.NETWORK_TYPE_1xRTT:
    case TelephonyManager.NETWORK_TYPE_EHRPD:
    case TelephonyManager.NETWORK_TYPE_IDEN:
        return CELL_RADIO_CDMA;

    default:/*from  w w w .ja v  a  2 s . c  om*/
        Log.e(LOGTAG, "", new IllegalArgumentException("Unexpected network type: " + networkType));
        return String.valueOf(networkType);
    }
}

From source file:org.kei.android.phone.cellhistory.towers.MobileNetworkInfo.java

public static String getTheoreticalSpeed(final NetworkInfo ni) {
    if (ni.getType() == ConnectivityManager.TYPE_MOBILE) {
        switch (ni.getSubtype()) {
        case TelephonyManager.NETWORK_TYPE_1xRTT:
            return "~50-100 kbps";
        case TelephonyManager.NETWORK_TYPE_CDMA:
            return "~14-64 kbps";
        case TelephonyManager.NETWORK_TYPE_EDGE:
            return "~50-100 kbps";
        case TelephonyManager.NETWORK_TYPE_EVDO_0:
            return "~400-1000 kbps";
        case TelephonyManager.NETWORK_TYPE_EVDO_A:
            return "~600-1400 kbps";
        case TelephonyManager.NETWORK_TYPE_GPRS:
            return "~100 kbps";
        case TelephonyManager.NETWORK_TYPE_HSDPA:
            return "~2-14 Mbps";
        case TelephonyManager.NETWORK_TYPE_HSPA:
            return "~700-1700 kbps";
        case TelephonyManager.NETWORK_TYPE_HSUPA:
            return "~1-23 Mbps";
        case TelephonyManager.NETWORK_TYPE_UMTS:
            return "~400-7000 kbps";
        case TelephonyManager.NETWORK_TYPE_EHRPD:
            return "~1-2 Mbps";
        case TelephonyManager.NETWORK_TYPE_EVDO_B:
            return "~5 Mbps";
        case TelephonyManager.NETWORK_TYPE_HSPAP:
            return "~10-20 Mbps";
        case TelephonyManager.NETWORK_TYPE_IDEN:
            return "~25 kbps";
        case TelephonyManager.NETWORK_TYPE_LTE:
            return "~10+ Mbps";
        }// w  ww  .j a v  a2  s .c o m
    }
    return TowerInfo.UNKNOWN;
}

From source file:com.error.hunter.ListenService.java

private StringBuffer getNetworkInfo() {
    StringBuffer info = new StringBuffer();
    StringBuffer backUpInfo = new StringBuffer();

    final ConnectivityManager connMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

    final android.net.NetworkInfo wifi = connMgr.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
    final android.net.NetworkInfo mobile = connMgr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);

    if (wifi.isConnected()) {
        info.append("\nWiFi network state: CONNECTED");
    } else {//  ww  w  . j a v a2 s .c  om
        info.append("\nWiFi network state: NOT CONNECTED");
    }
    backUpInfo = new StringBuffer(info);
    try {
        if (!mobile.isConnected()) {
            switch (mobile.getSubtype()) {
            case TelephonyManager.NETWORK_TYPE_GPRS:
                info.append("\nMobile network state: CONNECTED (GPRS)");
                break;
            case TelephonyManager.NETWORK_TYPE_EDGE:
                info.append("\nMobile network state: CONNECTED (EDGE)");
                break;
            case TelephonyManager.NETWORK_TYPE_CDMA:
                info.append("\nMobile network state: CONNECTED (CDMA)");
                break;
            case TelephonyManager.NETWORK_TYPE_HSPA:
                info.append("\nMobile network state: CONNECTED (HSPA)");
                break;
            case TelephonyManager.NETWORK_TYPE_HSPAP:
                info.append("\nMobile network state: CONNECTED (HSPA+)");
                break;
            case TelephonyManager.NETWORK_TYPE_LTE:
                info.append("\nMobile network state: CONNECTED (LTE)");
                break;
            case TelephonyManager.NETWORK_TYPE_UMTS:
                info.append("\nMobile network state: CONNECTED (UMTS)");
                break;
            }
        } else {
            info.append("\nMobile network state: NOT CONNECTED");
        }
    } catch (Exception e) {
        e.printStackTrace();
        return backUpInfo;
    }
    return info;
}

From source file:org.pixmob.freemobile.netstat.MonitorService.java

/**
 * Update the status bar notification./*from w  w  w. j  av a 2  s  .  c o  m*/
 * @param playSound play notification sound
 * @param phoneStateUpdated if phone state has been updated
 */
private void updateNotification(boolean playSound, boolean phoneStateUpdated) {
    String tickerText, contentText;
    int smallIcon;
    final int notificationPriority = NotificationCompat.PRIORITY_LOW;
    Bitmap largeIcon;
    final PendingIntent contentIntent = openUIPendingIntent;
    boolean airplaneModeOn = false;

    MobileOperator mobOp = MobileOperator.fromString(mobileOperatorId);

    if (mobOp == null) { // Not Free Mobile nor Orange
        if (airplaneModeOn = isAirplaneModeOn()) { // Airplane mode
            tickerText = getString(R.string.stat_airplane_mode_on);
            contentText = getString(R.string.notif_monitoring_disabled);
        } else if (mobileOperatorId == null) { // No signal
            tickerText = getString(R.string.stat_no_signal);
            contentText = getString(R.string.notif_action_open_network_operator_settings);
        } else { // Foreign operator
            tickerText = getString(R.string.stat_connected_to_foreign_mobile_network);
            contentText = getString(R.string.notif_action_open_network_operator_settings);
        }

        smallIcon = android.R.drawable.stat_sys_warning;
        largeIcon = null; // Use small icon as large icon.

    } else { // Free Mobile or Orange detected
        tickerText = String.format(getString(R.string.stat_connected_to_mobile_network), mobOp.toName(this));

        final Integer networkTypeRes = NETWORK_TYPE_STRINGS.get(mobileNetworkType,
                R.string.network_type_unknown);
        contentText = String.format(getString(R.string.mobile_network_type), getString(networkTypeRes));
        if (MobileOperator.FREE_MOBILE.equals(mobOp) && isFemtocell) {
            contentText = getString(R.string.network_free_femtocell, contentText);
        }

        smallIcon = getStatIcon(mobOp);
        largeIcon = getStatLargeIcon(mobOp);
    }

    final NotificationCompat.Builder nBuilder = new NotificationCompat.Builder(getApplicationContext());
    nBuilder.setSmallIcon(smallIcon).setContentTitle(tickerText).setContentText(contentText)
            .setTicker(tickerText).setContentIntent(contentIntent) // always set the content intent - exception fired on GB if null
            .setPriority(notificationPriority).setWhen(0);

    //ACRA bug
    //see : http://stackoverflow.com/questions/15642900/bad-notification-posted-from-package-couldnt-expand-remoteviews
    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.HONEYCOMB_MR2) {
        nBuilder.setLargeIcon(largeIcon);
    }

    if ((prefs != null) && (prefs.getBoolean(SP_KEY_ENABLE_NOTIF_ACTIONS, true))) {
        if (airplaneModeOn && wirelessSettingsPendingIntent != null) {
            nBuilder.addAction(android.R.drawable.ic_menu_preferences,
                    getString(R.string.notif_action_open_wireless_settings), wirelessSettingsPendingIntent);
        } else if (networkOperatorSettingsPendingIntent != null) {
            nBuilder.addAction(android.R.drawable.ic_menu_preferences,
                    getString(R.string.notif_action_open_network_operator_settings),
                    networkOperatorSettingsPendingIntent);
        }
    }

    if (playSound) {
        Log.d(TAG, "Play notification sound");

        // check if we need to trigger LTE alarm
        // network type changed from 3G to LTE
        boolean lteAlarm = ((Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
                && (lastMobileNetworkTypeForLTEDetect != null)
                && (lastMobileNetworkTypeForLTEDetect != TelephonyManager.NETWORK_TYPE_LTE)
                && (mobileNetworkType == TelephonyManager.NETWORK_TYPE_LTE));

        // we have just connected on a femtocell, trigger sound
        boolean femtocellConnection = ((isFemtocell) && (lastIsFemtocell != null) && (!lastIsFemtocell)
                && MobileOperator.FREE_MOBILE.equals(mobOp));

        // other case : trigger FreeMobile 3G alarm if we changed network type from LTE to 3G
        if ((Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) // first, are we using a compatible android version ?
                && (mobOp == MobileOperator.FREE_MOBILE) // second, are we on FreeMobile network ?
                && (!lteAlarm) // third, are not we on LTE network
                && (lastMobileNetworkTypeForLTEDetect != null)
                && (lastMobileNetworkTypeForLTEDetect.equals(TelephonyManager.NETWORK_TYPE_LTE))) { // fourth, and the last mobile network type is LTE
            phoneStateUpdated = true; // trigger 3G alarm
        }

        if ((phoneStateUpdated || lteAlarm || femtocellConnection) && (prefs != null)) {
            String rawSoundUri = null;
            if (lteAlarm) { // we are in LTE alarm case
                Log.d(TAG, "Try to play LTE alarm");
                rawSoundUri = prefs.getString(SP_KEY_STAT_NOTIF_SOUND_4G, null);
            } else if (femtocellConnection) { //we are in fetmocell connection alarm case
                Log.d(TAG, "Try to play Femtocell alarm");
                rawSoundUri = prefs.getString(SP_KEY_STAT_NOTIF_SOUND_FEMTO, null);
            } else { // we are in operator change case
                Log.d(TAG, "Try to play normal operator alarm");
                rawSoundUri = prefs
                        .getString((mobOp == MobileOperator.FREE_MOBILE) ? SP_KEY_STAT_NOTIF_SOUND_FREE_MOBILE
                                : SP_KEY_STAT_NOTIF_SOUND_ORANGE, null);
            }
            if (rawSoundUri != null) {
                final Uri soundUri = Uri.parse(rawSoundUri);
                nBuilder.setSound(soundUri);
            }
        } else if (BuildConfig.DEBUG) {
            Log.d(TAG, "No notification sound to play");
        }
    }

    startForeground(R.string.stat_connected_to_mobile_network, nBuilder.build());
}