<uses-permission android:name="android.permission.DISABLE_KEYGUARD" />
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
<activity android:name=".alarmclock.AlarmAlert" android:label="@string/alert_title"
            android:excludeFromRecents="true"
            android:theme="@android:style/Theme.Dialog"
            android:launchMode="singleTask"
            android:showOnLockScreen="true"
            android:taskAffinity=":AlarmAlert"
            android:screenOrientation="sensorPortrait"
            android:configChanges="orientation|keyboardHidden|keyboard|navigation" />

 import android.app.Activity;
        import android.app.Dialog;
        import android.app.KeyguardManager;
        import android.content.Context;
        import android.content.DialogInterface;
        import android.content.Intent;
        import android.content.SharedPreferences;
        import android.content.res.Configuration;
        import android.graphics.PixelFormat;
        import android.os.Bundle;
        import android.view.KeyEvent;
        import android.view.View;
        import android.view.ViewGroup;
        import android.view.LayoutInflater;
        import android.view.WindowManager;
        import android.widget.Button;
        import android.widget.Toast;
        import android.widget.TextView;
        import android.os.PowerManager;
        import android.content.pm.ActivityInfo;

        import java.util.Calendar;

        import com.gufa.myalarm2.R;

public class AlarmAlert extends Activity implements Alarms.AlarmSettings {

    private static final int SNOOZE_MINUTES = 10;
    private static final int UNKNOWN = 0;
    private static final int SNOOZE = 1;
    private static final int DISMISS = 2;
    private static final int KILLED = 3;
    private KeyguardManager mKeyguardManager;
    private KeyguardManager.KeyguardLock mKeyguardLock;
    private Button mSnoozeButton;
    private int mState = UNKNOWN;
    private AlarmKlaxon mKlaxon;
    private int mAlarmId;
    private AlarmPreference mAlarmPref;
    private String mLabel;
    private ShakeListener mShakeListener;
    private int mSnooze;
    private int mDuration;
    private int mCaptchaSnooze, mCaptchaDismiss;
    private boolean mCaptchaShown = false;
    private boolean mCaptchaDone = false;
    private PowerManager.WakeLock mWakeLock;
    public static final String DEBUG_TAG = AlarmReceiver.class.getSimpleName();

    @Override

    protected void onCreate(Bundle icicle) {
        super.onCreate(icicle);
        AlarmAlertWakeLock.acquire(this);
        Log.v("AlarmAlert.onCreate()");
        setWindowSettings();
        releaseWakeLock();
        acquireWakeLock();

        WindowManager.LayoutParams lp = getWindow().getAttributes();
        lp.width = ViewGroup.LayoutParams.WRAP_CONTENT;
        lp.height = ViewGroup.LayoutParams.WRAP_CONTENT;
        lp.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
        lp.token = null;
        getWindow().setAttributes(lp);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);

        mKeyguardManager = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE);

        Intent i = getIntent();
        mAlarmId = i.getIntExtra(Alarms.ID, -1);

        Alarms.getAlarm(getContentResolver(), this, mAlarmId);

        mKlaxon = new AlarmKlaxon();
        mKlaxon.postPlay(this, mAlarmId);

        setTitleFromIntent(i);

        Alarms.disableSnoozeAlert(AlarmAlert.this);
        Alarms.disableAlert(AlarmAlert.this, mAlarmId);
        Alarms.setNextAlert(this);

        mKlaxon.setKillerCallback(new AlarmKlaxon.KillerCallback() {
            public void onKilled() {
                if (Log.LOGV) Log.v("onKilled()");
                updateSilencedText();

                /* don't allow snooze */
                mSnoozeButton.setEnabled(false);

                dismiss();
                mState = KILLED;
            }
        });

        updateLayout();

        SharedPreferences settings = getSharedPreferences(AlarmClock.PREFERENCES, 0);
        if (settings.getBoolean(AlarmClock.PREF_SHAKE_SNOOZE, true)) {
            mShakeListener = new ShakeListener(this);
            mShakeListener.setOnShakeListener(new ShakeListener.OnShakeListener() {
                public void onShake() {
                    snooze();
                    if (mCaptchaSnooze == 0)
                        finish();
                }
            });
        }
    }

    private void setTitleFromIntent(Intent i) {
        mLabel = i.getStringExtra(Alarms.LABEL);
        if (mLabel == null || mLabel.length() == 0) {
            mLabel = getString(R.string.default_label);
        }
        setTitle(mLabel);
    }
    private void setWindowSettings()
    {
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

        int currentOrientation = getResources().getConfiguration().orientation;
        if (currentOrientation == Configuration.ORIENTATION_LANDSCAPE)
        {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
        } else
        {
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
        }}

    public void acquireWakeLock()
    {
       PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
        mWakeLock = pm.newWakeLock(PowerManager.ACQUIRE_CAUSES_WAKEUP
                | PowerManager.ON_AFTER_RELEASE
                | PowerManager.PARTIAL_WAKE_LOCK, "alarming_wakelock");
        mWakeLock.acquire();
    }

    public void releaseWakeLock()
    {
              if (mWakeLock != null)
        {
            if (mWakeLock.isHeld())
            {
                mWakeLock.release();
                mWakeLock = null;
            }
        }
    }

    private void updateSilencedText() {
        TextView silenced = (TextView) findViewById(R.id.silencedText);
        silenced.setText(getString(R.string.alarm_alert_alert_silenced,
                mDuration / 1000*60));
        silenced.setVisibility(View.VISIBLE);
    }

    private void updateLayout() {
        setContentView(R.layout.alarm_alert);

        AlarmAlertWakeLock.acquire(this);
        LayoutInflater mFactory = LayoutInflater.from(this);
        SharedPreferences settings =
                getSharedPreferences(AlarmClock.PREFERENCES, 0);
        int face = settings.getInt(AlarmClock.PREF_CLOCK_FACE, 0);
        if (face < 0 || face >= AlarmClock.CLOCKS.length) {
            face = 0;
        }
        View clockLayout =
                (View) mFactory.inflate(AlarmClock.CLOCKS[face], null);
        ViewGroup clockView = (ViewGroup) findViewById(R.id.clockView);
        clockView.addView(clockLayout);
        if (clockLayout instanceof DigitalClock) {
            ((DigitalClock) clockLayout).setAnimate();
        }

        mSnoozeButton = (Button) findViewById(R.id.snooze);
        if (mSnooze > 0) {
            mSnoozeButton.requestFocus();
            mSnoozeButton.setVisibility(View.VISIBLE);
        }
        else { // hide the snooze button if snooze disabled for this alarm
            mSnoozeButton.setVisibility(View.GONE);
        }
  
        if (mState == KILLED) {
            updateSilencedText();
            mSnoozeButton.setEnabled(false);
        } else {
            mSnoozeButton.setOnClickListener(new Button.OnClickListener() {
                public void onClick(View v) {
                    snooze();
                    if (mCaptchaSnooze == 0)
                        finish();
                }
            });
        }

        findViewById(R.id.dismiss).setOnClickListener(
                new Button.OnClickListener() {
                    public void onClick(View v) {
                        dismiss();
                        if (mCaptchaDismiss == 0)
                            finish();
                    }
                });
    }

    private void snooze() {
        if (mState != UNKNOWN) {
            return;
        }
        if (mSnooze == 0) { // snooze disabled for this alarm
            return;
        }
        if (mCaptchaSnooze != 0 && !mCaptchaDone) {
            show_captcha(mCaptchaSnooze, SNOOZE);
            return;
        }

        final long snoozeTime = System.currentTimeMillis()
                + (1000 * 60 * mSnooze);
        final long nextAlarm =
                Alarms.calculateNextAlert(AlarmAlert.this).getAlert();
        String displayTime = null;
        if (nextAlarm < snoozeTime) {
            final Calendar c = Calendar.getInstance();
            c.setTimeInMillis(nextAlarm);
            displayTime = getString(R.string.alarm_alert_snooze_not_set,
                    Alarms.formatTime(AlarmAlert.this, c));
            mState = DISMISS;
        } else {
            Alarms.saveSnoozeAlert(AlarmAlert.this, mAlarmId, snoozeTime,
                    mLabel);
            Alarms.setNextAlert(AlarmAlert.this);
            displayTime = getString(R.string.alarm_alert_snooze_set,
                    mSnooze);
            mState = SNOOZE;
        }
        Log.v(displayTime);
        Toast.makeText(AlarmAlert.this, displayTime, Toast.LENGTH_LONG).show();
        mKlaxon.stop(this, mState == SNOOZE);
        releaseLocks();
        finish();
    }

    private void dismiss() {
        if (mState != UNKNOWN) {
            return;
        }
        if (mCaptchaDismiss != 0 && !mCaptchaDone) {
            show_captcha(mCaptchaDismiss, DISMISS);
            return;
        }
        mState = DISMISS;
        mKlaxon.stop(this, false);
        releaseLocks();
        finish();
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        AlarmAlertWakeLock.acquire(this);
        if (Log.LOGV) Log.v("AlarmAlert.OnNewIntent()");
        mState = UNKNOWN;
        mSnoozeButton.setEnabled(true);
        disableKeyguard();

        mAlarmId = intent.getIntExtra(Alarms.ID, -1);
         mKlaxon.postPlay(this, mAlarmId);

        setTitleFromIntent(intent);

        TextView silenced = (TextView)findViewById(R.id.silencedText);
        silenced.setVisibility(View.GONE);

        Alarms.setNextAlert(this);
        setIntent(intent);
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (Log.LOGV) Log.v("AlarmAlert.onResume()");
        disableKeyguard();

        if (mShakeListener != null)
            mShakeListener.resume();
    }

    @Override
    protected void onStop() {
        super.onStop();
        AlarmAlertWakeLock.acquire(this);
        if (Log.LOGV) Log.v("AlarmAlert.onStop()");
        snooze();
        releaseLocks();

        if (mShakeListener != null)
            mShakeListener.pause();
    }

    @Override
    public void onConfigurationChanged(Configuration config) {
        super.onConfigurationChanged(config);
        updateLayout();
    }

    @Override
    public boolean dispatchKeyEvent(KeyEvent event) {
        boolean up = event.getAction() == KeyEvent.ACTION_UP;
        boolean dismiss = false;
        switch (event.getKeyCode()) {
            case KeyEvent.KEYCODE_DPAD_UP:
            case KeyEvent.KEYCODE_DPAD_DOWN:
            case KeyEvent.KEYCODE_DPAD_LEFT:
            case KeyEvent.KEYCODE_DPAD_RIGHT:
            case KeyEvent.KEYCODE_DPAD_CENTER:
             case KeyEvent.KEYCODE_ENDCALL:
                break;
            case KeyEvent.KEYCODE_VOLUME_UP:
            case KeyEvent.KEYCODE_VOLUME_DOWN:
                dismiss = true;
                 default:
                        if (mState == UNKNOWN && up) {
                    if (dismiss) {
                        dismiss();
                    } else {
                        snooze();
                    }
                }
 
                return true;
        }
        return super.dispatchKeyEvent(event);
    }

    private synchronized void enableKeyguard() {
        if (mKeyguardLock != null) {
            mKeyguardLock.reenableKeyguard();
            mKeyguardLock = null;
        }
    }

    private synchronized void disableKeyguard() {
        if (mKeyguardLock == null) {
            mKeyguardLock = mKeyguardManager.newKeyguardLock(Log.LOGTAG);
            mKeyguardLock.disableKeyguard();
        }
    }

    private synchronized void releaseLocks() {
        AlarmAlertWakeLock.release();
        enableKeyguard();
    }


    public void reportAlarm(
            int idx, boolean enabled, int hour, int minutes,
            Alarms.DaysOfWeek daysOfWeek, boolean vibrate, String message, String alert,
            int snooze, int duration, int delay, boolean vibrate_only,
            int volume, int crescendo,
            int captcha_snooze, int captcha_dismiss
    ) {
        mSnooze = snooze;
        mCaptchaSnooze = captcha_snooze;
        mCaptchaDismiss = captcha_dismiss;
        mDuration = duration;

        updateLayout();
    }

    private void show_captcha(int captcha_type, int which_state)
    {
        CaptchaInterface captcha;
        if (captcha_type == Alarms.CAPTCHA_TYPE_PUZZLE) {
            captcha = new PuzzleCaptcha(this);
        }
        else
        if (captcha_type == Alarms.CAPTCHA_TYPE_MATH) {
            captcha = new MathCaptcha(this);
        }
        else
            return;
        if (mCaptchaShown) return;
        mCaptchaShown = true;
        final int which = which_state;
        captcha.setOnCorrectListener(new CaptchaInterface.OnCorrectListener() {
            public void onCorrect() {
                mCaptchaDone = true;
                if (which == SNOOZE) {
                    snooze();
                }
                else
                if (which == DISMISS) {
                    dismiss();
                }
                finish();
            }
        });
        ((Dialog)captcha).setOnDismissListener(new DialogInterface.OnDismissListener() {
            public void onDismiss(DialogInterface dialog) {
                mCaptchaShown = false;
            }
        });
        captcha.show();
    }

}

   <uses-permission android:name="android.permission.WAKE_LOCK"/>