Android comment détecter si l'appel sortant est répondu

Question

Je suis en train de développer une application qui ne sera utilisée en interne qu'à des fins de test. J'ai beaucoup cherché et essayé différentes suggestions comme suggéré dans différents post mais aucun ne semble fonctionner pour moi.

Je suis ouvert à toutes les suggestions comme Reflections, Accessibility Service, root ou tout autre hack. S'il vous plaît aider.

Cordialement

Answer 1

FAITES L'ESSAI

Définir toutes les autorisations requises dans le fichier manifest.xml.

Appelez cette classe Service

public class PhoneListener extends PhoneStateListener { 

private static PhoneListener instance = null; 

/** 
* Must be called once on app startup 
* 
* @param context - application context 
* @return 
*/ 
public static PhoneListener getInstance(Context context) { 
    if (instance == null) { 
     instance = new PhoneListener(context); 
    } 
    return instance; 
} 

public static boolean hasInstance() { 
    return null != instance; 
} 

private final Context context; 
private CallLog phoneCall; 

private PhoneListener(Context context) { 
    this.context = context; 
} 

AtomicBoolean isRecording = new AtomicBoolean(); 
AtomicBoolean isWhitelisted = new AtomicBoolean(); 


/** 
* Set the outgoing phone number 
* <p/> 
* Called by {@link MyCallReceiver} since that is where the phone number is available in a outgoing call 
* 
* @param phoneNumber 
*/ 
public void setOutgoing(String phoneNumber) { 
    if (null == phoneCall) 
     phoneCall = new CallLog(); 
    phoneCall.setPhoneNumber(phoneNumber); 
    phoneCall.setOutgoing(); 
    // called here so as not to miss recording part of the conversation in TelephonyManager.CALL_STATE_OFFHOOK 
    isWhitelisted.set(Database.isWhitelisted(context, phoneCall.getPhoneNumber())); 
} 

@Override 
public void onCallStateChanged(int state, String incomingNumber) { 
    super.onCallStateChanged(state, incomingNumber); 

    switch (state) { 
     case TelephonyManager.CALL_STATE_IDLE: // Idle... no call 
      if (isRecording.get()) { 
       RecordCallService.stopRecording(context); 
       phoneCall = null; 
       isRecording.set(false); 
      } 
      break; 
     case TelephonyManager.CALL_STATE_OFFHOOK: // Call answered 
      if (isWhitelisted.get()) { 
       isWhitelisted.set(false); 
       return; 
      } 
      if (!isRecording.get()) { 
       isRecording.set(true); 
       // start: Probably not ever usefull 
       if (null == phoneCall) 
        phoneCall = new CallLog(); 
       if (!incomingNumber.isEmpty()) { 
        phoneCall.setPhoneNumber(incomingNumber); 
       } 
       // end: Probably not ever usefull 
       RecordCallService.sartRecording(context, phoneCall); 
      } 
      break; 
     case TelephonyManager.CALL_STATE_RINGING: // Phone ringing 
      // DO NOT try RECORDING here! Leads to VERY poor quality recordings 
      // I think something is not fully settled with the Incoming phone call when we get CALL_STATE_RINGING 
      // a "SystemClock.sleep(1000);" in the code will allow the incoming call to stabilize and produce a good recording...(as proof of above) 
      if (null == phoneCall) 
       phoneCall = new CallLog(); 
      if (!incomingNumber.isEmpty()) { 
       phoneCall.setPhoneNumber(incomingNumber); 
       // called here so as not to miss recording part of the conversation in TelephonyManager.CALL_STATE_OFFHOOK 
       isWhitelisted.set(Database.isWhitelisted(context, phoneCall.getPhoneNumber())); 
      } 
      break; 
    } 

} 

}

Et utiliser le récepteur de diffusion

public class MyCallReceiver extends BroadcastReceiver { 

public MyCallReceiver() { 
} 

static TelephonyManager manager; 

@Override 
public void onReceive(Context context, Intent intent) { 
    Log.i("JLCreativeCallRecorder", "MyCallReceiver.onReceive "); 

    if (!AppPreferences.getInstance(context).isRecordingEnabled()) { 
     removeListener(); 
     return; 
    } 

    if (Intent.ACTION_NEW_OUTGOING_CALL.equals(intent.getAction())) { 
     if (!AppPreferences.getInstance(context).isRecordingOutgoingEnabled()) { 
      removeListener(); 
      return; 
     } 
     PhoneListener.getInstance(context).setOutgoing(intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER)); 
    } else { 
     if (!AppPreferences.getInstance(context).isRecordingIncomingEnabled()) { 
      removeListener(); 
      return; 
     } 
    } 

    // Start Listening to the call.... 
    if (null == manager) { 
     manager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); 
    } 
    if (null != manager) 
     manager.listen(PhoneListener.getInstance(context), PhoneStateListener.LISTEN_CALL_STATE); 
} 

private void removeListener() { 
    if (null != manager) { 
     if (PhoneListener.hasInstance()) 
      manager.listen(PhoneListener.getInstance(null), PhoneStateListener.LISTEN_NONE); 
    } 
} 

}

J'espère que vous obtenez de l'aide de ce code.

Merci

Answer 2

Vous avez besoin de cette autorisation dans le manifeste

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

TelephonyManager a un écouteur pour obtenir l'état du téléphone. mettre en œuvre ce tho savoir si le téléphone sonne ou dans un appel.

TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 
     PhoneStateListener callStateListener = new PhoneStateListener() { 

      public void onCallStateChanged(int state, String incomingNumber) { 
       // TODO React to a incoming call. 

       try { 
        if (state == TelephonyManager.CALL_STATE_RINGING) { 
         Toast.makeText(getApplicationContext(), "Phone Is Ringing" + incomingNumber, Toast.LENGTH_LONG).show(); 
         number = incomingNumber; 
         //g.setPhoneNo(incomingNumber); 
         AndroidNetCommunicationClientActivity.mMsgSendRequest("CommandMsgCallIncoming" + number); 
        } else if (state == TelephonyManager.CALL_STATE_OFFHOOK) { 
         Toast.makeText(getApplicationContext(), "Phone is Currently in A call" + incomingNumber, Toast.LENGTH_LONG).show(); 
         //number = mIntent.getStringExtra(Intent.EXTRA_PHONE_NUMBER); 
         number = incomingNumber; 


        } else if (state == TelephonyManager.DATA_DISCONNECTED) { 
         number = ""; 
         CallID = ""; 
        } 
       } catch (Exception e) { 
        // TODO Auto-generated catch block 
        //conn.MessageBox(MainActivity.this, e.getMessage()); 
        e.printStackTrace(); 
       } 
       super.onCallStateChanged(state, incomingNumber); 

      } 
     }; 
     telephonyManager.listen(callStateListener, PhoneStateListener.LISTEN_CALL_STATE); 

Answer 3

Vous pouvez utiliser des événements d'accessibilité pour détecter la durée d'appel et de ce que vous pouvez détecter si l'appel sortant est répondu ou non ..

Je l'ai répondu en détail dans Here `vous pouvez regarde ça.