BartRunnerAndroid/src/com/dougkeen/bart/services/NotificationService.java

package com.dougkeen.bart.services;

import java.util.List;

import org.apache.commons.lang3.time.DateFormatUtils;

import android.app.AlarmManager;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.Parcelable;
import android.os.SystemClock;
import android.support.v4.app.NotificationCompat;
import android.support.v4.app.NotificationCompat.Builder;
import android.util.Log;

import com.dougkeen.bart.BartRunnerApplication;
import com.dougkeen.bart.R;
import com.dougkeen.bart.model.Constants;
import com.dougkeen.bart.model.Departure;
import com.dougkeen.bart.model.StationPair;
import com.dougkeen.bart.services.EtdService.EtdServiceBinder;
import com.dougkeen.bart.services.EtdService.EtdServiceListener;

public class NotificationService extends Service implements EtdServiceListener {

	private static final int DEPARTURE_NOTIFICATION_ID = 123;

	private volatile Looper mServiceLooper;
	private volatile ServiceHandler mServiceHandler;

	private boolean mBound = false;
	private EtdService mEtdService;
	private StationPair mStationPair;
	private NotificationManager mNotificationManager;
	private AlarmManager mAlarmManager;
	private PendingIntent mNotificationIntent;
	private PendingIntent mAlarmPendingIntent;
	private int mAlertLeadTime;
	private Handler mHandler;
	private boolean mHasShutDown = false;

	public NotificationService() {
		super();
	}

	private final class ServiceHandler extends Handler {
		public ServiceHandler(Looper looper) {
			super(looper);
		}

		@Override
		public void handleMessage(Message msg) {
			onHandleIntent((Intent) msg.obj);
		}
	}

	private final ServiceConnection mConnection = new ServiceConnection() {
		@Override
		public void onServiceDisconnected(ComponentName name) {
			mEtdService = null;
			mBound = false;
		}

		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			mEtdService = ((EtdServiceBinder) service).getService();
			if (getStationPair() != null) {
				mEtdService.registerListener(NotificationService.this, false);
			}
			mBound = true;
		}
	};

	@Override
	public void onCreate() {
		HandlerThread thread = new HandlerThread(
				"BartRunnerNotificationService");
		thread.start();

		mServiceLooper = thread.getLooper();
		mServiceHandler = new ServiceHandler(mServiceLooper);

		bindService(new Intent(this, EtdService.class), mConnection,
				Context.BIND_AUTO_CREATE);
		mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
		mAlarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
		mHandler = new Handler();
		super.onCreate();
	}

	@Override
	public void onStart(Intent intent, int startId) {
		Message msg = mServiceHandler.obtainMessage();
		msg.arg1 = startId;
		msg.obj = intent;
		mServiceHandler.sendMessage(msg);
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		mHasShutDown = false;
		onStart(intent, startId);
		return START_STICKY;
	}

	@Override
	public void onDestroy() {
		shutDown(true);
		if (mBound)
			unbindService(mConnection);
		mServiceLooper.quit();
		super.onDestroy();
	}

	protected void onHandleIntent(Intent intent) {
		final Departure boardedDeparture = ((BartRunnerApplication) getApplication())
				.getBoardedDeparture();
		if (boardedDeparture == null
				|| intent.getBooleanExtra("cancelAlarm", false)) {
			// Nothing to notify about, or we want to cancel the alarm
			shutDown(false);
			return;
		}

		Bundle bundle = intent.getExtras();
		StationPair oldStationPair = mStationPair;
		mStationPair = boardedDeparture.getStationPair();
		mAlertLeadTime = bundle.getInt("alertLeadTime");

		if (mEtdService != null && mStationPair != null
				&& !mStationPair.equals(oldStationPair)) {
			mEtdService.unregisterListener(this);
		}

		if (getStationPair() != null && mEtdService != null) {
			mEtdService.registerListener(this, false);
		}

		Intent targetIntent = new Intent(Intent.ACTION_VIEW,
				mStationPair.getUri());
		targetIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
		mNotificationIntent = PendingIntent.getActivity(this, 0, targetIntent,
				PendingIntent.FLAG_UPDATE_CURRENT);

		updateNotification();

		setAlarm();

		pollDepartureStatus();
	}

	private void refreshAlarmPendingIntent() {
		final Intent alarmIntent = new Intent(Constants.ACTION_ALARM,
				getStationPair().getUri());
		final Departure boardedDeparture = ((BartRunnerApplication) getApplication())
				.getBoardedDeparture();
		alarmIntent.putExtra("departure", (Parcelable) boardedDeparture);
		mAlarmPendingIntent = PendingIntent.getBroadcast(this, 0, alarmIntent,
				PendingIntent.FLAG_UPDATE_CURRENT);
	}

	private void setAlarm() {
		cancelAlarm();

		if (mAlertLeadTime > 0) {
			long alertTime = getAlarmClockTime();
			if (alertTime > System.currentTimeMillis()) {
				if (Log.isLoggable(Constants.TAG, Log.VERBOSE))
					Log.v(Constants.TAG, "Scheduling alarm for "
							+ DateFormatUtils.format(alertTime, "h:mm:ss"));
				refreshAlarmPendingIntent();
				mAlarmManager.set(AlarmManager.RTC_WAKEUP, alertTime,
						mAlarmPendingIntent);
				((BartRunnerApplication) getApplication())
						.setAlarmPending(true);
			}
		}
	}

	private void triggerAlarmImmediately() {
		Log.v(Constants.TAG, "Setting off alarm immediately");
		cancelAlarm();
		refreshAlarmPendingIntent();
		mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
				SystemClock.elapsedRealtime() + 100, mAlarmPendingIntent);
	}

	private long getAlarmClockTime() {
		final Departure boardedDeparture = ((BartRunnerApplication) getApplication())
				.getBoardedDeparture();
		return boardedDeparture.getMeanEstimate() - mAlertLeadTime * 60 * 1000;
	}

	private void cancelAlarm() {
		((BartRunnerApplication) getApplication()).setAlarmPending(false);
		if (mAlarmManager != null) {
			mAlarmManager.cancel(mAlarmPendingIntent);
		}
	}

	@Override
	public void onETDChanged(List<Departure> departures) {
		final Departure boardedDeparture = ((BartRunnerApplication) getApplication())
				.getBoardedDeparture();
		for (Departure departure : departures) {
			if (departure.equals(boardedDeparture)
					&& (boardedDeparture.getMeanSecondsLeft() != departure
							.getMeanSecondsLeft() || boardedDeparture
							.getUncertaintySeconds() != departure
							.getUncertaintySeconds())) {
				long initialAlertClockTime = getAlarmClockTime();

				boardedDeparture.mergeEstimate(departure);

				final long now = System.currentTimeMillis();
				final long newAlarmClockTime = getAlarmClockTime();
				if (initialAlertClockTime > now && newAlarmClockTime <= now) {
					// Alert time was changed to the past
					triggerAlarmImmediately();
				} else if (newAlarmClockTime > now) {
					// Alert time is still in the future
					setAlarm();
				}

				break;
			}
		}
	}

	@Override
	public void onError(String errorMessage) {
		// Do nothing
	}

	@Override
	public void onRequestStarted() {
		// Do nothing
	}

	@Override
	public void onRequestEnded() {
		// Do nothing
	}

	@Override
	public StationPair getStationPair() {
		return mStationPair;
	}

	private long mNextScheduledCheckClockTime = 0;

	private void pollDepartureStatus() {
		final Departure boardedDeparture = ((BartRunnerApplication) getApplication())
				.getBoardedDeparture();

		if (boardedDeparture.hasDeparted()) {
			shutDown(false);
		}

		// Departure must have changed... fire the alarm
		if (getAlarmClockTime() < System.currentTimeMillis()) {
			triggerAlarmImmediately();
		}

		updateNotification();

		final int pollIntervalMillis = getPollIntervalMillis();
		final long scheduledCheckClockTime = System.currentTimeMillis()
				+ pollIntervalMillis;
		if (mNextScheduledCheckClockTime < scheduledCheckClockTime) {
			mHandler.postDelayed(new Runnable() {
				@Override
				public void run() {
					pollDepartureStatus();
				}
			}, pollIntervalMillis);
			mNextScheduledCheckClockTime = scheduledCheckClockTime;
		}
	}

	private void shutDown(boolean isBeingDestroyed) {
		if (!mHasShutDown) {
			mHasShutDown = true;
			if (mEtdService != null) {
				mEtdService.unregisterListener(this);
			}
			if (mNotificationManager != null) {
				mNotificationManager.cancel(DEPARTURE_NOTIFICATION_ID);
			}
			cancelAlarm();
			if (!isBeingDestroyed)
				stopSelf();
		}
	}

	private void updateNotification() {
		if (mHasShutDown) {
			if (mEtdService != null) {
				mEtdService.unregisterListener(this);
			}
			return;
		}

		final Departure boardedDeparture = ((BartRunnerApplication) getApplication())
				.getBoardedDeparture();
		final int halfMinutes = (boardedDeparture.getMeanSecondsLeft() + 15) / 30;
		float minutes = halfMinutes / 2f;
		final String minutesText = (minutes < 1) ? "Less than one minute"
				: (String.format("~%.1f minute", minutes) + ((minutes != 1.0) ? "s"
						: ""));

		final Intent cancelAlarmIntent = new Intent(getApplicationContext(),
				NotificationService.class);
		cancelAlarmIntent.putExtra("cancelAlarm", true);
		Builder notificationBuilder = new NotificationCompat.Builder(this)
				.setOngoing(true)
				.setSmallIcon(R.drawable.ic_stat_notification)
				.setContentTitle(
						mStationPair.getOrigin().shortName + " to "
								+ mStationPair.getDestination().shortName)
				.setContentIntent(mNotificationIntent).setWhen(0);
		if (android.os.Build.VERSION.SDK_INT >= 16) {
			notificationBuilder
					.setPriority(NotificationCompat.PRIORITY_HIGH)
					.addAction(
							R.drawable.ic_action_cancel_alarm,
							"Cancel alarm",
							PendingIntent.getService(getApplicationContext(),
									0, cancelAlarmIntent,
									PendingIntent.FLAG_UPDATE_CURRENT))
					.setContentText(minutesText + " until departure")
					.setSubText(
							"Alert " + mAlertLeadTime
									+ " minutes before departure");
		} else {
			notificationBuilder.setContentText(minutesText
					+ " to departure (alarm at " + mAlertLeadTime + " min"
					+ ((mAlertLeadTime == 1) ? "" : "s") + ")");
		}

		mNotificationManager.notify(DEPARTURE_NOTIFICATION_ID,
				notificationBuilder.build());
	}

	private int getPollIntervalMillis() {
		final Departure boardedDeparture = ((BartRunnerApplication) getApplication())
				.getBoardedDeparture();
		final int secondsToAlarm = boardedDeparture.getMeanSecondsLeft()
				- mAlertLeadTime * 60;

		if (secondsToAlarm < -20) {
			/* Alarm should have already gone off by now */
			shutDown(false);
			return 10000000; // Arbitrarily large number
		}

		if (secondsToAlarm > 3 * 60) {
			return 15 * 1000;
		} else {
			return 6 * 1000;
		}
	}

	@Override
	public IBinder onBind(Intent intent) {
		// Doesn't support binding
		return null;
	}
}