Java Code Examples for android.telephony.TelephonyManager#CALL_STATE_RINGING

public void onCallStateChanged (int state, String incomingNumber)
{
    switch (state) {
    case TelephonyManager.CALL_STATE_IDLE:
        Boolean stopped = context.stopService(new Intent(context, RecordService.class));
        
        break;
    case TelephonyManager.CALL_STATE_RINGING:
        break;
    case TelephonyManager.CALL_STATE_OFFHOOK:
     if(PreferenceManager.getDefaultSharedPreferences(context).getBoolean("RecordCalls", false))
     {
         Intent callIntent = new Intent(context, RecordService.class);
         ComponentName name = context.startService(callIntent);
         if (null == name) {
         } else {
         }
     }
        break;
    }
}
 

@Override  
public void onCallStateChanged(int state, String incomingNumber) {  
        // TODO Auto-generated method stub  
        //state 当前状态 incomingNumber,貌似没有去电的API  
        super.onCallStateChanged(state, incomingNumber);  
        Intent it = new Intent();
        switch(state){  
        case TelephonyManager.CALL_STATE_IDLE:  
			it.setAction("com.jiusg.mainscreenshow");
			it.putExtra("msg", "call_stop");
			context.sendBroadcast(it);
                break;  
        case TelephonyManager.CALL_STATE_OFFHOOK:  
			it.setAction("com.jiusg.mainscreenshow");
			it.putExtra("msg", "call_start");
			context.sendBroadcast(it);  
                break;  
        case TelephonyManager.CALL_STATE_RINGING:  
              //  System.out.println("响铃:来电号码"+incomingNumber);
			it.setAction("com.jiusg.mainscreenshow");
			it.putExtra("msg", "call_ring");
			context.sendBroadcast(it);
                //输出来电号码  
                break; 
        }  
}
 

@Override
public void onCallStateChanged(int state, String incomingNumber) {
    super.onCallStateChanged(state, incomingNumber);
    switch (state) {
        // 电话挂断
        case TelephonyManager.CALL_STATE_IDLE:
            resume();
            break;
        // 等待接电话
        case TelephonyManager.CALL_STATE_RINGING:
            pause();
            break;
        // 通话中
        case TelephonyManager.CALL_STATE_OFFHOOK:
            break;
        default:
            break;
    }
}
 

@Override
public void onReceive(Context context, Intent intent) {

    //We listen to two intents.  The new outgoing call only tells us of an outgoing call.  We use it to get the number.
    if (intent.getAction().equals("android.intent.action.NEW_OUTGOING_CALL")) {
        savedNumber = intent.getExtras().getString("android.intent.extra.PHONE_NUMBER");
    } else {
        String stateStr = intent.getExtras().getString(TelephonyManager.EXTRA_STATE);
        String number = intent.getExtras().getString(TelephonyManager.EXTRA_INCOMING_NUMBER);
        int state = 0;
        if (stateStr.equals(TelephonyManager.EXTRA_STATE_IDLE)) {
            state = TelephonyManager.CALL_STATE_IDLE;
        } else if (stateStr.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)) {
            state = TelephonyManager.CALL_STATE_OFFHOOK;
        } else if (stateStr.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
            state = TelephonyManager.CALL_STATE_RINGING;
        }


        onCallStateChanged(context, state, number);
    }
}
 

private CallState detectCurrentCallState(final TelephonyManager telephonyManager) {
    int state = telephonyManager.getCallState();
    switch (state) {
        case TelephonyManager.CALL_STATE_IDLE:
            return CallState.STANDBY;
        case TelephonyManager.CALL_STATE_RINGING:
            return CallState.RINGING;
        case TelephonyManager.CALL_STATE_OFFHOOK:
        default:
            return CallState.UNKNOWN;
    }
}
 

@Override
public void phoneCallStateUpdated(int state, String phoneNumber) {
    jsModule = this.reactContext.getJSModule(CallStateUpdateActionModule.class);

    switch (state) {
        //Hangup
        case TelephonyManager.CALL_STATE_IDLE:
            if(wasAppInOffHook == true) { // if there was an ongoing call and the call state switches to idle, the call must have gotten disconnected
                jsModule.callStateUpdated("Disconnected", phoneNumber);
            } else if(wasAppInRinging == true) { // if the phone was ringing but there was no actual ongoing call, it must have gotten missed
                jsModule.callStateUpdated("Missed", phoneNumber);
            }

            //reset device state
            wasAppInRinging = false;
            wasAppInOffHook = false;
            break;
        //Outgoing
        case TelephonyManager.CALL_STATE_OFFHOOK:
            //Device call state: Off-hook. At least one call exists that is dialing, active, or on hold, and no calls are ringing or waiting.
            wasAppInOffHook = true;
            jsModule.callStateUpdated("Offhook", phoneNumber);
            break;
        //Incoming
        case TelephonyManager.CALL_STATE_RINGING:
            // Device call state: Ringing. A new call arrived and is ringing or waiting. In the latter case, another call is already active.
            wasAppInRinging = true;
            jsModule.callStateUpdated("Incoming", phoneNumber);
            break;
    }
}
 

public void onCallStateChanged(int state, String incomingNumber) {

        if (lastPhoneState == state || !MusicPlayer.isMusicPlyerEnable) {
            return;
        } else {

            lastPhoneState = state;

            if (state == TelephonyManager.CALL_STATE_RINGING) {
                pauseSoundIfPlay();
            } else if (state == TelephonyManager.CALL_STATE_IDLE) {

                if (MusicPlayer.pauseSoundFromCall) {
                    MusicPlayer.pauseSoundFromCall = false;
                    MusicPlayer.playSound();

                    //if (isBlutoothOn) {
                    //    isBlutoothOn = false;
                    //
                    //    AudioManager am = (AudioManager) G.context.getSystemService(Context.AUDIO_SERVICE);
                    //    am.setBluetoothScoOn(true);
                    //}
                }
            } else if (state == TelephonyManager.CALL_STATE_OFFHOOK) {
                pauseSoundIfPlay();
            }
        }
    }
 

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

    switch (state) {

        case TelephonyManager.CALL_STATE_OFFHOOK:
            if (DEBUG) {
                MyLog.i(CLS_NAME, "PhoneStateListener: TelephonyManager.CALL_STATE_OFFHOOK");
            }
            interrupt();
            break;
        case TelephonyManager.CALL_STATE_RINGING:
            if (DEBUG) {
                MyLog.i(CLS_NAME, "PhoneStateListener: TelephonyManager.CALL_STATE_RINGING: " + incomingNumber);
            }
            interrupt();
            break;
        case TelephonyManager.CALL_STATE_IDLE:
            if (DEBUG) {
                MyLog.i(CLS_NAME, "PhoneStateListener: TelephonyManager.CALL_STATE_IDLE");
            }

            if (conditions.restartHotword()) {
                startHotwordDetection(conditions.getBundle());
            }

            conditions.removeInterrupted(params);
            break;
    }
}
 

@Override
public void onCallStateChanged(int state, String incomingNumber) {
	super.onCallStateChanged(state, incomingNumber);
	if (state == TelephonyManager.CALL_STATE_RINGING) {
		String phoneNumber =   incomingNumber;
	}
}
 

private static boolean isIncomingCall() {
    try {
        TelephonyManager phone = (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
        return (phone.getCallState() == TelephonyManager.CALL_STATE_RINGING);
    } catch (Throwable t) {
        XposedBridge.log(t);
        return false;
    }
}
 

@Override
public void onCallStateChanged(int state, String incomingNumber) {
    String callState = "UNKNOWN";
    switch (state) {
        case TelephonyManager.CALL_STATE_IDLE:
            callState = "IDLE";
            break;
        case TelephonyManager.CALL_STATE_RINGING:
            // -- check international call or not.
            if (incomingNumber.startsWith("00")) {
                Toast.makeText(mContext, "International Call- " + incomingNumber, Toast.LENGTH_LONG).show();
                callState = "International - Ringing (" + incomingNumber + ")";
            } else {
                Toast.makeText(mContext, "Local Call - " + incomingNumber, Toast.LENGTH_LONG).show();
                callState = "Local - Ringing (" + incomingNumber + ")";
            }
            break;
        case TelephonyManager.CALL_STATE_OFFHOOK:
            String dialingNumber = mIntent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
            if (dialingNumber.startsWith("00")) {
                Toast.makeText(mContext, "International - " + dialingNumber, Toast.LENGTH_LONG).show();
                callState = "International - Dialing (" + dialingNumber + ")";
            } else {
                Toast.makeText(mContext, "Local Call - " + dialingNumber, Toast.LENGTH_LONG).show();
                callState = "Local - Dialing (" + dialingNumber + ")";
            }
            break;
    }
    Log.d(">>>Broadcast", "onCallStateChanged " + callState);
}
 

@Override
public void onCallStateChanged(int state, String incomingNumber) {
    super.onCallStateChanged(state, incomingNumber);
    switch (state) {
        case TelephonyManager.CALL_STATE_RINGING:
            videoView.pause();
            break;
        case TelephonyManager.CALL_STATE_OFFHOOK:
            videoView.pause();
            break;
        case TelephonyManager.CALL_STATE_IDLE:
            videoView.resume();
            break;
    }
}
 

private void initPhoneListener() {
    mPhoneStateListener = new PhoneStateListener(){
        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            if (!mMediaPlayer.isPlaying() || !hasCurrentMedia())
                return;
            if (state == TelephonyManager.CALL_STATE_RINGING || state == TelephonyManager.CALL_STATE_OFFHOOK)
                pause();
            else if (state == TelephonyManager.CALL_STATE_IDLE)
                play();
        }
    };
}
 

public void onCallStateChanged(int state, String incomingNumber) {
    if (lastState == TelephonyManager.CALL_STATE_RINGING
            && state == TelephonyManager.CALL_STATE_IDLE) {
        when_miss_call();
    }

    lastState = state;
}
 

@Override
public void onCallStateChanged(int state, String incomingNumber) {
    Intent restart;

    switch (state) {
        case TelephonyManager.CALL_STATE_IDLE:
            //CALL_STATE_IDLE;
            //restart = new Intent(this.module.getReactApplicationContextModule(), this.module.getClassActivity());
            //restart.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            //this.module.getReactApplicationContextModule().startActivity(restart);
            break;
        case TelephonyManager.CALL_STATE_OFFHOOK:
            //CALL_STATE_OFFHOOK;
            //restart = new Intent(this.module.getReactApplicationContextModule(), this.module.getClassActivity());
            //restart.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            //this.module.getReactApplicationContextModule().startActivity(restart);
            break;
        case TelephonyManager.CALL_STATE_RINGING:
            //CALL_STATE_RINGING
            if (this.module.getSignal().isPlaying) {
                this.module.stopOncall();
            }
            break;
        default:
            break;
    }
    super.onCallStateChanged(state, incomingNumber);
}
 

@Override
public void onReceive(Context context, Intent intent) {
  if (!TalkBackService.isServiceActive()) {
    LogUtils.w(TAG, "Service not initialized during " + "broadcast.");
    return;
  }

  int oldState = lastCallState;
  int newState;

  final String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
  if (TelephonyManager.EXTRA_STATE_IDLE.equals(state)) {
    newState = TelephonyManager.CALL_STATE_IDLE;
  } else if (TelephonyManager.EXTRA_STATE_OFFHOOK.equals(state)) {
    newState = TelephonyManager.CALL_STATE_OFFHOOK;
  } else if (TelephonyManager.EXTRA_STATE_RINGING.equals(state)) {
    newState = TelephonyManager.CALL_STATE_RINGING;
  } else {
    return;
  }
  if (newState != oldState) {
    LogUtils.v(
        TAG,
        "Call state changed: %s -> %s",
        callStateToString(lastCallState),
        callStateToString(newState));

    lastCallState = newState;
    for (CallStateChangedListener listener : callStateChangedListeners) {
      listener.onCallStateChanged(oldState, newState);
    }
  }
}
 

/**
 * Listener to check incoming call
 */
private void initPhoneListener() {

    final PhoneStateListener phoneStateListener = new PhoneStateListener() {
        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            if (state == TelephonyManager.CALL_STATE_RINGING) {
                pauseMedia();
            } else if (state == TelephonyManager.CALL_STATE_IDLE) {

                isInCall = false;

                if (isFirstStart == false) {
                    if (Build.VERSION.SDK_INT >= 17.0) {
                        bigNotification = true;
                        largeMediaPlayer = LargeMediaPlayer.getInstance(context);
                    } else {
                        bigNotification = false;
                        smallMediaPlayer = SmallMediaPlayer.getInstance(context);
                    }
                    resumeMedia();
                }

                isFirstStart = false;
            }
            super.onCallStateChanged(state, incomingNumber);
        }

    };

    telephoneManger = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
    if (telephoneManger != null) {
        telephoneManger.listen(phoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
    }
}
 

private void initPhoneCallListener()
{
    PhoneStateListener phoneStateListener = new PhoneStateListener()
    {
        @Override
        public void onCallStateChanged(int state, String incomingNumber)
        {
            if (state == TelephonyManager.CALL_STATE_RINGING) {
                //Incoming call: Pause music
                pauseVideo();
                updateAction(ACTION_PLAY);
            } else if (state == TelephonyManager.CALL_STATE_IDLE) {
                //Not in call: Play music
                resumeVideo();
                updateAction(ACTION_PAUSE);
            } else if (state == TelephonyManager.CALL_STATE_OFFHOOK) {
                //A call is dialing, active or on hold
            }
            super.onCallStateChanged(state, incomingNumber);
        }
    };

    TelephonyManager mgr = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
    if (mgr != null) {
        mgr.listen(phoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
    }
}
 

@Override
public void onCreate() {

	TelephonyManager telephonyManager = (TelephonyManager)getSystemService(getBaseContext().TELEPHONY_SERVICE);
	PhoneStateListener callStateListener = new PhoneStateListener() {
		public void onCallStateChanged(int state, String incomingNumber)
		{
			if(state==TelephonyManager.CALL_STATE_RINGING){
				//Toast.makeText(getApplicationContext(),"Phone Is Riging", Toast.LENGTH_LONG).show();
				if(handler.mediaplayer.isPlaying()){
					byCall = true;
					handler.mediaplayer.pause();
				}
			}

			if(state==TelephonyManager.CALL_STATE_OFFHOOK){
				//Toast.makeText(getApplicationContext(),"Phone is Currently in A call", Toast.LENGTH_LONG).show();
				if(handler.mediaplayer.isPlaying()){
					byCall = true;
					handler.mediaplayer.pause();
				}
			}

			if(state==TelephonyManager.CALL_STATE_IDLE){
				//Toast.makeText(getApplicationContext(),"phone is neither ringing nor in a call", Toast.LENGTH_LONG).show();
				if(byCall){
					byCall = false;
					handler.mediaplayer.start();
				}
			}
		}
	};
	telephonyManager.listen(callStateListener,PhoneStateListener.LISTEN_CALL_STATE);
	mSettingsContentObserver = new SettingsContentObserver( new Handler() );
	this.getContentResolver().registerContentObserver( android.provider.Settings.System.CONTENT_URI, true, mSettingsContentObserver );


	THIS = this;
	handler = new musicHandler(this);
	super.onCreate();
	//statusBar();

	handler.mEvent.addEvent(new EventCall(new int[]{playerEvents.PLAYER_COMPLETE,playerEvents.SONG_CHANGED,playerEvents.PLAYING_FLIP}){
		@Override
		public void onCall(final int eventId) {
			new Thread(){
				@Override
				public void run() {
					showNotification(eventId);
				}
			}.start();
		}
	});

	showNotification(-1);
}
 

/**
 * Return {@code true} if there is at least one call ringing/waiting/dialing/active or on hold.
 */
public boolean isPhoneCallActive() {
  int currentState = getCurrentCallState();
  return currentState == TelephonyManager.CALL_STATE_RINGING
      || currentState == TelephonyManager.CALL_STATE_OFFHOOK;
}