Develop Reference

Is it possible to record both incoming and outgoing calls in android, I tried using media recorder, but the need was not fulfilled

This is my Receiver Class where i'm getting phone state of both incoming and outgoing calls
public class MyBroadcastReceiver extends BroadcastReceiver {
private static final String TAG = "MyBroadcastReceiver";
//The receiver will be recreated whenever android feels like it. We need a static variable to remember data between instantiations
private String phoneIncomingNumber = "";
private String PhoneState = "";
private String Message = "";
private MediaRecorder recorder;
Context context;
//Call Recording varibales
private static final String AUDIO_RECORDER_FILE_EXT_3GP = ".3gp";
private static final String AUDIO_RECORDER_FILE_EXT_MP4 = ".mp3";
private static final String AUDIO_RECORDER_FOLDER = "Recordings";
Uri audiouri;
ParcelFileDescriptor file;
AudioManager audioManager;
private int currentFormat = 0;
private int output_formats[] = { MediaRecorder.OutputFormat.MPEG_4,
MediaRecorder.OutputFormat.THREE_GPP };
private String file_exts[] = { AUDIO_RECORDER_FILE_EXT_MP4,
AUDIO_RECORDER_FILE_EXT_3GP };
//The receiver will be recreated whenever android feels like it. We need a static variable to remember data between instantiations
private static int lastState = TelephonyManager.CALL_STATE_IDLE;
private static Date callStartTime;
private static boolean isIncoming;
private static String savedNumber; //because the passed incoming is only valid in ringing
#Override
public void onReceive(Context context, Intent intent) {
// TODO: This method is called when the BroadcastReceiver is receiving
// Registering service
context.startService(new Intent(context, MyService.class));
// Getting Call Details
String stateStr = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
phoneIncomingNumber = intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER);
Log.d("Call Status1", "Number1: " + phoneIncomingNumber + ":STATE : " + stateStr);
if (intent.getAction().equals("android.intent.action.NEW_OUTGOING_CALL")) {
savedNumber = intent.getStringExtra("android.intent.extra.PHONE_NUMBER");
} else {
phoneIncomingNumber = intent.getStringExtra(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;
startRecording(getRecordFileName(phoneIncomingNumber), context);
} else if (stateStr.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
state = TelephonyManager.CALL_STATE_RINGING;
}
onCallStateChanged(context, state, phoneIncomingNumber);
}
}
//Derived classes should override these to respond to specific events of interest
protected void onIncomingCallStarted(Context ctx, String number, Date start) {
Message = "Call from : \"+number+\" on DATE \"+start+\" started";
Log.d("Call Status", "INCOMING CALL STARTED");
}
protected void onOutgoingCallStarted(Context ctx, String number, Date start) {
Message = "Call to : \"+number+\" on DATE \"+start+\" started";
Log.d("Call Status", "OUTGOING CALL STARTED to :" + number);
PhoneState = "OFFHOOK";
}
protected void onIncomingCallEnded(Context ctx, String number, Date start, Date end) {
Log.d("Call Status", "INCOMING CALL ENDED");
Message = "Call from : \"+number+\" on DATE \"+start+\" ended";
stopRecording();
}
protected void onOutgoingCallEnded(Context ctx, String number, Date start, Date end) {
Message = "Call to : \"+number+\" on DATE \"+start+\" ended";
Log.d("Call Status", "OUTGOING CALL ENDED");
stopRecording();
}
protected void onMissedCall(Context ctx, String number, Date start) {
Message = "Missed call : \"+number+\" on DATE \"+start+\"";
Log.d("Call Status", "MISSED CALL");
}
//Deals with actual events
//Incoming call- goes from IDLE to RINGING when it rings, to OFFHOOK when it's answered, to IDLE when its hung up
//Outgoing call- goes from IDLE to OFFHOOK when it dials out, to IDLE when hung up
public void onCallStateChanged(Context context, int state, String number) {
Log.d("Call", "Number: " + number);
if (lastState == state) {
//No change, debounce extras
return;
}
switch (state) {
case TelephonyManager.CALL_STATE_RINGING:
isIncoming = true;
callStartTime = new Date();
savedNumber = number;
PhoneState = "RINGING";
onIncomingCallStarted(context, number, callStartTime);
break;
case TelephonyManager.CALL_STATE_OFFHOOK:
//Transition of ringing->offhook are pickups of incoming calls. Nothing done on them
if (lastState != TelephonyManager.CALL_STATE_RINGING) {
isIncoming = false;
callStartTime = new Date();
PhoneState = "OFFHOOK";
onOutgoingCallStarted(context, phoneIncomingNumber, callStartTime);
}
break;
case TelephonyManager.CALL_STATE_IDLE:
//Went to idle- this is the end of a call. What type depends on previous state(s)
if (lastState == TelephonyManager.CALL_STATE_RINGING) {
//Ring but no pickup- a miss
PhoneState = "IDLE";
onMissedCall(context, phoneIncomingNumber, callStartTime);
} else if (isIncoming) {
PhoneState = "INCOMING CALL ENDED";
onIncomingCallEnded(context, phoneIncomingNumber, callStartTime, new Date());
} else {
PhoneState = "OUTGOING CALL ENDED";
onOutgoingCallEnded(context, phoneIncomingNumber, callStartTime, new Date());
}
break;
}
lastState = state;
}
private MediaRecorder.OnErrorListener errorListener = new MediaRecorder.OnErrorListener() {
#Override
public void onError(MediaRecorder mr, int what, int extra) {
Toast.makeText(context,
"Error: " + what + ", " + extra, Toast.LENGTH_SHORT).show();
}
};
private MediaRecorder.OnInfoListener infoListener = new MediaRecorder.OnInfoListener() {
#Override
public void onInfo(MediaRecorder mr, int what, int extra) {
Toast.makeText(context,
"Warning: " + what + ", " + extra, Toast.LENGTH_SHORT)
.show();
}
};
// Recording Audio
private void startRecording(String fileName, Context ctx) {
Log.d("Call Status", "Inside");
ContentValues values = new ContentValues(4);
values.put(MediaStore.Audio.Media.TITLE, fileName);
values.put(MediaStore.Audio.Media.DATE_ADDED, (int) (System.currentTimeMillis() / 1000));
values.put(MediaStore.Audio.Media.MIME_TYPE, "audio/mpeg");
values.put(MediaStore.Audio.Media.RELATIVE_PATH, "Music/Recordings/");
audiouri = ctx.getContentResolver().insert(MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, values);
Log.d("Call Status", "Call Status: "+audiouri);
try {
file = ctx.getContentResolver().openFileDescriptor(audiouri, "w");
} catch (Exception e) {
Log.d("Call Status", "File Error"+e);
}
audioManager = (AudioManager) ctx.getApplicationContext().getSystemService(Context.AUDIO_SERVICE);
audioManager.setMode(AudioManager.MODE_IN_CALL);
// audioManager.setSpeakerphoneOn(true);
recorder = new MediaRecorder();
recorder.setAudioSource(MediaRecorder.AudioSource.VOICE_COMMUNICATION);
recorder.setOutputFormat(output_formats[currentFormat]);
//recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
recorder.setOutputFile(file.getFileDescriptor());
recorder.setOnErrorListener(errorListener);
recorder.setOnInfoListener(infoListener);
try {
recorder.prepare();
recorder.start();
} catch (IllegalStateException e) {
Log.e("REDORDING :: ",e.getMessage());
e.printStackTrace();
} catch (IOException e) {
Log.e("REDORDING :: ",e.getMessage());
e.printStackTrace();
}
}
private void stopRecording() {
// audioManager.setSpeakerphoneOn(false);
try{
if (null != recorder) {
recorder.stop();
recorder.reset();
recorder.release();
recorder = null;
}
}catch(Exception stopException){
Log.d("Exce",stopException+"");
}
}
private String getRecordFileName(String phoneNumber) {
// Generate a unique file name based on the phone number and the current time
String timeStamp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
return phoneNumber + "_" + timeStamp + ".wav";
}
}
My Service Class to run receiver as a forground service
public class MyService extends Service {
private static final int SERVICE_NOTIFICATION_ID =2 ;
private static final String CHANNEL_ID = "PhoneStateModule";
public MyService() {
}
private Handler handler = new Handler();
private Runnable runnableCode = new Runnable() {
#Override
public void run() {
try{
handler.postDelayed(this, 2000);
}catch (Exception ex){
Log.d("Error",ex+"");
}
}
};
private void createNotificationChannel() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
int importance = NotificationManager.IMPORTANCE_DEFAULT;
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "PhoneStateModule", importance);
channel.setDescription("CHANEL DESCRIPTION");
NotificationManager notificationManager = getSystemService(NotificationManager.class);
notificationManager.createNotificationChannel(channel);
}
}
#Override
public int onStartCommand(Intent intent, int flags, int startId) {
this.handler.post(this.runnableCode); // Starting the interval
// Turning into a foreground service
createNotificationChannel(); // Creating channel for API 26+
Intent notificationIntent = new Intent(this, MainActivity.class);
PendingIntent contentIntent = PendingIntent.getActivity(this, 0, notificationIntent, PendingIntent.FLAG_CANCEL_CURRENT|PendingIntent.FLAG_MUTABLE);
Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
.setContentTitle("Phone Recording Service")
.setContentText("Running…")
.setSmallIcon(R.mipmap.ic_launcher)
.setContentIntent(contentIntent)
.setOngoing(true)
.build();
startForeground(SERVICE_NOTIFICATION_ID, notification);
return START_STICKY;
}
#Override
public IBinder onBind(Intent intent) {
// TODO: Return the communication channel to the service.
return null;
}
}
Can anyone help me with the issue facing, I am using device with android 10 and am not getting the recordings, even if the recording is saved inside folder I'm not getting any audio.

Android - How to create a PhoneStateListener

I have a function to initiate an outbound phone call. I need to set up the listener to know the state of the call (ringing, hang-up, etc). I am having trouble figuring out how to do that and haven't found a tutorial that shows how. Here is the setup to place the call:
PhoneCall.kt
class PhoneCall : AppCompatActivity() {
private fun placeCall() {
if(ActivityCompat.checkSelfPermission(this, android.Manifest.permission.CALL_PHONE) == PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, android.Manifest.permision.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED) {
val telephonyManager = getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
telephonyManager.listen(CallListener, PhoneStateListener.LISTEN_CALL_STATE) //Not sure how to set up CallListener here?
val callIntent = Intent(Intent.ACTION_CALL, Uri.parse(phoneNumber))
startActivity(callIntent)
}
}
}
I believe from CallListener I can create a when() to find the current state. But I'm not sure how to create CallListener and this doesn't appear to be a true listener? Does CallListener need to be a new class, object, or something else? I think I may need a Broadcast Receiver? I don't know the correct way to handle this.

I have a project where I do something similar I created two classes one PhoneCallListener and PhoneCallReceiver. I have removed some code that is used for my needs but if you implement these two classes you should be ok. I am no expert but I hope it helps you.
The jsonObject is just used as an example to show "doing something". I should also mention that I do not know Kotlin but I am told that Android Studio can convert the Java to Kotlin so it might help, hopefully someone more experienced will know how in Kotlin.
PhoneCallListener.java
public class PhoneCallListener extends PhoneCallReceiver {
#Override
protected void onIncomingCallStarted(Context c, String number, Date start) {
JSONObject jsonObject = new JSONObject();
try {
jsonObject.put("Timestamp", App.getUTCTimestamp());
jsonObject.put("Direction", "incoming");
jsonObject.put("Number", number);
} catch (JSONException e) {
e.printStackTrace();
}
}
#Override
protected void onOutgoingCallStarted(Context c, String number, Date start) {
JSONObject jsonObject = new JSONObject();
try {
jsonObject.put("Timestamp", App.getUTCTimestamp());
jsonObject.put("Direction", "outgoing");
jsonObject.put("Number", number);
} catch (JSONException e) {
e.printStackTrace();
}
}
#Override
protected void onIncomingCallEnded(Context c, String number, Date start, Date end)
JSONObject jsonObject = new JSONObject();
try {
jsonObject.put("Timestamp", App.getUTCTimestamp());
jsonObject.put("Direction", "incoming call ended");
jsonObject.put("Number", number);
} catch (JSONException e) {
e.printStackTrace();
});
}
#Override
protected void onOutgoingCallEnded(Context c, String number, Date start, Date end) {
JSONObject jsonObject = new JSONObject();
try {
jsonObject.put("Timestamp", App.getUTCTimestamp());
jsonObject.put("Direction", "outgoing call ended");
jsonObject.put("Number", number);
} catch (JSONException e) {
e.printStackTrace();
}
}
#Override
protected void onMissedCall(Context c, String number, Date start) {
JSONObject jsonObject = new JSONObject();
try {
jsonObject.put("Timestamp", App.getUTCTimestamp());
jsonObject.put("Direction", "missed");
jsonObject.put("Number", number);
} catch (JSONException e) {
e.printStackTrace();
}
}
}
PhoneCallReceiver.java
abstract class PhoneCallReceiver extends BroadcastReceiver {
//The receiver will be recreated whenever android feels like it. We need a static variable to remember data between instantiations
private static int lastState = TelephonyManager.CALL_STATE_IDLE;
private static Date callStartTime;
private static boolean isIncoming;
private static String savedNumber; //because the passed incoming is only valid in ringing
#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.
try {
if (Objects.equals(intent.getAction(), "android.intent.action.NEW_OUTGOING_CALL")) {
savedNumber = Objects.requireNonNull(intent.getExtras()).getString("android.intent.extra.PHONE_NUMBER");
} else {
String stateStr = Objects.requireNonNull(intent.getExtras()).getString(TelephonyManager.EXTRA_STATE);
String number = intent.getExtras().getString(TelephonyManager.EXTRA_INCOMING_NUMBER);
if (number == null) {
number = "00000000000"; // Caller Withheld.
}
int state = 0;
assert stateStr != null;
if (!stateStr.equals(TelephonyManager.EXTRA_STATE_IDLE)) {
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);
}
} catch (Exception e) {
e.printStackTrace();
}
}
//Derived classes should override these to respond to specific events of interest
protected void onIncomingCallStarted(Context ctx, String number, Date start) {
}
protected void onOutgoingCallStarted(Context ctx, String number, Date start) {
}
protected void onIncomingCallEnded(Context ctx, String number, Date start, Date end) {
}
protected void onOutgoingCallEnded(Context ctx, String number, Date start, Date end) {
}
protected void onMissedCall(Context ctx, String number, Date start) {
}
//Deals with actual events
//Incoming call- goes from IDLE to RINGING when it rings, to OFFHOOK when it's answered, to IDLE when its hung up
//Outgoing call- goes from IDLE to OFFHOOK when it dials out, to IDLE when hung up
public void onCallStateChanged(Context context, int state, String number) {
if (lastState == state) {
//No change, debounce extras
return;
}
switch (state) {
case TelephonyManager.CALL_STATE_RINGING:
isIncoming = true;
callStartTime = new Date();
savedNumber = number;
onIncomingCallStarted(context, number, callStartTime);
break;
case TelephonyManager.CALL_STATE_OFFHOOK:
//Transition of ringing->offhook are pickups of incoming calls. Nothing done on them
if (lastState != TelephonyManager.CALL_STATE_RINGING) {
isIncoming = false;
callStartTime = new Date();
onOutgoingCallStarted(context, savedNumber, callStartTime);
}
break;
case TelephonyManager.CALL_STATE_IDLE:
//Went to idle- this is the end of a call. What type depends on previous state(s)
if (lastState == TelephonyManager.CALL_STATE_RINGING) {
//Ring but no pickup- a miss
onMissedCall(context, savedNumber, callStartTime);
} else if (isIncoming) {
onIncomingCallEnded(context, savedNumber, callStartTime, new Date());
} else {
onOutgoingCallEnded(context, savedNumber, callStartTime, new Date());
}
break;
}
lastState = state;
}
}

Android block outgoing calls issue

I want to block out going calls based on some logic.
I am using below code
public class OutgoingCallReceiver extends BroadcastReceiver {
private OutgoingCallListener customPhoneListener = null;
public static boolean check = true;
#Override
public void onReceive(Context context, Intent intent) {
String originalNumber = intent
.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
TelephonyManager telephony = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
customPhoneListener = new OutgoingCallListener(context,
originalNumber);
telephony.listen(customPhoneListener,
PhoneStateListener.LISTEN_CALL_STATE);
}
}
}
// Blocking call
public void blockCall(Context context) {
try {
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
Class<?> c = Class.forName(tm.getClass().getName());
Method m = c.getDeclaredMethod("getITelephony");
m.setAccessible(true);
ITelephony telephonyService = (ITelephony) m.invoke(tm);
telephonyService = (ITelephony) m.invoke(tm);
// telephonyService.silenceRinger();
telephonyService.endCall();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
<uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS" />
<receiver android:name="com.demo.example.OutgoingCallReceiver" >
<intent-filter>
<action android:name="android.intent.action.NEW_OUTGOING_CALL" />
</intent-filter>
</receiver>
The issue is :: When i am calling from my mobile. Onreceive is calling multiple times and it giving different numbers.
Please help me. Thank you.

I am also facing same issue. It's because of using .
Here first store your number in some object. see my code below.
<receiver android:name="com.perumaltt.cloud.receiver.ProcessCall" >
<intent-filter>
<action android:name="android.intent.action.PHONE_STATE" />
<action android:name="android.intent.action.NEW_OUTGOING_CALL" />
</intent-filter>
</receiver>
public class ProcessCall extends BroadcastReceiver {
public static String number;
#Override
public void onReceive(Context context, Intent intent) {
// TODO Auto-generated method stub
String originalNumber = intent
.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
System.out.println("originalNumber :::: " + originalNumber);
if (originalNumber != null) {
number = originalNumber;
}
TelephonyManager telephony = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
MyPhoneStateListener listener = new MyPhoneStateListener(context,originalNumber);
telephony.listen(listener, PhoneStateListener.LISTEN_CALL_STATE);
}
}
// My listener
public class MyPhoneStateListener extends PhoneStateListener {
Context context;
String outGoingCall;
public MyPhoneStateListener(Context context, String outGoingCall) {
super();
this.context = context;
this.outGoingCall = outGoingCall;
}
#Override
public void onCallStateChanged(int state, String callingNumber) {
System.out.println("callingNumber MyPhoneStateListener before"
+ callingNumber);
// Log.i("callingNumber :::: MyPhoneStateListener ", outGoingCall);
// if(callingNumber == null || callingNumber.trim().length() < 3){
// return;
// }
// if(outGoingCall == null || outGoingCall.trim().length() < 3){
// return;
// }
System.out.println("callingNumber MyPhoneStateListener after"
+ callingNumber);
System.out.println("state ::: "+state);
switch (state) {
case TelephonyManager.CALL_STATE_IDLE:
break;
case TelephonyManager.CALL_STATE_OFFHOOK:
// handle out going call
callOut(outGoingCall);
break;
case TelephonyManager.CALL_STATE_RINGING:
// handle in coming call
endCallIfBlocked(callingNumber);
break;
default:
break;
}
super.onCallStateChanged(state, callingNumber);
}
synchronized private void callOut(String outGoingCall1) {
if(outGoingCall1 == null){
return;
}
if(ProcessCall.number.equalsIgnoreCase(outGoingCall1)){
System.out.println("yes same ******** ");
}else {
System.out.println("not same ******* ");
return;
}
System.out.println("call out :::: "+outGoingCall1);
if (UserDetials.getInstance().getCallController().ismCallOutList()
&& outGoingCall != null) {
ArrayList<ContactsModel> numbers = CloudApplication.database
.getContacts(MySQLiteHelper.COLUMN_PHONE_NUMBER,
outGoingCall);
if (numbers.size() > 0) {
ContactsModel model = numbers.get(0);
System.out.println("type :::: " + model.getType());
if (model.getType() != Constants.CALL_OUT) {
CommonMethods.getInstance().blockCall(context,outGoingCall1,Constants.CALL_OUT);
}
}else{
CommonMethods.getInstance().blockCall(context,outGoingCall1,Constants.CALL_OUT);
}
}
}
private void endCallIfBlocked(String callingNumber) {
System.out.println("endCallIfBlocked :::: endCallIfBlocked");
ArrayList<ContactsModel> numbers = CloudApplication.database
.getContacts(MySQLiteHelper.COLUMN_PHONE_NUMBER, callingNumber);
if (UserDetials.getInstance().getCallController().ismCallInList()) {
if (numbers.size() > 0) {
ContactsModel model = numbers.get(0);
if (model.getType() != Constants.CALL_IN) {
CommonMethods.getInstance().blockCall(context,callingNumber,Constants.CALL_IN);
}
} else {
CommonMethods.getInstance().blockCall(context,callingNumber,Constants.CALL_IN);
}
} else if (UserDetials.getInstance().getCallController().ismBlockList()) {
if (numbers.size() > 0) {
ContactsModel model = numbers.get(0);
if (model.getType() == Constants.BLOCK_LIST) {
CommonMethods.getInstance().blockCall(context,callingNumber,Constants.BLOCK_LIST);
}
}
}
}
}
// Blocking code
public void blockCall(Context context) {
try {
TelephonyManager tm = (TelephonyManager) context
.getSystemService(Context.TELEPHONY_SERVICE);
Class<?> c = Class.forName(tm.getClass().getName());
Method m = c.getDeclaredMethod("getITelephony");
m.setAccessible(true);
ITelephony telephonyService = (ITelephony) m.invoke(tm);
telephonyService = (ITelephony) m.invoke(tm);
telephonyService.endCall();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
That's it. Enjoy

Last outgoing call details after call ends

Hi I searched a lot on this forum for correct result but unable to find. I need details of last outgoing call once call is ended. For this I am using BroadcasteReceiver here is code for my receiver
public class CallStateBroadcaster extends BroadcastReceiver {
#Override
public void onReceive(Context context, Intent intent) {
// TODO Auto-generated method stub
((TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE)).listen(new CustomPhoneStateListener(context), PhoneStateListener.LISTEN_CALL_STATE);
}}
Here is code for PhoneStateListener
public class CustomPhoneStateListener extends PhoneStateListener{
private Context context;
public CustomPhoneStateListener(Context paramContext)
{
this.context = paramContext;
}
#Override
public void onCallStateChanged(int state, String incomingNumber) {
// TODO Auto-generated method stub
super.onCallStateChanged(state, incomingNumber);
((TelephonyManager)this.context.getSystemService("phone")).listen(this, PhoneStateListener.LISTEN_NONE);
if(TelephonyManager.CALL_STATE_IDLE == state)
{
try {
Thread.sleep(1500L);
Intent intent = new Intent(this.context,LastCallInfoActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
this.context.startActivity(intent);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Here is code for my activity which fetch call details for call log
public class LastCallInfoActivity extends Activity{
String addtolist;
#Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
Cursor callDetailCursor = getContentResolver().query(CallLog.Calls.CONTENT_URI, null,null,null,android.provider.CallLog.Calls.DATE + " DESC limit 1");
int phoneNumber= callDetailCursor.getColumnIndex(CallLog.Calls.NUMBER);
int callType=callDetailCursor.getColumnIndex(CallLog.Calls.TYPE);
int callDate=callDetailCursor.getColumnIndex(CallLog.Calls.DATE);
int callDuration=callDetailCursor.getColumnIndex(CallLog.Calls.DURATION);
Log.i(">>CAllDetails", "getsCallLogs" );
if(callDetailCursor.getCount()>0)
{
while(callDetailCursor.moveToNext())
{
String phoneNumberString=callDetailCursor.getString(phoneNumber);
String contactName= getContactName(this, phoneNumberString);
String callTypeString =callDetailCursor.getString(callType);
String callDateString=callDetailCursor.getString(callDate);
String callDurationString=callDetailCursor.getString(callDuration);
Date callDayTime=new Date(Long.valueOf(callDateString));
int callCode = Integer.parseInt(callTypeString);
int calldur=Integer.parseInt(callDurationString);
if (callCode==2 && calldur>=1)
{
Double callCost=Double.parseDouble(callDurationString);
String callCostString= String.valueOf( callCost);
Log.i(">>CAllDetails", "getsLocation" );
addtolist= "Name :"+contactName+"\n"+
"Phone Number: "+phoneNumberString+"\n"+"Call Duration :"+
callDurationString+" Seconds\n"+"Call Date: "+callDayTime+"\n"+
callCostString;
}
}
}callDetailCursor.close();
Toast.makeText(this, addtolist, Toast.LENGTH_LONG).show();
}
public String getContactName(Context context, String phoneNumber) {
ContentResolver cr = context.getContentResolver();
Uri uri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI, Uri.encode(phoneNumber));
Cursor cursor = cr.query(uri, new String[]{PhoneLookup.DISPLAY_NAME}, null, null, null);
if (cursor == null) {
return null;
}
String contactName = null;
if(cursor.moveToFirst()) {
contactName = cursor.getString(cursor.getColumnIndex(PhoneLookup.DISPLAY_NAME));
}
if(cursor != null && !cursor.isClosed()) {
cursor.close();
}
return contactName;
}
}
My this program show toast even before my call got disconnected and start my activity. Please help me and correct my code so that it will get executed after call ends
thanks

just try this add an additional if statement for checking previous sate was off hook.
boolean wasoffhook=false;
if(TelephonyManager.CALL_STATE_OFFHOOK == state)
{
wasoffhook=true;
}
if(TelephonyManager.CALL_STATE_IDLE == state&&wasoffhook)
{
try {
Thread.sleep(1500L);
Intent intent = new Intent(this.context,LastCallInfoActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
this.context.startActivity(intent);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

In your onreceive method of Callstatebroadcaster add this code and it would work fine.I just solved it.
#Override
public void onReceive(Context context, Intent intent)
{
try
{
if (intent.getAction().equals("android.intent.action.NEW_OUTGOING_CALL"))
{
savedNumber = intent.getExtras().getString("android.intent.extra.PHONE_NUMBER");
Toast.makeText(context,"the no. is"+savedNumber,Toast.LENGTH_LONG).show();
// onOutgoingCallStarted(context,"",callStartTime);
}
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)) {
switch (state) {
case TelephonyManager.CALL_STATE_IDLE:
Log.d("Testing", "Outgoing call has been disconnect");
intent = new Intent(context, MyCustomDialog.class);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
context.startActivity(intent);
System.out.println("CAll has been disconnect...............");
// Toast.makeText(this, "CAll has been disconnect", Toast.LENGTH_LONG).show();
break;
}
}
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);
}
}
catch (Exception e)
{
e.printStackTrace();
}
}
And in Callstatechanged method add this code.
public void onCallStateChanged(Context context, int state, String number)
{
if(lastState == state)
{
//No change, debounce extras
return;
}
switch (state)
{
case TelephonyManager.CALL_STATE_RINGING:
isIncoming = true;
callStartTime = new Date();
savedNumber = number;
// onIncomingCallStarted(context, number, callStartTime);
// onIncomingCallEnded(context, savedNumber, callStartTime, new Date());
// onOutgoingCallEnded(context, savedNumber, callStartTime, new Date());
// wasRinging = true;
break;
case TelephonyManager.CALL_STATE_OFFHOOK:
if (!wasRinging) {
// Start your new activity
onIncomingCallEnded(context,savedNumber,callStartTime,new Date());
onOutgoingCallEnded(context,savedNumber,callStartTime,new Date());
} else {
onIncomingCallStarted(context,savedNumber,callStartTime);
// Cancel your old activity
}
// this should be the last piece of code before the break
break;
case TelephonyManager.CALL_STATE_IDLE:
if(isIncoming)
{
onIncomingCallEnded(context, savedNumber, callStartTime, new Date());
}
}
lastState = state;
}
This would work.

call block app android custom number

I want to block a certain phone number from calling me. I coded everything and it's working fine when I put the number within application. But I don't know how to make a custom list of phone numbers that I manually enter after the application is installed. I want to change any number and save it. In PhoneCallStateListener I made a new class of type Resource.java where I extract the number. But it did not work. Please help.
Here is my code:
public class PhoneCallReceiver extends BroadcastReceiver {
#Override
public void onReceive(Context context, Intent intent) {
TelephonyManager telephony = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
PhoneCallStateListener customPhoneListener = new PhoneCallStateListener(context);
telephony.listen(customPhoneListener, PhoneStateListener.LISTEN_CALL_STATE);
}
}
public class PhoneCallStateListener extends PhoneStateListener {
private Context context;
public PhoneCallStateListener(Context context){
this.context = context;
}
#SuppressWarnings("unchecked")
#Override
public void onCallStateChanged(int state, String incomingNumber) {
switch (state) {
case TelephonyManager.CALL_STATE_RINGING:
AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
//Turn ON the mute
audioManager.setStreamMute(AudioManager.STREAM_RING, true);
//i want to getnum from here
Resource res=new Resource();
String get=res.et.getText().toString();
//end of getting num
TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
try {
Class clazz = Class.forName(telephonyManager.getClass().getName());
Method method = clazz.getDeclaredMethod("getITelephony");
method.setAccessible(true);
ITelephony telephonyService = (ITelephony) method.invoke(telephonyManager);
//Checking incoming call number
if (incomingNumber.equalsIgnoreCase(get)) {
telephonyService.silenceRinger();
}
} catch (Exception e) {
e.printStackTrace();
}
//Turn OFF the mute
audioManager.setStreamMute(AudioManager.STREAM_RING, false);
break;
}
super.onCallStateChanged(state, incomingNumber);
}
}
Resource.java file:
public class Resource extends Activity {
Button btsave,btcancel;
EditText et;
#Override
protected void onCreate(Bundle savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
setContentView(R.layout.numbers);
et=(EditText)findViewById(R.id.editNumber);
btsave=(Button)findViewById(R.id.buttonSave);
btcancel=(Button)findViewById(R.id.buttonCancel);
edittext();
}
public void edittext() {
// TODO Auto-generated method stub
InputStreamReader is=new InputStreamReader(this.getResources().openRawResource(R.raw.numtext));
BufferedReader buff=new BufferedReader(is);
StringBuilder finaltext=new StringBuilder();
String line = null;
try{
while((line= buff.readLine())!=null)
{
finaltext.append(line);
}
}
catch(Exception e)
{
e.printStackTrace();
}
et.setText(finaltext);
}
}