AudioManager manager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
                        manager.setRingerMode(AudioManager.RINGER_MODE_SILENT);

package my.package;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.media.AudioManager;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.provider.CallLog;
import android.telephony.TelephonyManager;
import android.util.Log;

public class PhoneReceiver extends BroadcastReceiver {

private DbHelperAdapter mDbHelper;
private DbHelperAdapter mDbHelperFive;
private DbHelperAdapter mDbHelperSix;
private static final int RINGER_MODE_SILENT = 0;
private static final int RINGER_MODE_VIBRATE = 1;
private static final int RINGER_MODE_NORMAL = 2;
public static final String PREFS_NAME = "MyPrefsFile";

int indexOfCurrentNumber = 0;

private Context context;

@Override
public void onReceive(Context context, Intent intent) {
    RingerMode ringMode = new RingerMode();
    Log.i("jens", "RingerMode: "+ringMode.getRingerMode(context));
    this.context = context;
    Bundle extras = intent.getExtras();
    //AudioManager manager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);

    SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME,
            Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = prefs.edit();
    int incommingcall = 0;
    int incommingcallanswered = 0;

    incommingcallanswered = prefs.getInt("incommingcallanswered", 0);
    incommingcall = prefs.getInt("incommingcall", 0);
    //boolean prefCallLogStatus = prefs.getBoolean(SettingsActivity.KEY_PREF_CALLLOG, false);
    int prefMissedCallsLimit = prefs.getInt("missedCallInCallLog", 3);
    int prefMinutesCallInCallLog = prefs.getInt("minutesCallInCallLog", 3);

    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
    boolean prefCallLogStatus = sp.getBoolean(SettingsActivity.KEY_PREF_CALLLOG, false);

    Log.i("jens", "prefCallLogStatus: "+prefCallLogStatus);
    Log.i("jens", "prefMissedCallsLimit: "+prefMissedCallsLimit);
    //SharedPreferences sharedPref = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
    // If there has been an incomming call

    if (extras != null) {
        String state = extras.getString(TelephonyManager.EXTRA_STATE);

        Log.i("jens", "phone state: "+state);
        //User ended call
        if (state.equals(TelephonyManager.EXTRA_STATE_IDLE)) {

            if (incommingcall == 1 || incommingcallanswered == 1){

                try {
                    //when Idle i.e no call
                    //Toast.makeText(context, "Phone state IDLE", Toast.LENGTH_LONG).show();
                    //SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME,
                    //      Context.MODE_PRIVATE);
                    int ringermode = 0;
                    ringermode = prefs.getInt("oldringermode", -1);
                    RingerMode setR = new RingerMode();
                    Log.i("jens", "ringermode value: "+ringermode);
                    //Change profile back to previous state
                    if (ringermode == RINGER_MODE_NORMAL) {
                        //AudioManager manager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
                        AudioManager manager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
                        manager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
                        //setR.setRingerMode(context, RINGER_MODE_NORMAL);
                        //manager.setRingerMode(RINGER_MODE_NORMAL);
                    }else if (ringermode == RINGER_MODE_SILENT) {
                        //AudioManager manager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
                        AudioManager manager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
                        manager.setRingerMode(AudioManager.RINGER_MODE_SILENT);
                        //setR.setRingerMode(context, RINGER_MODE_SILENT);
                        //manager.setRingerMode(RINGER_MODE_SILENT);
                    }else if (ringermode == RINGER_MODE_VIBRATE) {
                        //AudioManager manager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
                        AudioManager manager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
                        manager.setRingerMode(AudioManager.RINGER_MODE_VIBRATE);

                        //manager.setRingerMode(RINGER_MODE_VIBRATE);
                    }else{
                        //Failed
                        Log.e("DEBUG", "Failed to reset ringermode in PhoneReceiver");

                    }
                    //Log.i("jens", "Ringermode in IDLE: "+manager.getRingerMode());
                    //Change shared preference to show not imcomming call
                    editor.putInt("incommingcall", 0);
                    editor.putInt("incommingcallanswered", 0);
                    // Commit the edits!
                    editor.commit();
                } catch (Exception e) {
                    Log.i("********************************", ""+e);
                }


            }else{
                //If not an incomming call
                editor.putInt("incommingcall", 0);
                editor.commit();
            }
        }


        else if (state.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)) {
            Log.i("********************************", "Phone state OFFHOOK");
            //Toast.makeText(context, "Phone state OFFHOOK", Toast.LENGTH_LONG).show();
            //when Off hook i.e in call
            //Make intent and start your service here
            incommingcall = prefs.getInt("incommingcall", -1);

            //Incomming call or not
            if (incommingcall == 1){
                editor.putInt("incommingcallanswered", 1);
            }else{
                editor.putInt("incommingcallanswered", 0);
                editor.putInt("incommingcall", 0);
            }

            // Commit the edits!
            editor.commit();

            //Toast.makeText(context, "Phone state Off hook", Toast.LENGTH_LONG).show();
        }


        //Phone is ringing
        else if (state.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
            Log.i("jens", "Phone state RINGING");
            mDbHelper = new DbHelperAdapter(context);
            try {
                String incomingPhoneNumber = extras
                        .getString(TelephonyManager.EXTRA_INCOMING_NUMBER);
                Log.i("jens", "bundle number"+incomingPhoneNumber);

                //check if phonenumbers is in whitelist in database (phonenumbers table)


                mDbHelper.open();

                // Check if the calling number is in the white list
                Cursor cur = mDbHelper.fetchActiveNormalList(incomingPhoneNumber);

                //count to see if the number is in the whitelist
                int i = cur.getCount();
                // Fetch the index of the Current number
                while (cur.moveToNext())
                {
                    indexOfCurrentNumber = cur.getInt(0);
                }
                cur.close();
                mDbHelper.close();

                ////check if denyphonenumbers is in blacklist in database (denyphonenumbers table)
                mDbHelperFive = new DbHelperAdapter(context);
                mDbHelperFive.open();

                // Check if the calling number is in the white list
                Cursor cursorFive = mDbHelperFive.fetchActiveSilentList(incomingPhoneNumber);

                //count to see if there is one number in the list
                int l = cursorFive.getCount();
                cursorFive.close();
                mDbHelperFive.close();


                ////check if denyphonenumbers is in blacklist in database (denyphonenumbers table)
                mDbHelperSix = new DbHelperAdapter(context);
                mDbHelperSix.open();

                // Check if the calling number is in the white list
                Cursor cursorSix = mDbHelperSix.fetchActiveVibrateList(incomingPhoneNumber);

                //count to see if there is one number in the list
                int m = cursorSix.getCount();
                cursorSix.close();
                mDbHelperSix.close();

                Log.i("jens", "VALUE of i: "+i);
                int listStatus = 0;

                if (i > 0){
                    //Number exists in whitelist
                    listStatus = 1;
                }else if (l > 0){
                    //Number exists in blacklist
                    listStatus = 2;
                }else if (m > 0){
                    //Number exists in blacklist
                    listStatus = 3;
                }
                if (listStatus == 0){
                    // Call log checkbox is checked in preferences
                    if (prefCallLogStatus == true){
                        listStatus = 4;
                    }
                }
                Log.i("jens", "VALUE of listStatus: "+listStatus);


                int oldringermode;
                RingerMode setR = new RingerMode();
                switch (listStatus) {
                //case 0:
                //  Log.i("jens", "Case 0");
                // Number exists in whiteList
                case 1:
                    Log.i("jens", "Case 1 Normal : "+i);
                    //Store old ringermode value in shared preference
                    oldringermode = setR.getRingerMode(context);
                    editor.putInt("oldringermode", oldringermode);
                    editor.putInt("incommingcall", 1);
                    // Commit the edits!
                    editor.commit();
                    // Change ringermode to allow sound

                    setR.setRingerMode(context, RINGER_MODE_NORMAL);

                    break;

                    // Number set to silent
                case 2:
                    Log.i("jens","Case 2 Silent ");
                    oldringermode = setR.getRingerMode(context);
                    editor.putInt("oldringermode", oldringermode);
                    editor.putInt("incommingcall", 1);
                    // Commit the edits!
                    editor.commit();
                    // Change ringermode to block sound

                    setR.setRingerMode(context, RINGER_MODE_SILENT);
                    //manager.setRingerMode(AudioManager.RINGER_MODE_SILENT);
                    break;
                    // Number set to vibrate
                case 3:
                    //number set to vibrate
                    Log.i("jens","Case 3 Vibrate ");
                    oldringermode = setR.getRingerMode(context);
                    editor.putInt("oldringermode", oldringermode);
                    editor.putInt("incommingcall", 1);
                    // Commit the edits!
                    editor.commit();
                    // Change ringermode to block sound
                    setR.setRingerMode(context, RINGER_MODE_VIBRATE);
                    //manager.setRingerMode(AudioManager.RINGER_MODE_VIBRATE);
                    break;

                    // Number does not exist in white or black list
                case 4:
                    Log.i("jens", "Case 4 ");
                    //int minutes = 3; // The number of minutes to be fetched from the callLog
                    long timestamp = System.currentTimeMillis();
                    timestamp = timestamp - (60000 * prefMinutesCallInCallLog); // The number of minutes to be fetched from the callLog

                    String projection[] = new String[] {CallLog.Calls.NUMBER, CallLog.Calls.TYPE, CallLog.Calls.DATE  };
                    String selection = CallLog.Calls.NUMBER+" = '" + incomingPhoneNumber +"' AND " + CallLog.Calls.DATE + " > "+ timestamp + " "    ;
                    //String selectionArgs[] = new String[] { (String.valueOf(CallLog.Calls.INCOMING_TYPE)) , (resetDate) };
                    Log.i("jens", "selection: "+selection);
                    // Fetch last three minutes from callLog
                    Cursor managedCursor = context.getContentResolver().query(android.provider.CallLog.Calls.CONTENT_URI, projection,
                            selection , null, null);

                    int responseCount = managedCursor.getCount();
                    Log.i("jens","responseCount: "+responseCount);
                    Log.i("jens","prefMissedCallsLimit: "+prefMissedCallsLimit);
                    // If there is more than X calls in callLog
                    if (responseCount > (prefMissedCallsLimit-1))
                    {
                        Log.i("jens","responseCount > (prefMissedCallsLimit-1) setting normal" );
                        oldringermode = setR.getRingerMode(context);
                        editor.putInt("oldringermode", oldringermode);
                        editor.putInt("incommingcall", 1);
                        // Commit the edits!
                        editor.commit();
                        // Change ringermode to block sound
                        setR.setRingerMode(context, RINGER_MODE_NORMAL);
                        //manager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);

                    }
                    break;

                default: listStatus = 0;
                Log.i("jens", "No Case");
                break;
                }

            } catch (Exception e) {
                // TODO Auto-generated catch block
                Log.i("jens", ""+e);
            }
            mDbHelper.close();
            Log.i("jens", "Phone state RINGING stopped");
        }
    }
}
}