TelephonyManager 处于摘机状态时电话号码设置为空

Question

我在振铃状态时获取电话号码，但有时在摘机状态时将其设置为空。我无法捕捉到它变为空的那一刻。

因此，当有电话打来（来电）时，它会转到

RINGING STATE

并且号码设置为 callno 变量。之后，当我接听电话时，它会转到

OFFHOOK STATE

，并且我在 callno 中得到

null

，因此它给了我一个

NullPointerException

。

如何预防这种情况？

公共类 CallStateReceiver 扩展了 BroadcastReceiver {

private static boolean noCallListenerYet = true;
TelephonyManager telephonyManager;
static MyPhoneStateListener phoneListener;
private static Context context1;
Context context;
private int prevState;
String userId;
String incoming_number = null;
Bundle bundle;
String state;
private static String callno = null;
static SharedPreferences pref;
static int cidvalue;
/*Added to resolve the below bug:
 * Bug: At the time of call comes on poped up note and 
 *      below note was not send and new userid not 
 *      replace with older userid.
 */
private static boolean isOnReceive = false;

public static String getCallno() {
    return callno;
}

@Override
public void onReceive(Context context, Intent intent) {
    String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);


    isOnReceive = true;

    if( CallTrackerModel.isRecording() ){
    }else{

    CallTrackerModel.setCallId("");
    try{
        if (intent.getAction()
                .equals("android.intent.action.NEW_OUTGOING_CALL")) {
            if ((bundle = intent.getExtras()) != null) {
                callno = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
                callno = callno.replaceAll(" ", "");                    
            }
        }
    }
    catch(Exception e){
    }

    try{
    if (noCallListenerYet) {
        telephonyManager = (TelephonyManager) context
                .getSystemService(Context.TELEPHONY_SERVICE);
        if (phoneListener == null) {
            phoneListener = new MyPhoneStateListener(context);
            telephonyManager.listen(phoneListener,
                    PhoneStateListener.LISTEN_CALL_STATE);
        }
        noCallListenerYet = false;
    }
    }catch(Exception e){
        isOnReceive = false;
    }

    context1 = context;
    }

}

public static int returncid() {
    int cid;
    pref = context1.getSharedPreferences("Myprefer", 0);
    SharedPreferences.Editor editor = pref.edit();
    cid = pref.getInt("currentcid", 0);
    if (cid == 0) {
        cid = cid + 1;
    }
    editor.putInt("currentcid", cid);
    editor.commit();
    pref = context1.getSharedPreferences("Myprefer", 0);
    cidvalue = pref.getInt("currentcid", 0);
    return cidvalue;
}


private class MyPhoneStateListener extends PhoneStateListener {

    Context context;
    MyPhoneStateListener(Context c) {
        super();
        context = c;
    }

    /**
     * Listen call state changes.
     */
    public void onCallStateChanged(int state, String incomingNumber) {
        CallTrackerModel ctm = new CallTrackerModel(context1);
        switch (state) {

        // Incoming/Outgoing call over.
        case TelephonyManager.CALL_STATE_IDLE:

            if (CallTrackerModel.returnRecordStarted()) {

                ctm.stopRecording();
                userId = RetrieveUserId.getUserId();

            }

            //For Received calls.
            if (prevState == TelephonyManager.CALL_STATE_OFFHOOK) {

                try{

                    cidvalue = pref.getInt("currentcid", 0);
                    ++cidvalue;
                    pref = context1.getSharedPreferences("Myprefer", 0);
                    SharedPreferences.Editor editor = pref.edit();
                    editor.putInt("currentcid", cidvalue);
                    editor.commit();
                    prevState = state;
                    // Start note activity.
                    Intent i = new Intent(context1, NoteActivity.class);
                    i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

                    if (userId == null) {
                        userId = "@@";
                    }
                    i.putExtra("userId", userId);
                    i.putExtra("isSend", false);
                    i.putExtra("incomingNumber", incoming_number);
                    context1.startActivity(i);
                    i = null;

                }catch(Exception ex){
                }
            }

            //For missed calls.
            if(prevState==TelephonyManager.CALL_STATE_RINGING){  
                prevState=state;  
            }  

            break;

        //If the caller or receiver picks up the phone
        case TelephonyManager.CALL_STATE_OFFHOOK:
            try{
                if( CallTrackerModel.isRecording() ){
                    break;
                }
                if( NoteActivity.getIsStart() ){
                    NoteActivity.setStop(true);
                }


                prevState = state;
                if (callno.length() == 13) {

                    incoming_number = callno.substring(3);

                } else if (callno.length() == 11) {

                    incoming_number = callno.substring(1);

                } else {

                    incoming_number = callno;

                }

            }catch(Exception ex){
                isOnReceive = false;
            }

            try{
                if( NoteActivity.getIsStop() ){

                    if(NoteActivity.getLater()){
                        NoteActivity.setLater(false);
                        NoteActivity.setStop(false);
                    }else{
                        NoteActivity.later(); 
                    }
                }
            }catch(Exception e){
                isOnReceive = false;
            }

            try{
                Intent i = new Intent(context1, RetrieveUserId.class);
                i.putExtra("incoming number", incoming_number);

                context1.startService(i);
                // start recording
                ctm.startRecording();
            }catch(Exception e){
                isOnReceive = false;
            }

            break;
        case TelephonyManager.CALL_STATE_RINGING:

            if( CallTrackerModel.isRecording() ){

            }else{
                prevState = state;
                callno = incomingNumber;
                callno = callno.replaceAll(" ", "");                    
            }

            break;
        }
    }
}

}

Answer 1

每次电话状态发生变化时，您的广播接收器都会被解雇。

它的作用是在每次状态改变时，在响铃后将传入号码设置为空。

首先电话响了。那时您就可以获得号码。当电话号码状态更改为 IDLE 或 OFF_HOOK 时，您的号码将再次设置为 null，因为 BR 会再次触发。

String incoming_number = null;

是将您的号码设置为空。这是搞乱它的代码。把它变成：

MainActivity:

String incoming_number;

BroadcastReceiver

MainActivity.incomingnumber = XXX-XXX-XXXX ; 

//when done with the number clean it
MainActivity.incomingnumber = null;

Answer 2

或者您可以删除通话录音应用程序。通话录音应用程序也会导致此问题。