There are two different "types" of phone state receivers, receivers that have Manifest.permission.READ_CALL_LOG permission and receivers that don't.

If a receiver doesn't have the Manifest.permission.READ_CALL_LOG permission, it will be called for all state changed once, without the EXTRA_INCOMING_NUMBER extra.

If a receiver does have that above permission, like in your case, it will be called for every state changed twice, one without the EXTRA_INCOMING_NUMBER permission, and another time with it.

Since you have this code:

if (lastState == state) {
    return;
}

in your onCallStateChanged method, you're basically skipping the second call, and thus losing the EXTRA_INCOMING_NUMBER info.

If you're sure you have the READ_CALL_LOG permission, you can try skipping the duplicated receiver call without that extra completely (however note that there's a difference between getting a "null" value for that extra which means a private number call, and not getting that extra at all), like so:

String stateStr = intent.getExtras().getString(TelephonyManager.EXTRA_STATE);
if (!intent.getExtras().containsKey(TelephonyManager.EXTRA_INCOMING_NUMBER)) {
    Log.i("Call receiver", "skipping intent=" + intent + ", extras=" + intent.getExtras() + " - no number was supplied");
    return;
}
String number = intent.getExtras().getString(TelephonyManager.EXTRA_INCOMING_NUMBER);

See the official docs at: https://developer.android.com/reference/android/telephony/TelephonyManager#ACTION_PHONE_STATE_CHANGED

after installing a call recorder, have same message

You can read through the source of TelephonyRegistry: Link

/** ... this class provides a centralized place that applications can register and be called back from. */

The broadcast for an incoming call is sent from this method:

Copyprivate void broadcastCallStateChanged(int state, String incomingNumber) {
    ....
    ....
    Intent intent = new Intent(TelephonyManager.ACTION_PHONE_STATE_CHANGED);
    intent.putExtra(PhoneConstants.STATE_KEY,
            DefaultPhoneNotifier.convertCallState(state).toString());

    // If `incomingNumber` is empty, the key 
    // `TelephonyManager.EXTRA_INCOMING_NUMBER` will not be present
    // in the attached Bundle
    if (!TextUtils.isEmpty(incomingNumber)) {
        intent.putExtra(TelephonyManager.EXTRA_INCOMING_NUMBER, incomingNumber);
    }
    mContext.sendBroadcastAsUser(intent, UserHandle.ALL,
            android.Manifest.permission.READ_PHONE_STATE);
}

So, you'll receive a value corresponding to TelephonyManager.EXTRA_INCOMING_NUMBER iff incomingNumber is not empty.

incomingNumber comes from DefaultPhoneNotifier#notifyPhoneState(Phone): Link

Copy@Override
public void notifyPhoneState(Phone sender) {
    Call ringingCall = sender.getRingingCall();
    String incomingNumber = "";
    if (ringingCall != null && ringingCall.getEarliestConnection() != null){

        // Here
        incomingNumber = ringingCall.getEarliestConnection().getAddress();

    }
    try {
        mRegistry.notifyCallState(convertCallState(sender.getState()), incomingNumber);
    } catch (RemoteException ex) {
        // system process is dead
    }
}

ringingCall.getEarliestConnection().getAddress() calls the getAddress() method from one of the classes that extend com.android.internal.telephony.Connection (GsmConnection, CdmaConnection..).

If you look at the constructor of GsmConnection, you can see that there are variables assigned for number AND caller name. From what I can tell, as a receiver, you only receive the number - if one is available. So, in case of an empty string (when a caller id is blocked/withheld), the key TelephonyManager.EXTRA_INCOMING_NUMBER will not be present in the Bundle you receive.

You did not mention as to why you need this information. If you are trying to show a personalized message by comparing String values, I suggest you do the following:

CopyString phoneNumber = extras.getString(TelephonyManager.EXTRA_INCOMING_NUMBER,
                              "Personalized message for a Blocked Call");

I am not sure if this will be an adequate test, but to simulate a blocked caller id, you can take a look at this question: Link.

Your approach doesn't effectively handle the asynchronous nature of receiving call state and number information, leading to multiple log entries for the same call or nulls.

you can try this to keep track of last number

  private var lastNumber: String? = null

  private val broadcastReceiver = object : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
       if (TelephonyManager.ACTION_PHONE_STATE_CHANGED == intent.action) {
           val state = intent.getStringExtra(TelephonyManager.EXTRA_STATE)
           if (TelephonyManager.EXTRA_STATE_RINGING == state) {
               val number = intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER)
            if (number != null && number != lastNumber) {
                logCall(number)
                lastNumber = number
              }
           }
       }
    }
}

private fun logCall(number: String?) {
       // your logcall code 
}