Java 类android.telephony.CellInfo 实例源码

public static void loadCellInfo(TelephonyManager tm, Device pDevice) {
    int lCurrentApiVersion = android.os.Build.VERSION.SDK_INT;
    try {
        if (pDevice.mCell == null) {
            pDevice.mCell = new Cell();
        }
        List<CellInfo> cellInfoList = tm.getAllCellInfo();
        if (cellInfoList != null) {
            for (final CellInfo info : cellInfoList) {

                //Network Type
                pDevice.mCell.setNetType(tm.getNetworkType());

                if (info instanceof CellInfoGsm) {
                    final CellSignalStrengthGsm gsm = ((CellInfoGsm) info).getCellSignalStrength();
                    final CellIdentityGsm identityGsm = ((CellInfoGsm) info).getCellIdentity();
                    // Signal Strength
                    pDevice.mCell.setDBM(gsm.getDbm()); // [dBm]
                    // Cell Identity
                    pDevice.mCell.setCID(identityGsm.getCid());
                    pDevice.mCell.setMCC(identityGsm.getMcc());
                    pDevice.mCell.setMNC(identityGsm.getMnc());
                    pDevice.mCell.setLAC(identityGsm.getLac());

                } else if (info instanceof CellInfoCdma) {
                    final CellSignalStrengthCdma cdma = ((CellInfoCdma) info).getCellSignalStrength();
                    final CellIdentityCdma identityCdma = ((CellInfoCdma) info).getCellIdentity();
                    // Signal Strength
                    pDevice.mCell.setDBM(cdma.getDbm());
                    // Cell Identity
                    pDevice.mCell.setCID(identityCdma.getBasestationId());
                    pDevice.mCell.setMNC(identityCdma.getSystemId());
                    pDevice.mCell.setLAC(identityCdma.getNetworkId());
                    pDevice.mCell.setSID(identityCdma.getSystemId());

                } else if (info instanceof CellInfoLte) {
                    final CellSignalStrengthLte lte = ((CellInfoLte) info).getCellSignalStrength();
                    final CellIdentityLte identityLte = ((CellInfoLte) info).getCellIdentity();
                    // Signal Strength
                    pDevice.mCell.setDBM(lte.getDbm());
                    pDevice.mCell.setTimingAdvance(lte.getTimingAdvance());
                    // Cell Identity
                    pDevice.mCell.setMCC(identityLte.getMcc());
                    pDevice.mCell.setMNC(identityLte.getMnc());
                    pDevice.mCell.setCID(identityLte.getCi());

                } else if  (lCurrentApiVersion >= Build.VERSION_CODES.JELLY_BEAN_MR2 && info instanceof CellInfoWcdma) {
                    final CellSignalStrengthWcdma wcdma = ((CellInfoWcdma) info).getCellSignalStrength();
                    final CellIdentityWcdma identityWcdma = ((CellInfoWcdma) info).getCellIdentity();
                    // Signal Strength
                    pDevice.mCell.setDBM(wcdma.getDbm());
                    // Cell Identity
                    pDevice.mCell.setLAC(identityWcdma.getLac());
                    pDevice.mCell.setMCC(identityWcdma.getMcc());
                    pDevice.mCell.setMNC(identityWcdma.getMnc());
                    pDevice.mCell.setCID(identityWcdma.getCid());
                    pDevice.mCell.setPSC(identityWcdma.getPsc());

                } else {
                    Log.i(TAG, mTAG + "Unknown type of cell signal!"
                            + "\n ClassName: " + info.getClass().getSimpleName()
                            + "\n ToString: " + info.toString());
                }
                if (pDevice.mCell.isValid()) {
                    break;
                }
            }
        }
    } catch (NullPointerException npe) {
       Log.e(TAG, mTAG + "loadCellInfo: Unable to obtain cell signal information: ", npe);
    }
}

/**
 * Get current cell info
 * 
 * @return cell information format as {@link String}
 */
public String getCellInfo() {
    if (DBG)
        Log.d(Config.TAG, TAG + "getCellInfo called");
    String ret = null;
    List<CellInfo> listCellInfo = mTelMgr.getAllCellInfo();
    if (listCellInfo != null)
        for (CellInfo a_Info : listCellInfo) {
            if (CellInfoCdma.class.isInstance(a_Info))
                ret = ret + "\n Cell info cdma: " + a_Info.toString();
            else if (CellInfoGsm.class.isInstance(a_Info))
                ret = ret + "\n Cell info gsm: " + a_Info.toString();
            else if (CellInfoLte.class.isInstance(a_Info)) {
                ret = ret + "\n Cell info lte: " + a_Info.toString();
                CellInfoLte cellInfoLte = (CellInfoLte) a_Info;
                CellIdentityLte cellIdentity = cellInfoLte
                        .getCellIdentity();
                Log.d(Config.TAG, TAG + " LTE - " + cellIdentity.getCi()
                        + cellIdentity.getTac() + cellIdentity.getPci());

            } else if (CellInfoWcdma.class.isInstance(a_Info))
                ret = ret + "\n Cell info : wcdma" + a_Info.toString();
        }
    return ret;
}

/**
 * Returns all observed cell information from all radios on the device including the primary
 * and neighboring cells. Returns only the information of cells that are registered to a
 * mobile network. May return {@code null}.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
private static List<CellInfo> getRegisteredCellInfo(Context context) {
    if (!isAPIAvailable(context)) {
        return null;
    }

    TelephonyManager telephonyManager =
            (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
    if (telephonyManager == null) {
        return null;
    }

    List<CellInfo> cellInfos = telephonyManager.getAllCellInfo();
    if (cellInfos == null) {
        return null;
    }

    Iterator<CellInfo> iter = cellInfos.iterator();
    while (iter.hasNext()) {
        if (!iter.next().isRegistered()) {
            iter.remove();
        }
    }
    return cellInfos;
}

/**
 * @return Signal strength (in dbM) from {@link cellInfo}. Returns {@link
 * CellularSignalStrengthError#ERROR_NOT_SUPPORTED} if the signal strength is unavailable.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
private static int getSignalStrengthDbm(CellInfo cellInfo) {
    if (cellInfo instanceof CellInfoCdma) {
        return ((CellInfoCdma) cellInfo).getCellSignalStrength().getDbm();
    }
    if (cellInfo instanceof CellInfoGsm) {
        return ((CellInfoGsm) cellInfo).getCellSignalStrength().getDbm();
    }
    if (cellInfo instanceof CellInfoLte) {
        return ((CellInfoLte) cellInfo).getCellSignalStrength().getDbm();
    }
    if (cellInfo instanceof CellInfoWcdma) {
        return ((CellInfoWcdma) cellInfo).getCellSignalStrength().getDbm();
    }
    return CellularSignalStrengthError.ERROR_NOT_SUPPORTED;
}

/**
 * @return the signal level from {@link cellInfo}. Returns {@link
 * CellularSignalStrengthError#ERROR_NOT_SUPPORTED} if the signal
 * level is unavailable with lower value indicating lower signal strength.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
private static int getSignalStrengthLevel(CellInfo cellInfo) {
    if (cellInfo instanceof CellInfoCdma) {
        return ((CellInfoCdma) cellInfo).getCellSignalStrength().getLevel();
    }
    if (cellInfo instanceof CellInfoGsm) {
        return ((CellInfoGsm) cellInfo).getCellSignalStrength().getLevel();
    }
    if (cellInfo instanceof CellInfoLte) {
        return ((CellInfoLte) cellInfo).getCellSignalStrength().getLevel();
    }
    if (cellInfo instanceof CellInfoWcdma) {
        return ((CellInfoWcdma) cellInfo).getCellSignalStrength().getLevel();
    }
    return CellularSignalStrengthError.ERROR_NOT_SUPPORTED;
}

public CellInformationWrapper(CellInfo cellInfo) {
    setRegistered(cellInfo.isRegistered());
    this.setTimeStamp(cellInfo.getTimeStamp());

    if (cellInfo.getClass().equals(CellInfoLte.class)) {
        setTechnology(Technology.CONNECTION_4G);
        this.ci = new CellIdentity(((CellInfoLte) cellInfo).getCellIdentity());
        this.cs = new CellSignalStrength(((CellInfoLte) cellInfo).getCellSignalStrength());
    }
    else if (cellInfo.getClass().equals(CellInfoWcdma.class)) {
        setTechnology(Technology.CONNECTION_3G);
        this.ci = new CellIdentity(((CellInfoWcdma) cellInfo).getCellIdentity());
        this.cs = new CellSignalStrength(((CellInfoWcdma) cellInfo).getCellSignalStrength());
    }
    else if (cellInfo.getClass().equals(CellInfoGsm.class)) {
        setTechnology(Technology.CONNECTION_2G);
        this.ci = new CellIdentity(((CellInfoGsm) cellInfo).getCellIdentity());
        this.cs = new CellSignalStrength(((CellInfoGsm) cellInfo).getCellSignalStrength());
    }
    else if (cellInfo.getClass().equals(CellInfoCdma.class)) {
        setTechnology(Technology.CONNECTION_2G);
        this.ci = new CellIdentity(((CellInfoCdma) cellInfo).getCellIdentity());
        this.cs = new CellSignalStrength(((CellInfoCdma) cellInfo).getCellSignalStrength());
    }
}

private static CellInfo createCellInfo(VCell cell) {
    if (cell.type == 2) { // CDMA
        CellInfoCdma cdma = mirror.android.telephony.CellInfoCdma.ctor.newInstance();
        CellIdentityCdma identityCdma = mirror.android.telephony.CellInfoCdma.mCellIdentityCdma.get(cdma);
        CellSignalStrengthCdma strengthCdma = mirror.android.telephony.CellInfoCdma.mCellSignalStrengthCdma.get(cdma);
        mirror.android.telephony.CellIdentityCdma.mNetworkId.set(identityCdma, cell.networkId);
        mirror.android.telephony.CellIdentityCdma.mSystemId.set(identityCdma, cell.systemId);
        mirror.android.telephony.CellIdentityCdma.mBasestationId.set(identityCdma, cell.baseStationId);
        mirror.android.telephony.CellSignalStrengthCdma.mCdmaDbm.set(strengthCdma, -74);
        mirror.android.telephony.CellSignalStrengthCdma.mCdmaEcio.set(strengthCdma, -91);
        mirror.android.telephony.CellSignalStrengthCdma.mEvdoDbm.set(strengthCdma, -64);
        mirror.android.telephony.CellSignalStrengthCdma.mEvdoSnr.set(strengthCdma, 7);
        return cdma;
    } else { // GSM
        CellInfoGsm gsm = mirror.android.telephony.CellInfoGsm.ctor.newInstance();
        CellIdentityGsm identityGsm = mirror.android.telephony.CellInfoGsm.mCellIdentityGsm.get(gsm);
        CellSignalStrengthGsm strengthGsm = mirror.android.telephony.CellInfoGsm.mCellSignalStrengthGsm.get(gsm);
        mirror.android.telephony.CellIdentityGsm.mMcc.set(identityGsm, cell.mcc);
        mirror.android.telephony.CellIdentityGsm.mMnc.set(identityGsm, cell.mnc);
        mirror.android.telephony.CellIdentityGsm.mLac.set(identityGsm, cell.lac);
        mirror.android.telephony.CellIdentityGsm.mCid.set(identityGsm, cell.cid);
        mirror.android.telephony.CellSignalStrengthGsm.mSignalStrength.set(strengthGsm, 20);
        mirror.android.telephony.CellSignalStrengthGsm.mBitErrorRate.set(strengthGsm, 0);
        return gsm;
    }
}

public boolean isValid(CellInfo cellInfo) {
    if (cellInfo instanceof CellInfoGsm) {
        CellInfoGsm gsmCellInfo = (CellInfoGsm) cellInfo;
        // If is compatible with API 17 hack (PSC on GSM) return true
        boolean wcdmaApi17Valid = getWcdmaValidator().isValid(gsmCellInfo.getCellIdentity());
        if (wcdmaApi17Valid)
            return true;
        return getGsmValidator().isValid(gsmCellInfo.getCellIdentity());
    }
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2 && cellInfo instanceof CellInfoWcdma) {
        CellInfoWcdma wcdmaCellInfo = (CellInfoWcdma) cellInfo;
        return getWcdmaValidator().isValid(wcdmaCellInfo.getCellIdentity());
    }
    if (cellInfo instanceof CellInfoLte) {
        CellInfoLte lteCellInfo = (CellInfoLte) cellInfo;
        return getLteValidator().isValid(lteCellInfo.getCellIdentity());
    }
    if (cellInfo instanceof CellInfoCdma) {
        CellInfoCdma cdmaCellInfo = (CellInfoCdma) cellInfo;
        return getCdmaValidator().isValid(cdmaCellInfo.getCellIdentity());
    }
    throw new UnsupportedOperationException("Cell identity type not supported `" + cellInfo.getClass().getName() + "`");
}

private void removeDuplicatedCells(List<CellInfo> cells) {
    List<CellInfo> cellsToRemove = new ArrayList<CellInfo>();
    Set<String> uniqueCellKeys = new HashSet<String>();

    for (CellInfo cell : cells) {
        String key = cellIdentityConverter.createCellKey(cell);
        if (uniqueCellKeys.contains(key)) {
            Log.d("removeDuplicatedCells(): Remove duplicated cell: %s", key);
            cellsToRemove.add(cell);
        } else {
            uniqueCellKeys.add(key);
        }
    }

    cells.removeAll(cellsToRemove);
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
private static boolean isApi17CellInfoAvailable(Context context) {
    TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
    List<CellInfo> cells;
    try {
        cells = telephonyManager.getAllCellInfo();
    } catch (SecurityException ex) {
        Log.d("isApi17CellInfoAvailable(): Result = coarse location permission is denied", ex);
        return false;
    }
    if (cells == null || cells.size() == 0) {
        Log.d("isApi17CellInfoAvailable(): Result = no cell info");
        return false;
    }
    CellIdentityValidator validator = new CellIdentityValidator();
    for (CellInfo cell : cells) {
        if (validator.isValid(cell)) {
            Log.d("isApi17CellInfoAvailable(): Result = true");
            return true;
        }
    }
    Log.d("isApi17CellInfoAvailable(): Result = false");
    return false;
}

private void getWcdmaSignalStrength() {
    List<CellInfo> cellInfoList = mTM.getAllCellInfo();

    if (cellInfoList == null) {
        //Log.e(Tag,"getAllCellInfo is null");
        return;
    }
    //Log.e(Tag,"getAllCellInfo size "+cellInfoList.size());

    for (CellInfo cellInfo : cellInfoList) {

        if (!cellInfo.isRegistered())
            continue;

        if (cellInfo instanceof CellInfoWcdma) {
            CellInfoWcdma wcdmaInfo = (CellInfoWcdma) cellInfo;
            wcdma_RSSI = wcdmaInfo.getCellSignalStrength().getDbm();
        }
    }
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
private static Set<VisibleCell> getAllVisibleCellsPostJellyBeanMr1(
        TelephonyManager telephonyManager) {
    Set<VisibleCell> visibleCells = new HashSet<>();
    // Retrieve visible cell networks
    List<CellInfo> cellInfos = telephonyManager.getAllCellInfo();
    if (cellInfos == null) {
        return visibleCells;
    }

    long elapsedTime = sTimeProvider.getElapsedRealtime();
    long currentTime = sTimeProvider.getCurrentTime();
    for (int i = 0; i < cellInfos.size(); i++) {
        CellInfo cellInfo = cellInfos.get(i);
        VisibleCell visibleCell =
                getVisibleCellPostJellyBeanMr1(cellInfo, elapsedTime, currentTime);
        if (visibleCell.radioType() != VisibleCell.UNKNOWN_RADIO_TYPE) {
            visibleCells.add(visibleCell);
        }
    }
    return visibleCells;
}

/**
 * Returns a CellInfo object representing the currently registered base stations, containing
 * its identity fields and signal strength. Null if no base station is active.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
@Nullable
private static CellInfo getActiveCellInfo(TelephonyManager telephonyManager) {
    int numRegisteredCellInfo = 0;
    List<CellInfo> cellInfos = telephonyManager.getAllCellInfo();

    if (cellInfos == null) {
        return null;
    }
    CellInfo result = null;

    for (int i = 0; i < cellInfos.size(); i++) {
        CellInfo cellInfo = cellInfos.get(i);
        if (cellInfo.isRegistered()) {
            numRegisteredCellInfo++;
            if (numRegisteredCellInfo > 1) {
                return null;
            }
            result = cellInfo;
        }
    }
    // Only found one registered cellinfo, so we know which base station was used to measure
    // network quality
    return result;
}

/**
 * @return Signal strength (in dbM) from {@link cellInfo}. Returns {@link
 * CellularSignalStrengthError#ERROR_NOT_SUPPORTED} if the signal strength is unavailable.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
private static int getSignalStrengthDbm(CellInfo cellInfo) {
    if (cellInfo instanceof CellInfoCdma) {
        return ((CellInfoCdma) cellInfo).getCellSignalStrength().getDbm();
    }
    if (cellInfo instanceof CellInfoGsm) {
        return ((CellInfoGsm) cellInfo).getCellSignalStrength().getDbm();
    }
    if (cellInfo instanceof CellInfoLte) {
        return ((CellInfoLte) cellInfo).getCellSignalStrength().getDbm();
    }
    if (cellInfo instanceof CellInfoWcdma) {
        return ((CellInfoWcdma) cellInfo).getCellSignalStrength().getDbm();
    }
    return CellularSignalStrengthError.ERROR_NOT_SUPPORTED;
}

/**
 * @return the signal level from {@link cellInfo}. Returns {@link
 * CellularSignalStrengthError#ERROR_NOT_SUPPORTED} if the signal
 * level is unavailable with lower value indicating lower signal strength.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
private static int getSignalStrengthLevel(CellInfo cellInfo) {
    if (cellInfo instanceof CellInfoCdma) {
        return ((CellInfoCdma) cellInfo).getCellSignalStrength().getLevel();
    }
    if (cellInfo instanceof CellInfoGsm) {
        return ((CellInfoGsm) cellInfo).getCellSignalStrength().getLevel();
    }
    if (cellInfo instanceof CellInfoLte) {
        return ((CellInfoLte) cellInfo).getCellSignalStrength().getLevel();
    }
    if (cellInfo instanceof CellInfoWcdma) {
        return ((CellInfoWcdma) cellInfo).getCellSignalStrength().getLevel();
    }
    return CellularSignalStrengthError.ERROR_NOT_SUPPORTED;
}

@Override
public void onCellInfoChanged(List<CellInfo> cellInfo)
{
    super.onCellInfoChanged(cellInfo);

    PPApplication.logE("PhoneStateScanner.onCellInfoChanged", "telephonyManager="+telephonyManager);
    CallsCounter.logCounter(context, "PhoneStateScanner.onCellInfoChanged", "PhoneStateScanner_onCellInfoChanged");

    if (cellInfo == null)
        getAllCellInfo();
    else
        getAllCellInfo(cellInfo);

    if (registeredCell != Integer.MAX_VALUE) {
        DatabaseHandler db = DatabaseHandler.getInstance(context);
        db.updateMobileCellLastConnectedTime(registeredCell, lastConnectedTime);
    }

    doAutoRegistration();
    sendBroadcast();
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
public static void fill(TheDictionary map, CellInfo value) throws Exception {
    if (value != null) {
        map.put("time_stamp", value.getTimeStamp());
        map.put("registered", value.isRegistered());
        if (value instanceof CellInfoCdma) {
            fill(map, ((CellInfoCdma) value).getCellIdentity());
            fill(map, ((CellInfoCdma) value).getCellSignalStrength());
        } else if (value instanceof CellInfoGsm) {
            fill(map, ((CellInfoGsm) value).getCellIdentity());
            fill(map, ((CellInfoGsm) value).getCellSignalStrength());
        } else if (value instanceof CellInfoWcdma) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
                fill(map, ((CellInfoWcdma) value).getCellIdentity());
                fill(map, ((CellInfoWcdma) value).getCellSignalStrength());
            }
        } else if (value instanceof CellInfoLte) {
            fill(map, ((CellInfoLte) value).getCellIdentity());
            fill(map, ((CellInfoLte) value).getCellSignalStrength());
        } else {
            map.put("class", value.getClass().getName());
            map.put("string", value.toString());
        }
    }
}

/**
 * @return Signal strength (in dbM) for the currently registered cellular network. Returns
 * {@link CellularSignalStrengthError#ERROR_NOT_SUPPORTED} if the signal strength is
 * unavailable or if there are multiple cellular radios on the device.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
@CalledByNative
public static int getSignalStrengthDbm(Context context) {
    List<CellInfo> cellInfos = getRegisteredCellInfo(context);
    return cellInfos == null || cellInfos.size() != 1
            ? CellularSignalStrengthError.ERROR_NOT_SUPPORTED
            : getSignalStrengthDbm(cellInfos.get(0));
}

/**
 * @return the signal strength level (between 0 and 4, both inclusive) for the currently
 * registered cellular network with lower value indicating lower signal strength. Returns
 * {@link CellularSignalStrengthError#ERROR_NOT_SUPPORTED} if the signal strength level is
 * unavailable or if there are multiple cellular radios on the device.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
@CalledByNative
public static int getSignalStrengthLevel(Context context) {
    List<CellInfo> cellInfos = getRegisteredCellInfo(context);
    return cellInfos == null || cellInfos.size() != 1
            ? CellularSignalStrengthError.ERROR_NOT_SUPPORTED
            : getSignalStrengthLevel(cellInfos.get(0));
}

public ArrayList<CommonCellInfo> toCellularInfo(List<CellInfo> cellInfoList) {
    final ArrayList<CommonCellInfo> res = new ArrayList<CommonCellInfo>();
    if (cellInfoList == null) {
        return res;
    }

    for (CellInfo cellInfo : cellInfoList) {
        if (!cellInfo.isRegistered()) {
            continue;
        }
        //Wcdma : Wideband Code Division Multiple Access : multiplexage par code à large bande
        if (cellInfo instanceof CellInfoWcdma) {
            CellInfoWcdma cellInfoWcdma = (CellInfoWcdma) cellInfo;
            res.add(toCellularInfo(cellInfoWcdma));
        }

        if (cellInfo instanceof CellInfoGsm) {
            final CellInfoGsm cellInfoGsm = (CellInfoGsm) cellInfo;
            res.add(toCellularInfo(cellInfoGsm));
        }

        if (cellInfo instanceof CellInfoLte) {
            final CellInfoLte cellInfoLte = (CellInfoLte) cellInfo;
            res.add(toCellularInfo(cellInfoLte));
        }

        // TODO: gérer CDMA
    }
    return res;
}

/**
 * Returns all observed cell information from all radios on the device including the primary and
 * neighboring cells. Calling this method does not trigger a call to onCellInfoChanged(), or change
 * the rate at which onCellInfoChanged() is called.
 */
private void getAllCellInfos(){
    if(_telephonyManager != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        final List<CellInfo> cellInfos = _telephonyManager.getAllCellInfo();
        processCellInfos(cellInfos);
    }
    else {
        Log.w(TAG, "Unable to provide cell info due to version restriction");
    }
}

private static void processCellInfos(List<CellInfo> cellInfos){
    if(cellInfos != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){

        for(CellInfo cellInfo : cellInfos){

            if(cellInfo instanceof  CellInfoWcdma){
                final CellInfoWcdma cellInfoWcdma = (CellInfoWcdma) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoWCDMAJSON(cellInfoWcdma, _returnSignalStrength));
            }
            if(cellInfo instanceof CellInfoGsm){
                final CellInfoGsm cellInfoGsm = (CellInfoGsm) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoGSMJSON(cellInfoGsm, _returnSignalStrength));
            }
            if(cellInfo instanceof  CellInfoCdma){
                final CellInfoCdma cellIdentityCdma = (CellInfoCdma) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoCDMAJSON(cellIdentityCdma, _returnSignalStrength));
            }
            if(cellInfo instanceof  CellInfoLte){
                final CellInfoLte cellInfoLte = (CellInfoLte) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoLTEJSON(cellInfoLte, _returnSignalStrength));
            }

            Log.d(TAG,cellInfo.toString());
        }
    }
    else {
        Log.e(TAG, "CellInfoLocation returning null. Is it supported on this phone?");

        // There are several reasons as to why cell location data would be null.
        // * could be an older device running an unsupported version of the Android OS
        // * could be a device that doesn't support this capability.
        // * could be incorrect permissions: ACCESS_COARSE_LOCATION
        sendCallback(PluginResult.Status.ERROR,
                JSONHelper.errorJSON(CELLINFO_PROVIDER, ErrorMessages.CELL_DATA_IS_NULL()));
    }
}

/**
 * Returns all observed cell information from all radios on the device including the primary and
 * neighboring cells. Calling this method does not trigger a call to onCellInfoChanged(), or change
 * the rate at which onCellInfoChanged() is called.
 */
private void getAllCellInfos(){
    if(_telephonyManager != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        final List<CellInfo> cellInfos = _telephonyManager.getAllCellInfo();
        processCellInfos(cellInfos);
    }
    else {
        Log.w(TAG, "Unable to provide cell info due to version restriction");
    }
}

private static void processCellInfos(List<CellInfo> cellInfos){
    if(cellInfos != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){

        for(CellInfo cellInfo : cellInfos){

            if(cellInfo instanceof  CellInfoWcdma){
                final CellInfoWcdma cellInfoWcdma = (CellInfoWcdma) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoWCDMAJSON(cellInfoWcdma, _returnSignalStrength));
            }
            if(cellInfo instanceof CellInfoGsm){
                final CellInfoGsm cellInfoGsm = (CellInfoGsm) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoGSMJSON(cellInfoGsm, _returnSignalStrength));
            }
            if(cellInfo instanceof  CellInfoCdma){
                final CellInfoCdma cellIdentityCdma = (CellInfoCdma) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoCDMAJSON(cellIdentityCdma, _returnSignalStrength));
            }
            if(cellInfo instanceof  CellInfoLte){
                final CellInfoLte cellInfoLte = (CellInfoLte) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoLTEJSON(cellInfoLte, _returnSignalStrength));
            }

            Log.d(TAG,cellInfo.toString());
        }
    }
    else {
        Log.e(TAG, "CellInfoLocation returning null. Is it supported on this phone?");

        // There are several reasons as to why cell location data would be null.
        // * could be an older device running an unsupported version of the Android OS
        // * could be a device that doesn't support this capability.
        // * could be incorrect permissions: ACCESS_COARSE_LOCATION
        sendCallback(PluginResult.Status.ERROR,
                JSONHelper.errorJSON(CELLINFO_PROVIDER, ErrorMessages.CELL_DATA_IS_NULL()));
    }
}

/**
 * Returns all observed cell information from all radios on the device including the primary and
 * neighboring cells. Calling this method does not trigger a call to onCellInfoChanged(), or change
 * the rate at which onCellInfoChanged() is called.
 */
private void getAllCellInfos(){
    if(_telephonyManager != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        final List<CellInfo> cellInfos = _telephonyManager.getAllCellInfo();
        processCellInfos(cellInfos);
    }
    else {
        Log.w(TAG, "Unable to provide cell info due to version restriction");
    }
}

private static void processCellInfos(List<CellInfo> cellInfos){
    if(cellInfos != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){

        for(CellInfo cellInfo : cellInfos){

            if(cellInfo instanceof  CellInfoWcdma){
                final CellInfoWcdma cellInfoWcdma = (CellInfoWcdma) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoWCDMAJSON(cellInfoWcdma, _returnSignalStrength));
            }
            if(cellInfo instanceof CellInfoGsm){
                final CellInfoGsm cellInfoGsm = (CellInfoGsm) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoGSMJSON(cellInfoGsm, _returnSignalStrength));
            }
            if(cellInfo instanceof  CellInfoCdma){
                final CellInfoCdma cellIdentityCdma = (CellInfoCdma) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoCDMAJSON(cellIdentityCdma, _returnSignalStrength));
            }
            if(cellInfo instanceof  CellInfoLte){
                final CellInfoLte cellInfoLte = (CellInfoLte) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoLTEJSON(cellInfoLte, _returnSignalStrength));
            }

            Log.d(TAG,cellInfo.toString());
        }
    }
    else {
        Log.e(TAG, "CellInfoLocation returning null. Is it supported on this phone?");

        // There are several reasons as to why cell location data would be null.
        // * could be an older device running an unsupported version of the Android OS
        // * could be a device that doesn't support this capability.
        // * could be incorrect permissions: ACCESS_COARSE_LOCATION
        sendCallback(PluginResult.Status.ERROR,
                JSONHelper.errorJSON(CELLINFO_PROVIDER, ErrorMessages.CELL_DATA_IS_NULL()));
    }
}

@Override
public Object call(Object who, Method method, Object... args) throws Throwable {
    if (isFakeLocationEnable()) {
        List<VCell> cells = VirtualLocationManager.get().getAllCell(getAppUserId(), getAppPkg());
        if (cells != null) {
            List<CellInfo> result = new ArrayList<CellInfo>();
            for (VCell cell : cells) {
                result.add(createCellInfo(cell));
            }
            return result;
        }

    }
    return super.call(who, method, args);
}

/**
 * Returns all observed cell information from all radios on the device including the primary and
 * neighboring cells. Calling this method does not trigger a call to onCellInfoChanged(), or change
 * the rate at which onCellInfoChanged() is called.
 */
private void getAllCellInfos(){
    if(_telephonyManager != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        final List<CellInfo> cellInfos = _telephonyManager.getAllCellInfo();
        processCellInfos(cellInfos);
    }
    else {
        Log.w(TAG, "Unable to provide cell info due to version restriction");
    }
}

private static void processCellInfos(List<CellInfo> cellInfos){
    if(cellInfos != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){

        for(CellInfo cellInfo : cellInfos){

            if(cellInfo instanceof  CellInfoWcdma){
                final CellInfoWcdma cellInfoWcdma = (CellInfoWcdma) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoWCDMAJSON(cellInfoWcdma, _returnSignalStrength));
            }
            if(cellInfo instanceof CellInfoGsm){
                final CellInfoGsm cellInfoGsm = (CellInfoGsm) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoGSMJSON(cellInfoGsm, _returnSignalStrength));
            }
            if(cellInfo instanceof  CellInfoCdma){
                final CellInfoCdma cellIdentityCdma = (CellInfoCdma) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoCDMAJSON(cellIdentityCdma, _returnSignalStrength));
            }
            if(cellInfo instanceof  CellInfoLte){
                final CellInfoLte cellInfoLte = (CellInfoLte) cellInfo;
                sendCallback(PluginResult.Status.OK,
                        JSONHelper.cellInfoLTEJSON(cellInfoLte, _returnSignalStrength));
            }

            Log.d(TAG,cellInfo.toString());
        }
    }
    else {
        Log.e(TAG, "CellInfoLocation returning null. Is it supported on this phone?");

        // There are several reasons as to why cell location data would be null.
        // * could be an older device running an unsupported version of the Android OS
        // * could be a device that doesn't support this capability.
        // * could be incorrect permissions: ACCESS_COARSE_LOCATION
        sendCallback(PluginResult.Status.ERROR,
                JSONHelper.errorJSON(CELLINFO_PROVIDER, ErrorMessages.CELL_DATA_IS_NULL()));
    }
}

public synchronized void setLastCellInfo(List<CellInfo> cellInfo) {
    Log.d("setLastCellInfo(): Cell info updated: %s ", cellInfo);
    this.lastCellInfo = cellInfo;
    this.lastNetworkType = NetworkGroup.Unknown;
    this.lastOperatorName = null;
    notifyIfReadyToProcess();
}

public static void loadCellInfo(TelephonyManager tm, Device pDevice) {
    int lCurrentApiVersion = Build.VERSION.SDK_INT;
    try {
        if (pDevice.cell == null) {
            pDevice.cell = new Cell();
        }
        List<CellInfo> cellInfoList = tm.getAllCellInfo();
        if (cellInfoList != null) {
            for (final CellInfo info : cellInfoList) {

                //Network Type
                pDevice.cell.setNetType(tm.getNetworkType());

                if (info instanceof CellInfoGsm) {
                    final CellSignalStrengthGsm gsm = ((CellInfoGsm) info).getCellSignalStrength();
                    final CellIdentityGsm identityGsm = ((CellInfoGsm) info).getCellIdentity();
                    // Signal Strength
                    pDevice.cell.setDbm(gsm.getDbm()); // [dBm]
                    // Cell Identity
                    pDevice.cell.setCellId(identityGsm.getCid());
                    pDevice.cell.setMobileCountryCode(identityGsm.getMcc());
                    pDevice.cell.setMobileNetworkCode(identityGsm.getMnc());
                    pDevice.cell.setLocationAreaCode(identityGsm.getLac());

                } else if (info instanceof CellInfoCdma) {
                    final CellSignalStrengthCdma cdma = ((CellInfoCdma) info).getCellSignalStrength();
                    final CellIdentityCdma identityCdma = ((CellInfoCdma) info).getCellIdentity();
                    // Signal Strength
                    pDevice.cell.setDbm(cdma.getDbm());
                    // Cell Identity
                    pDevice.cell.setCellId(identityCdma.getBasestationId());
                    pDevice.cell.setMobileNetworkCode(identityCdma.getSystemId());
                    pDevice.cell.setLocationAreaCode(identityCdma.getNetworkId());
                    pDevice.cell.setSid(identityCdma.getSystemId());

                } else if (info instanceof CellInfoLte) {
                    final CellSignalStrengthLte lte = ((CellInfoLte) info).getCellSignalStrength();
                    final CellIdentityLte identityLte = ((CellInfoLte) info).getCellIdentity();
                    // Signal Strength
                    pDevice.cell.setDbm(lte.getDbm());
                    pDevice.cell.setTimingAdvance(lte.getTimingAdvance());
                    // Cell Identity
                    pDevice.cell.setMobileCountryCode(identityLte.getMcc());
                    pDevice.cell.setMobileNetworkCode(identityLte.getMnc());
                    pDevice.cell.setCellId(identityLte.getCi());

                } else if  (lCurrentApiVersion >= Build.VERSION_CODES.JELLY_BEAN_MR2 && info instanceof CellInfoWcdma) {
                    final CellSignalStrengthWcdma wcdma = ((CellInfoWcdma) info).getCellSignalStrength();
                    final CellIdentityWcdma identityWcdma = ((CellInfoWcdma) info).getCellIdentity();
                    // Signal Strength
                    pDevice.cell.setDbm(wcdma.getDbm());
                    // Cell Identity
                    pDevice.cell.setLocationAreaCode(identityWcdma.getLac());
                    pDevice.cell.setMobileCountryCode(identityWcdma.getMcc());
                    pDevice.cell.setMobileNetworkCode(identityWcdma.getMnc());
                    pDevice.cell.setCellId(identityWcdma.getCid());
                    pDevice.cell.setPrimaryScramblingCode(identityWcdma.getPsc());

                } else {
                    log.info("Unknown type of cell signal!"
                            + "\n ClassName: " + info.getClass().getSimpleName()
                            + "\n ToString: " + info.toString());
                }
                if (pDevice.cell.isValid()) {
                    break;
                }
            }
        }
    } catch (NullPointerException npe) {
        log.error("loadCellInfo: Unable to obtain cell signal information: ", npe);
    }
}

@TargetApi(17) @Override
public void onCellInfoChanged(List<CellInfo> cellinfos) {
    super.onCellInfoChanged(cellinfos);
    try {
        if (!owner.isMMCActiveOrRunning())
            return;
        if (tmLastCellInfoUpdate + 60000 > System.currentTimeMillis() && cellinfos != null && cellinfos.size() > 0 && cellinfos.get(0).toString().equals(lastCellInfoString))
            return;
        if (cellinfos != null && cellinfos.size() > 0)
            lastCellInfoString = cellinfos.get(0).toString();
        else
            lastCellInfoString = "";    
        tmLastCellInfoUpdate = System.currentTimeMillis();

        if (mPhoneState.getNetworkType() == mPhoneState.NETWORK_NEWTYPE_LTE)
        {
            String neighbors = owner.getCellHistory().updateLteNeighborHistory(cellinfos);
            if (neighbors != null)
            {
                owner.getIntentDispatcher().updateLTEIdentity (neighbors);
                owner.getReportManager().setNeighbors(neighbors);
            }

        }

        if (cellinfos != null && cellinfos.size() > 0 && cellinfos.get(0) != null)
            for (int i=0; i<cellinfos.size(); i++)
            {
                //MMCLogger.logToFile(MMCLogger.Level.DEBUG, TAG, "onCellInfoChanged", "cellinfos["+i+"]: " + cellinfos.get(i).toString());
                if (mPhoneState.getNetworkType() == mPhoneState.NETWORK_NEWTYPE_LTE)
                {
                    if (cellinfos.get(i) instanceof CellInfoLte)
                    {
                        CellIdentityLte cellIDLte = ((CellInfoLte)cellinfos.get(i)).getCellIdentity();
                        //MMCLogger.logToFile(MMCLogger.Level.DEBUG, TAG, "onCellInfoChanged", "Reflected: " + listCellInfoFields(cellIDLte));
                    }
                }
            }
        //else
        //  MMCLogger.logToFile(MMCLogger.Level.ERROR, TAG, "onCellInfoChanged", "cellinfos: null");

    } catch (Exception intEx){
        LoggerUtil.logToFile(LoggerUtil.Level.ERROR, TAG, "onCellInfoChanged", "InterruptedException: " + intEx.getMessage());
    } 
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
private static VisibleCell getConnectedCellPostJellyBeanMr1(
        Context context, TelephonyManager telephonyManager) {
    if (!hasLocationPermission(context)) {
        return VisibleCell.UNKNOWN_MISSING_LOCATION_PERMISSION_VISIBLE_CELL;
    }
    CellInfo cellInfo = getActiveCellInfo(telephonyManager);
    return getVisibleCellPostJellyBeanMr1(
            cellInfo, sTimeProvider.getElapsedRealtime(), sTimeProvider.getCurrentTime());
}

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
private static VisibleCell getVisibleCellPostJellyBeanMr1(
        @Nullable CellInfo cellInfo, long elapsedTime, long currentTime) {
    if (cellInfo == null) {
        return VisibleCell.UNKNOWN_VISIBLE_CELL;
    }
    long cellInfoAge = elapsedTime - TimeUnit.NANOSECONDS.toMillis(cellInfo.getTimeStamp());
    long cellTimestamp = currentTime - cellInfoAge;
    if (cellInfo instanceof CellInfoCdma) {
        CellIdentityCdma cellIdentityCdma = ((CellInfoCdma) cellInfo).getCellIdentity();
        return VisibleCell.builder(VisibleCell.CDMA_RADIO_TYPE)
                .setCellId(cellIdentityCdma.getBasestationId())
                .setLocationAreaCode(cellIdentityCdma.getNetworkId())
                .setMobileNetworkCode(cellIdentityCdma.getSystemId())
                .setTimestamp(cellTimestamp)
                .build();
    }
    if (cellInfo instanceof CellInfoGsm) {
        CellIdentityGsm cellIdentityGsm = ((CellInfoGsm) cellInfo).getCellIdentity();
        return VisibleCell.builder(VisibleCell.GSM_RADIO_TYPE)
                .setCellId(cellIdentityGsm.getCid())
                .setLocationAreaCode(cellIdentityGsm.getLac())
                .setMobileCountryCode(cellIdentityGsm.getMcc())
                .setMobileNetworkCode(cellIdentityGsm.getMnc())
                .setTimestamp(cellTimestamp)
                .build();
    }
    if (cellInfo instanceof CellInfoLte) {
        CellIdentityLte cellIdLte = ((CellInfoLte) cellInfo).getCellIdentity();
        return VisibleCell.builder(VisibleCell.LTE_RADIO_TYPE)
                .setCellId(cellIdLte.getCi())
                .setMobileCountryCode(cellIdLte.getMcc())
                .setMobileNetworkCode(cellIdLte.getMnc())
                .setPhysicalCellId(cellIdLte.getPci())
                .setTrackingAreaCode(cellIdLte.getTac())
                .setTimestamp(cellTimestamp)
                .build();
    }
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2
            && cellInfo instanceof CellInfoWcdma) {
        // CellInfoWcdma is only usable JB MR2 upwards.
        CellIdentityWcdma cellIdentityWcdma = ((CellInfoWcdma) cellInfo).getCellIdentity();
        return VisibleCell.builder(VisibleCell.WCDMA_RADIO_TYPE)
                .setCellId(cellIdentityWcdma.getCid())
                .setLocationAreaCode(cellIdentityWcdma.getLac())
                .setMobileCountryCode(cellIdentityWcdma.getMcc())
                .setMobileNetworkCode(cellIdentityWcdma.getMnc())
                .setPrimaryScramblingCode(cellIdentityWcdma.getPsc())
                .setTimestamp(cellTimestamp)
                .build();
    }
    return VisibleCell.UNKNOWN_VISIBLE_CELL;
}

/**
 * @return Signal strength (in dbM) for the currently registered cellular network. Returns
 * {@link CellularSignalStrengthError#ERROR_NOT_SUPPORTED} if the signal strength is
 * unavailable or if there are multiple cellular radios on the device.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
@CalledByNative
public static int getSignalStrengthDbm() {
    List<CellInfo> cellInfos = getRegisteredCellInfo();
    return cellInfos == null || cellInfos.size() != 1
            ? CellularSignalStrengthError.ERROR_NOT_SUPPORTED
            : getSignalStrengthDbm(cellInfos.get(0));
}

/**
 * @return the signal strength level (between 0 and 4, both inclusive) for the currently
 * registered cellular network with lower value indicating lower signal strength. Returns
 * {@link CellularSignalStrengthError#ERROR_NOT_SUPPORTED} if the signal strength level is
 * unavailable or if there are multiple cellular radios on the device.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
@CalledByNative
public static int getSignalStrengthLevel() {
    List<CellInfo> cellInfos = getRegisteredCellInfo();
    return cellInfos == null || cellInfos.size() != 1
            ? CellularSignalStrengthError.ERROR_NOT_SUPPORTED
            : getSignalStrengthLevel(cellInfos.get(0));
}

/**
 * Returns all observed cell information from all radios on the device including the primary
 * and neighboring cells. Returns only the information of cells that are registered to a
 * mobile network. May return {@code null}.
 */
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
private static List<CellInfo> getRegisteredCellInfo() {
    if (!isAPIAvailable()) {
        return null;
    }

    TelephonyManager telephonyManager =
            (TelephonyManager) ContextUtils.getApplicationContext().getSystemService(
                    Context.TELEPHONY_SERVICE);
    if (telephonyManager == null) {
        return null;
    }

    List<CellInfo> cellInfos = telephonyManager.getAllCellInfo();
    if (cellInfos == null) {
        return null;
    }

    Iterator<CellInfo> iter = cellInfos.iterator();
    while (iter.hasNext()) {
        if (!iter.next().isRegistered()) {
            iter.remove();
        }
    }
    return cellInfos;
}

public static int getCellStatus(Context c){
    int z = 0;
    try {
        TelephonyManager tm = (TelephonyManager) c.getSystemService(Context.TELEPHONY_SERVICE);
        List<CellInfo> cellInfoList = tm.getAllCellInfo();
        //This means cell is off
        if (cellInfoList.isEmpty()) {
            z = 1;
        }
        return z;
    } catch(SecurityException e){
        Log.e("RadioControl","Unable to get Location Permission",e);
    }
    return z;
}

/**
 * Call this in {@link org.microg.nlp.api.LocationBackendService#onOpen()}.
 */
@Override
public synchronized void onOpen() {
    super.onOpen();

    if (phoneStateListener == null) {
        Handler mainHandler = new Handler(context.getMainLooper());
        mainHandler.post(new Runnable() {
            @Override
            public void run() {
                phoneStateListener = new PhoneStateListener() {

                    @Override
                    public void onCellInfoChanged(List<CellInfo> cellInfo) {
                        if (cellInfo != null && !cellInfo.isEmpty()) {
                            onCellsChanged(cellInfo);
                        } else if (supportsCellInfoChanged) {
                            supportsCellInfoChanged = false;
                            onSignalStrengthsChanged(null);
                        }
                    }

                    @Override
                    public void onSignalStrengthsChanged(SignalStrength signalStrength) {
                        if (!supportsCellInfoChanged) {
                            fallbackScan();
                        }
                    }
                };
                registerPhoneStateListener();
            }
        });
    } else {
        registerPhoneStateListener();
    }
}