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

Question

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

因此，当有电话打来(来电)时，它会进入振铃状态，并且号码会设置为 callno 变量。之后，当我接听电话时，它会进入摘机状态，并且我在 callno 中收到 null，因此它给了我一个 NullPointerException。

如何防止这种情况发生？

公共(public)类 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

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

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

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

Stringcoming_number = null; 是将您的号码设置为 null 的原因。这是搞乱它的代码。把它变成:

MainActivity:

String incoming_number;

BroadcastReceiver

MainActivity.incomingnumber = XXX-XXX-XXXX ; 

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