Odczytywanie stanu połączenia z siecią GSM (telefonia)

0. Niezbędne uprawnienie READ_PHONE_STATE

W pliku manifestu, w obrębie elementu manifest:

<uses-permission android:name="android.permission.READ_PHONE_STATE" />


1. W Android >=6 należy zdobyć te uprawnienia dla procesu:

public static final int REQUEST_READ_PHONE_STATE = 0;

    static private boolean zdobądźUprawnieniaDoOdczytaniaWłasnościGSM(Activity activity)
    {
        int permissionCheck = ContextCompat.checkSelfPermission(activity, Manifest.permission.READ_PHONE_STATE);
        if (permissionCheck != PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(activity, new String[]{Manifest.permission.READ_PHONE_STATE}, REQUEST_READ_PHONE_STATE);
            return false;
        }
        else
        {
            //Toast.makeText(activity.getApplicationContext(), "Aplikacja posiada już uprawnienia do odczytania stanu telefonu", Toast.LENGTH_LONG).show();
            return true;
        }
    }

Po przydzieleniu uprawnień (okno dialogowe) wywołana zostanie metoda:

    @Override
    public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
        switch (requestCode) {
            case REQUEST_READ_PHONE_STATE:
                if ((grantResults.length > 0) && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {
                    //Toast.makeText(getApplicationContext(), "Udzielono uprawnienia do odczytania stanu telefonu", Toast.LENGTH_LONG).show();
                    odswiezListe();
                }
                break;

            default:
                break;
        }
    }

2. Odczytanie stanu sieci:

    static private UrzadzenieInfo odczytajSiećTelefoniczną(Activity activity, SignalStrength signalStrength)
    {
        UrzadzenieInfo gsmInfo = new UrzadzenieInfo();
        gsmInfo.typInformacji=TypInformacji.Inne;
        gsmInfo.nazwa="Sieć GSM";

        TelephonyManager tm = (TelephonyManager) activity.getSystemService(TELEPHONY_SERVICE);	//menadzer gsm
        //GsmCellLocation loc = (GsmCellLocation) tm.getCellLocation();	//lokalizacja telefonu przez gsm

        if(tm != null)
        {
            gsmInfo.opis = "IMEI: "+tm.getDeviceId();
            //gsmInfo.opis = "\nID: "+loc.getCid();
            gsmInfo.opis += "\nOperator: "+tm.getNetworkOperatorName();
            String typSieciTelefonicznej = "";
            switch(tm.getNetworkType())
            {
                case TelephonyManager.NETWORK_TYPE_1xRTT: typSieciTelefonicznej="1xRTT"; break;
                case TelephonyManager.NETWORK_TYPE_CDMA: typSieciTelefonicznej="CDMA"; break;
                case TelephonyManager.NETWORK_TYPE_EDGE: typSieciTelefonicznej="EDGE"; break;
                case TelephonyManager.NETWORK_TYPE_EHRPD: typSieciTelefonicznej="eHRPD"; break;
                case TelephonyManager.NETWORK_TYPE_EVDO_0: typSieciTelefonicznej="EVDO rev. 0"; break;
                case TelephonyManager.NETWORK_TYPE_EVDO_A: typSieciTelefonicznej="EVDO rev. A"; break;
                case TelephonyManager.NETWORK_TYPE_EVDO_B: typSieciTelefonicznej="EVDO rev. B"; break;
                case TelephonyManager.NETWORK_TYPE_GPRS: typSieciTelefonicznej="GPRS"; break;
                case TelephonyManager.NETWORK_TYPE_HSDPA: typSieciTelefonicznej="HSDPA"; break;
                case TelephonyManager.NETWORK_TYPE_HSPA: typSieciTelefonicznej="HSPA"; break;
                case TelephonyManager.NETWORK_TYPE_HSPAP: typSieciTelefonicznej="HSPA+"; break;
                case TelephonyManager.NETWORK_TYPE_HSUPA: typSieciTelefonicznej="HSUPA"; break;
                case TelephonyManager.NETWORK_TYPE_IDEN: typSieciTelefonicznej="iDen"; break;
                case TelephonyManager.NETWORK_TYPE_LTE: typSieciTelefonicznej="LTE"; break;
                case TelephonyManager.NETWORK_TYPE_UMTS: typSieciTelefonicznej="UMTS"; break;
                case TelephonyManager.NETWORK_TYPE_UNKNOWN: typSieciTelefonicznej="Unknown"; break;
            }
            gsmInfo.opis += "\nTyp sieci: "+typSieciTelefonicznej;
            gsmInfo.opis += "\nNumer telefonu: " + tm.getLine1Number();
            String stanPołączenia = "";
            switch(tm.getCallState())
            {
                case TelephonyManager.CALL_STATE_RINGING:
                    stanPołączenia = "Dzwonienie";
                    break;
                case TelephonyManager.CALL_STATE_OFFHOOK:
                    stanPołączenia = "Zajęty";
                    break;
                case TelephonyManager.CALL_STATE_IDLE:
                    stanPołączenia = "Wolny";
                    break;
            }
            gsmInfo.opis += "\nStan połączenia: " + stanPołączenia;
            if(signalStrength != null)
                gsmInfo.polozeniePaska = signalStrength.getLevel() * 25; //0-4, wymaga API 22 -> trzeba zwiększyć
            else gsmInfo.polozeniePaska = -1;
        }
        else
        {
            //nie ma połączenia
            gsmInfo.polozeniePaska=-1;
        }

        return gsmInfo;
    }

3. Uruchomienie w metodzie odswiezListe:

        if(zdobądźUprawnieniaDoOdczytaniaWłasnościGSM(this))
        {
            listaUrzadzen.add(odczytajSiećTelefoniczną(this, null)); //na razie bez siły sygnału
        }

4. Nasłuchiwacz do monitorowania siły sygnału:

    PhoneStateListener phoneStateListener = null;
    SignalStrength signalStrength = null;

Rozwinięcie kodu z metody odswiezListe

        if(zdobądźUprawnieniaDoOdczytaniaWłasnościGSM(this))
        {
            if(phoneStateListener == null)
            {
                phoneStateListener = new PhoneStateListener()
                {
                    @Override
                    public void onSignalStrengthsChanged(SignalStrength _signalStrength)
                    {
                        signalStrength = _signalStrength;
                        odswiezListe();
                    }
                };
                TelephonyManager tm = (TelephonyManager) this.getSystemService(TELEPHONY_SERVICE);
                tm.listen(phoneStateListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);
            }

            listaUrzadzen.add(odczytajSiećTelefoniczną(this, signalStrength)); //teraz przekazywanie siły sygnału
        }


------------------------------------------------------


Odczytywanie stanu sieci radiowej WiFi

Uprawnienia:
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />

Zdobywanie uprawnień przez proces:

    static private boolean zdobądźUprawnieniaDoOdczytaniaWłasnościWiFi(Activity activity)
    {
        int permissionCheck = ContextCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_WIFI_STATE);
        if (permissionCheck != PackageManager.PERMISSION_GRANTED)
        {
            ActivityCompat.requestPermissions(activity, new String[]{Manifest.permission.ACCESS_WIFI_STATE}, REQUEST_ACCESS_WIFI_STATE);
            return false;
        }
        else
        {
            //Toast.makeText(activity.getApplicationContext(), "Aplikacja posiada już uprawnienia do odczytania stanu telefonu", Toast.LENGTH_LONG).show();
            return true;
        }
    }

Zmiana w istniejącej metodzie:

    @Override
    public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
        switch (requestCode) {
            case REQUEST_READ_PHONE_STATE:
                if ((grantResults.length > 0) && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {
                    //Toast.makeText(getApplicationContext(), "Udzielono uprawnienia do odczytania stanu telefonu", Toast.LENGTH_LONG).show();
                    odswiezListe();
                }
                break;

            case REQUEST_ACCESS_WIFI_STATE:
                if ((grantResults.length > 0) && (grantResults[0] == PackageManager.PERMISSION_GRANTED)) {
                    //Toast.makeText(getApplicationContext(), "Udzielono uprawnienia do odczytania stanu sieci WiFi", Toast.LENGTH_LONG).show();
                    odswiezListe();
                }
                break;

            default:
                break;
        }
    }


Odczytywanie informacji o sieci WiFi:

    static private UrzadzenieInfo odczytajSiećWiFi(Activity activity)
    {
        UrzadzenieInfo wifiInfo = new UrzadzenieInfo();
        wifiInfo.typInformacji=TypInformacji.Inne;
        wifiInfo.nazwa="Sieć WiFi";

        WifiManager wm = (WifiManager) activity.getApplicationContext().getSystemService(WIFI_SERVICE);

        if(wm != null)
        {
            WifiInfo wi = wm.getConnectionInfo();
            if (wi != null)
            {
                wifiInfo.opis = "SSID: " + wi.getSSID();
                wifiInfo.opis += "\nIP: " + wi.getIpAddress();
                wifiInfo.opis += "\nMAC: " + wi.getMacAddress();
                int rssi = wi.getRssi();
                wifiInfo.polozeniePaska = WifiManager.calculateSignalLevel(rssi, 100);
            }
            else wifiInfo.polozeniePaska = -1;
            wifiInfo.opis += "\nDostępne sieci: ";
            List<WifiConfiguration> _wis = wm.getConfiguredNetworks();
            if(_wis != null)
            {
                for (WifiConfiguration _wi : _wis)
                {
                    wifiInfo.opis += "\n\t" + _wi.SSID;
                }
            }
            else wifiInfo.opis += "---";
        }
        else
        {
            //nie ma połączenia
            wifiInfo.polozeniePaska=-1;
        }

        return wifiInfo;
    }

Wywołanie tej metody należy dodać do odwiezListe.

Jeżeli chcemy być powiadamiani o zmianach w sieci WiFi (UWAGA! Bardzo częste powiadomienia), należy ustalić BroadcastReceiver:

    BroadcastReceiver wifiReceiver = null;
    Date czasOstatniegoOdświeżeniaWiFi = null;
    final long czasMiędzyOdświeżeniamiWiFi = 10000;

W metodzie odswiezListe:

            if (wifiReceiver == null)
                wifiReceiver = new BroadcastReceiver() {
                    @Override
                    public void onReceive(Context context, Intent intent)
                    {
                        //UWAGA! To jest wywoływane bardzo częstp
                        if(intent.getAction() == WifiManager.WIFI_STATE_CHANGED_ACTION)
                        {
                            Date bieżącyCzas = new Date();
                            if(czasOstatniegoOdświeżeniaWiFi == null || (bieżącyCzas.getTime() - czasOstatniegoOdświeżeniaWiFi.getTime() > czasMiędzyOdświeżeniamiWiFi))
                            {
                                czasOstatniegoOdświeżeniaWiFi = bieżącyCzas;
                                //Toast.makeText(context, "Zmiana stanu WiFi", Toast.LENGTH_LONG).show();
                                //odswiezListe();
                            }
                        }
                    }

                };
            IntentFilter _intentFilter = new IntentFilter(WifiManager.WIFI_STATE_CHANGED_ACTION);
            final Intent _intent = this.getApplicationContext().registerReceiver(wifiReceiver, _intentFilter);