Autore Topic: Attendere la fine di una telefonata  (Letto 794 volte)

Offline funcool

  • Nuovo arrivato
  • *
  • Post: 42
  • Respect: +3
    • Mostra profilo
  • Dispositivo Android:
    Acer Liquid CM 7.1
  • Play Store ID:
    elcasa
  • Sistema operativo:
    Windows 8
Attendere la fine di una telefonata
« il: 23 Ottobre 2011, 16:41:02 CEST »
0
ciao a tutti, prima di eseguire un operazione dovrei aspettare che eventuali chiamate in corso siano terminate, pensavo di fare così:
Codice (Java): [Seleziona]
        TelephonyManager telMan;
        telMan =  (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

        while ( telMan.getCallState() != TelephonyManager.CALL_STATE_IDLE ){
                // wait 1 minute
                               
        }
TelephonyManager.CALL_STATE_IDLE è lo stato in cui non c'è una chiamata in corso e non se ne stanno ricevendo

oltre al fatto che possa funzionare o no ( e non funziona .. ) formalmente non è un gran che, ho visto che di solito si fa una cosa del genere:
telephonymanager - Android Handle phone call - Stack Overflow
Codice (Java): [Seleziona]
TelephonyManager tm = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);
tm.listen(mPhoneListener, PhoneStateListener.LISTEN_CALL_STATE);

// somewhere else
private PhoneStateListener mPhoneListener = new PhoneStateListener() {
    public void onCallStateChanged(int state, String incomingNumber) {
        try {
            switch (state) {
            case TelephonyManager.CALL_STATE_RINGING:
                // do something...
                break;

            case TelephonyManager.CALL_STATE_OFFHOOK:
                // do something...
                break;

            case TelephonyManager.CALL_STATE_IDLE:
                // do something...
                break;
            default:
                Log.d(TAG, "Unknown phone state=" + state);
            }
        } catch (RemoteException e) {}
    }
};

io vorrei far eseguire un controllo sulla chiamata ogni minuto, tanto per quello che devo fare non serve che sia immediato, dovrei usare un handler giusto ?
e per mettere in attesa il resto del codice, l'idea del while andava bene ? una cosa così potrebbe andare ? EDIT: meglio un do-while ma vabbè in fin dei conti è una finezza..
Codice (Java): [Seleziona]
boolean phoneOk=false;

private PhoneStateListener mPhoneListener = new PhoneStateListener() {
    public void onCallStateChanged(int state, String incomingNumber) {
        try {
            switch (state) {
            case TelephonyManager.CALL_STATE_RINGING:
                // do something...
                break;

            case TelephonyManager.CALL_STATE_OFFHOOK:
                // do something...
                break;

            case TelephonyManager.CALL_STATE_IDLE:
                phoneOk=true;
                break;
            default:
                Log.d(TAG, "Unknown phone state=" + state);
            }
        } catch (RemoteException e) {}
    }
};

TelephonyManager tm = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);

tm.listen(mPhoneListener, PhoneStateListener.LISTEN_CALL_STATE);

while ( phoneOk == false ) {
    // aspetta un minuto
    tm.listen(mPhoneListener, PhoneStateListener.LISTEN_CALL_STATE);
}

// avanti con il resto del codice

grazie in anticipo !
« Ultima modifica: 23 Ottobre 2011, 16:59:04 CEST da funcool »

Offline funcool

  • Nuovo arrivato
  • *
  • Post: 42
  • Respect: +3
    • Mostra profilo
  • Dispositivo Android:
    Acer Liquid CM 7.1
  • Play Store ID:
    elcasa
  • Sistema operativo:
    Windows 8
Re:Attendere la fine di una telefonata
« Risposta #1 il: 14 Febbraio 2012, 17:03:29 CET »
0
nessuno ?? ok prima avevo le idee abbastanza confuse, adesso qualcosa ho capito ma ancora non funziona.

Devo attendere che eventuali telefonate in corso terminino prima di eseguire delle operazioni, ho provato questi 2 modi:

1) modo molto caprone
Codice (Java): [Seleziona]
boolean isCalling=true;
TelephonyManager telMan =  (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

int callState = telMan.getCallState();                                                                         
if (callState != TelephonyManager.CALL_STATE_IDLE)
  {
        Log.i(LOG_TAG, "INIZIO WHILE");
        while ( isCalling ){
                                       
                if ( telMan.getCallState() == TelephonyManager.CALL_STATE_IDLE)
                        isCalling=false;
 
        /* avevo provato con un thread.sleep ma non funzionava lo stesso
                try {
                        Thread.sleep(2000);
                } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
        */


        }

2) tentativo di utilizzo di un handler
Codice (Java): [Seleziona]
boolean isCalling=true;
TelephonyManager telMan =  (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

int callState = telMan.getCallState();
if (callState != TelephonyManager.CALL_STATE_IDLE)
  {
        Log.i(LOG_TAG, "INIZIO WHILE");
        while ( isCalling ){
       
                Handler handler = new Handler();
                handler.postDelayed(new Runnable() {
                                 public void run() {
                                      updateCallState();
                                 }
                    }, 2000); // 2000ms = 2 sec
               
        }
/* e il metodo updateCallState */

public void updateCallState()
    {
                if ( telMan.getCallState() == TelephonyManager.CALL_STATE_IDLE)
                        isCalling=false;
    }

in entrambi i casi il sistema dice che l'applicazione non risponde, force close o wait, nel primo caso se interrompo la telefonata in un tempo brevissimo funziona

cosa sto sbagliando? sapete come dovrei fare ?
in pratica vorrei capire come inserire un ritardo che non mi mandi l'app a remengo...

 EDIT: altra idea che mi è venuta, forse una volta verificato che è  in corso una telefonata dovrei   registrarmi all'evento ' messo giù il telefono ' ,  solo che mi pare ancora piú complicato ..
« Ultima modifica: 14 Febbraio 2012, 20:59:40 CET da funcool »

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Attendere la fine di una telefonata
« Risposta #2 il: 14 Febbraio 2012, 22:20:38 CET »
+1
Ciao funcool {il tuo nick evoca parolacce :) }
Bene, se ti serve solamente sapere quando una chiamata in corso termina ti basta semplicemente dichiarare un PhoneStateListener e sarà lui ad avvertirti del cambiamento di stato del telefono.
Però credo sarebbe bene distinguere tra chiamate in uscita (Outgoing call) e chiamate in entrata (Incoming call)
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline funcool

  • Nuovo arrivato
  • *
  • Post: 42
  • Respect: +3
    • Mostra profilo
  • Dispositivo Android:
    Acer Liquid CM 7.1
  • Play Store ID:
    elcasa
  • Sistema operativo:
    Windows 8
Re:Attendere la fine di una telefonata
« Risposta #3 il: 15 Febbraio 2012, 19:34:44 CET »
0
Grazie, nel mio caso la differenza tra outgoing e ingoing non è importante

Ho fatto questo test e funziona, allo stato attuale continua a notificarmi tutti i cambi di stato ma appena lo stato diventa IDLE io mi devo de-registrare ma non so dove de-registrare il PhoneStateListener, ho provato direttamente dentro al listener ma non funziona..

Codice (Java): [Seleziona]
EndCallListener callListener;
TelephonyManager mTM;
private Button callState;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.test);

callState = (Button) findViewById(R.id.button8);

callState.setOnClickListener(new OnClickListener(){
                public void onClick(View v){
                        // check the call state
                        checkCall();
                }
        });

}

private void checkCall(){
               
                callListener = new EndCallListener();
                mTM = (TelephonyManager)this.getSystemService(Context.TELEPHONY_SERVICE);
               
                if( mTM.getCallState() != TelephonyManager.CALL_STATE_IDLE ){
                        Toast.makeText( myCont , "IF: NOT IDLE", Toast.LENGTH_LONG).show();
                        mTM.listen(callListener, PhoneStateListener.LISTEN_CALL_STATE);
                }
                else {         
                        Toast.makeText( myCont , "IF: IDLE", Toast.LENGTH_LONG).show();
                }
               
        }

private class EndCallListener extends PhoneStateListener {
            @Override
            public void onCallStateChanged(int state, String incomingNumber) {
                if(TelephonyManager.CALL_STATE_RINGING == state) {
                        Toast.makeText( myCont , "CALL STATE RINGING", Toast.LENGTH_LONG).show();
                        Log.i(LOG_TAG, "RINGING, number: " + incomingNumber);
                }
                if(TelephonyManager.CALL_STATE_OFFHOOK == state) {
                    //wait for phone to go offhook (probably set a boolean flag) so you know your app initiated the call.
                        Toast.makeText( myCont , "CALL STATE OFFHOOK", Toast.LENGTH_LONG).show();
                        Log.i(LOG_TAG, "OFFHOOK");
                }
                if(TelephonyManager.CALL_STATE_IDLE == state) {
                    //when this state occurs, and your flag is set, restart your app
                        Toast.makeText( myCont , "CALL STATE IDLE", Toast.LENGTH_LONG).show();
                        Log.i(LOG_TAG, "IDLE");
                   
                  //  unregisterCallListener(); // de registrando qui ho una sequenza infinita di Toast e si riavvia l'emulatore
                                   
                }
            }
        }
       
        private void unregisterCallListener(){
               
                // DEREGISTRA,  unregister the listener
                mTM.listen( callListener , PhoneStateListener.LISTEN_CALL_STATE);
               
        }

Offline alexAndroid

  • Utente normale
  • ***
  • Post: 185
  • Respect: +27
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy Giò
  • Sistema operativo:
    Ubuntu 11.10; Windows XP
Re:Attendere la fine di una telefonata
« Risposta #4 il: 16 Febbraio 2012, 14:07:19 CET »
+1
Come mai lo de-registreresti?
Comunque credo che lo dovresti de-registrare in questo punto
Codice (Java): [Seleziona]
private void checkCall(){
               
                callListener = new EndCallListener();
                mTM = (TelephonyManager)this.getSystemService(Context.TELEPHONY_SERVICE);
               
                if( mTM.getCallState() != TelephonyManager.CALL_STATE_IDLE ){
                        Toast.makeText( myCont , "IF: NOT IDLE", Toast.LENGTH_LONG).show();
                        mTM.listen(callListener, PhoneStateListener.LISTEN_CALL_STATE);
                }
                else if (mTM.getCallState() == TelephonyManager.CALL_STATE_IDLE) {        
                        Toast.makeText( myCont , "IDLE", Toast.LENGTH_LONG).show();
                         unregisterCallListener();         //QUI LO DEREGISTRI
                }
               
        }
Sei stato aiutato oppure il tuo problema è stato risolto? Allora premi il tasto THANKS E' un modo utile e carino per ringraziare chi ti è stato di aiuto.

Offline funcool

  • Nuovo arrivato
  • *
  • Post: 42
  • Respect: +3
    • Mostra profilo
  • Dispositivo Android:
    Acer Liquid CM 7.1
  • Play Store ID:
    elcasa
  • Sistema operativo:
    Windows 8
Re:Attendere la fine di una telefonata
« Risposta #5 il: 18 Febbraio 2012, 17:00:54 CET »
0
grazie ancora, de-registrandolo lì non ha funzionato e ho optato per una soluzione completamente diversa, se il telefono non è in IDLE richiamo il mio service tra un minuto e ripeto finchè non è terminata la telefonata

dovevo de-registrarlo perchè io devo solo controllare che un operazione programmata non avvenga durante una telefonata, lasciandolo registrato la mia app avrebbe agito ad ogni cambio di stato del telefono, cosa che non deve succedere
« Ultima modifica: 18 Febbraio 2012, 17:03:29 CET da funcool »