public class FakeService extends Service {
    /**
     * Play alarm up to 10 minutes before silencing
     */
    private static final int ALARM_TIMEOUT_SECONDS = 10 * 60;
    private static final long[] sVibratePattern = new long[]{500, 500};
    public static final String FAKE_SERVICE_PARAM = "FAKE_SERVICE_PARAM";
    private static final int NOTIFICATION_ID = 1;
    private static final String CHANNEL_ID = "ALARM_CHANNEL ID";
    private static final String CHANNEL_NAME = "ALARM_CHANNEL NAME";
    public static String ACTION_ALARM_SNOOZE = "com.troido.intent.action.ACTION_ALARM_SNOOZE";
    private boolean mPlaying = false;
    private Vibrator mVibrator;
    private MediaPlayer mMediaPlayer;
    private TelephonyManager mTelephonyManager;
    private int mInitialCallState;
    BroadcastReceiver snoozeAlarmReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action != null && action.equalsIgnoreCase(ACTION_ALARM_SNOOZE)) {
                stopSelf();
            }
        }
    };
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        if (intent == null) {
            stopSelf();
            return START_NOT_STICKY;
        }
        Commands.ALARM alarmType = (Commands.ALARM) intent.getSerializableExtra(FAKE_SERVICE_PARAM);
        Notification notification = createNotification(alarmType);
        registerSnoozeAlarmReceiver();
        startForeground(NOTIFICATION_ID, notification);
        play(alarmType);
        // Record the initial call state here so that the new alarm has the
        // newest state.
        mInitialCallState = mTelephonyManager.getCallState();
        return START_NOT_STICKY;
    }
    @RequiresApi(Build.VERSION_CODES.O)
    private String createNotificationChannel() {
        String channelId = CHANNEL_ID;
        NotificationChannel chan = new NotificationChannel(channelId, CHANNEL_NAME, NotificationManager.IMPORTANCE_HIGH);
        chan.setLightColor(Color.RED);
        chan.setLockscreenVisibility(Notification.VISIBILITY_PUBLIC);
        NotificationManager service = ((NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE));
        if (service != null) {
            service.createNotificationChannel(chan);
        }
        return channelId;
    }
    private void registerSnoozeAlarmReceiver() {
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(ACTION_ALARM_SNOOZE);
        registerReceiver(snoozeAlarmReceiver, intentFilter);
    }
    private Notification createNotification(Commands.ALARM alarmType) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            createNotificationChannel();
        }
        Intent snoozeIntent = new Intent();
        snoozeIntent.setAction(ACTION_ALARM_SNOOZE);
        PendingIntent snoozePendingIntent =
                PendingIntent.getBroadcast(this, 0, snoozeIntent, 0);
        String alarmText = "";
        if (alarmType == Commands.ALARM.BURGLARY) {
            alarmText += "ALARM FOR BURGLARY IS RINGING..";
        } else if (alarmType == Commands.ALARM.Fire) {
            alarmText += "ALARM FOR FIRE IS RINGING..";
        } else if (alarmType == Commands.ALARM.BOTH) {
            alarmText += "ALARM FOR FIRE AND BURGLARY IS RINGING..";
        }
        NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this, CHANNEL_ID)
                .setSmallIcon(R.drawable.ic_launcher)
                .setContentTitle("ALARM! ALARM! ALARM!")
                .setContentText(alarmText)
                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
                .setContentIntent(snoozePendingIntent)
                .addAction(R.drawable.ic_snooze, getString(R.string.snooze),
                        snoozePendingIntent);
        return mBuilder.build();
    }
    private Uri getUriAlert() {
        Uri alert = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_ALARM);
        if (alert == null) {
            // alert is null, using backup
            alert = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
            // I can't see this ever being null (as always have a default notification)
            // but just incase
            if (alert == null) {
                // alert backup is null, using 2nd backup
                alert = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE);
            }
        }
        return alert;
    }
    // Volume suggested by media team for in-call alarms.
    private static final float IN_CALL_VOLUME = 0.125f;
    private void play(Commands.ALARM alarmType) {
        // stop() checks to see if we are already playing.
        stop();
        Log.v("ALARM", "AlarmKlaxon.play() ");
        // TODO: Reuse mMediaPlayer instead of creating a new one and/or use
        // RingtoneManager.
        mMediaPlayer = new MediaPlayer();
        mMediaPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() {
            public boolean onError(MediaPlayer mp, int what, int extra) {
                Log.e("ALARM", "Error occurred while playing audio.");
                mp.stop();
                mp.release();
                mMediaPlayer = null;
                return true;
            }
        });
        try {
            // Check if we are in a call. If we are, use the in-call alarm
            // resource at a low volume to not disrupt the call.
            if (mTelephonyManager.getCallState()
                    != TelephonyManager.CALL_STATE_IDLE) {
                Log.v("ALARM", "Using the in-call alarm");
                mMediaPlayer.setVolume(IN_CALL_VOLUME, IN_CALL_VOLUME);
                setDataSourceFromResource(getResources(), mMediaPlayer,
                        R.raw.burglary);
            } else {
                if (alarmType == Commands.ALARM.BURGLARY || alarmType == Commands.ALARM.BOTH) {
                    setDataSourceFromResource(getResources(), mMediaPlayer,
                            R.raw.burglary);
                } else if (alarmType == Commands.ALARM.Fire) {
                    setDataSourceFromResource(getResources(), mMediaPlayer,
                            R.raw.fire);
                }
            }
            startAlarm(mMediaPlayer);
        } catch (Exception ex) {
            Log.v("ALARM", "Using the fallback ringtone");
            // The alert may be on the sd card which could be busy right
            // now. Use the fallback ringtone.
            try {
                // Must reset the media player to clear the error state.
                mMediaPlayer.reset();
                setDataSourceFromResource(getResources(), mMediaPlayer,
                        R.raw.burglary);
                startAlarm(mMediaPlayer);
            } catch (Exception ex2) {
                // At this point we just don't play anything.
                Log.e("ALARM", "Failed to play fallback ringtone", ex2);
            }
        }
        /* Start the vibrator after everything is ok with the media player */
        mVibrator.vibrate(sVibratePattern, 0);
        enableKiller();
        mPlaying = true;
    }
    // Do the common stuff when starting the alarm.
    private void startAlarm(MediaPlayer player)
            throws java.io.IOException, IllegalArgumentException,
            IllegalStateException {
        final AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
        // do not play alarms if stream volume is 0
        // (typically because ringer mode is silent).
        if (audioManager != null && audioManager.getStreamVolume(AudioManager.STREAM_ALARM) != 0) {
            player.setAudioStreamType(AudioManager.STREAM_ALARM);
            player.setLooping(true);
            player.prepare();
            player.start();
        }
    }
    private void setDataSourceFromResource(Resources resources,
                                           MediaPlayer player, int res) throws java.io.IOException {
        AssetFileDescriptor afd = resources.openRawResourceFd(res);
        if (afd != null) {
            player.setDataSource(afd.getFileDescriptor(), afd.getStartOffset(),
                    afd.getLength());
            afd.close();
        }
    }
    /**
     * Stops alarm audio and disables alarm if it not snoozed and not
     * repeating
     */
    public void stop() {
        Log.v("TAG", "AlarmKlaxon.stop()");
        if (mPlaying) {
            mPlaying = false;
            // Stop audio playing
            if (mMediaPlayer != null) {
                mMediaPlayer.stop();
                mMediaPlayer.release();
                mMediaPlayer = null;
            }
            // Stop vibrator
            mVibrator.cancel();
        }
        disableKiller();
    }
    /**
     * Kills alarm audio after ALARM_TIMEOUT_SECONDS, so the alarm
     * won't run all day.
     * <p>
     * This just cancels the audio, but leaves the notification
     * popped, so the user will know that the alarm tripped.
     */
    private void enableKiller() {
        mHandler.sendMessageDelayed(mHandler.obtainMessage(KILLER, ""),
                1000 * ALARM_TIMEOUT_SECONDS);
    }
    private void disableKiller() {
        mHandler.removeMessages(KILLER);
    }
    // Internal messages
    private static final int KILLER = 1000;
    @SuppressLint("HandlerLeak")
    private Handler mHandler = new Handler() {
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case KILLER:
                    Log.v("ALARM", "*********** Alarm killer triggered ***********");
                    stopSelf();
                    break;
            }
        }
    };
    private PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
        @Override
        public void onCallStateChanged(int state, String ignored) {
            // The user might already be in a call when the alarm fires. When
            // we register onCallStateChanged, we get the initial in-call state
            // which kills the alarm. Check against the initial call state so
            // we don't kill the alarm during a call.
            if (state != TelephonyManager.CALL_STATE_IDLE
                    && state != mInitialCallState) {
                stopSelf();
            }
        }
    };
    @Override
    public void onCreate() {
        mVibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
        // Listen for incoming calls to kill the alarm.
        mTelephonyManager =
                (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
        if (mTelephonyManager != null) {
            mTelephonyManager.listen(
                    mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
        }
        AlarmAlertWakeLock.acquireCpuWakeLock(this);
    }
    @Override
    public void onDestroy() {
        stop();
        // Stop listening for incoming calls.
        mTelephonyManager.listen(mPhoneStateListener, 0);
        AlarmAlertWakeLock.releaseCpuLock();
        unregisterReceiver(snoozeAlarmReceiver);
    }
}