BartRunnerAndroid/src/com/dougkeen/bart/model/Departure.java

701 lines
19 KiB
Java

package com.dougkeen.bart.model;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.lang3.time.DateFormatUtils;
import android.app.AlarmManager;
import android.app.Notification;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.v4.app.NotificationCompat;
import android.support.v4.app.NotificationCompat.Builder;
import android.text.format.DateFormat;
import android.util.Log;
import com.dougkeen.bart.BartRunnerApplication;
import com.dougkeen.bart.R;
import com.dougkeen.bart.services.BoardedDepartureService;
import com.dougkeen.util.Observable;
public class Departure implements Parcelable, Comparable<Departure> {
private static final int MINIMUM_MERGE_OVERLAP_MILLIS = 5000;
private static final int EXPIRE_MINUTES_AFTER_ARRIVAL = 1;
public Departure() {
super();
}
public Departure(String destinationAbbr, String destinationColor,
String platform, String direction, boolean bikeAllowed,
String trainLength, int minutes) {
super();
this.trainDestination = Station.getByAbbreviation(destinationAbbr);
this.destinationColor = destinationColor;
this.platform = platform;
this.direction = direction;
this.bikeAllowed = bikeAllowed;
this.trainLength = trainLength;
this.minutes = minutes;
}
public Departure(Parcel in) {
readFromParcel(in);
}
private Station origin;
private Station trainDestination;
private Station passengerDestination;
private Line line;
private String destinationColor;
private String platform;
private String direction;
private boolean bikeAllowed;
private String trainLength;
private boolean requiresTransfer;
private boolean transferScheduled;
private int minutes;
private long minEstimate;
private long maxEstimate;
private int estimatedTripTime;
private boolean beganAsDeparted;
private long arrivalTimeOverride;
private Observable<Integer> alarmLeadTimeMinutes = new Observable<Integer>(
0);
private Observable<Boolean> alarmPending = new Observable<Boolean>(false);
private boolean listedInETDs = true;
private boolean selected;
public Station getOrigin() {
return origin;
}
public void setOrigin(Station origin) {
this.origin = origin;
}
public Station getTrainDestination() {
return trainDestination;
}
public void setTrainDestination(Station destination) {
this.trainDestination = destination;
}
public String getTrainDestinationName() {
if (trainDestination != null)
return trainDestination.name;
return null;
}
public String getTrainDestinationAbbreviation() {
if (trainDestination != null)
return trainDestination.abbreviation;
return null;
}
public Station getPassengerDestination() {
return passengerDestination;
}
public void setPassengerDestination(Station passengerDestination) {
this.passengerDestination = passengerDestination;
}
public StationPair getStationPair() {
if (passengerDestination != null) {
return new StationPair(origin, passengerDestination);
} else {
return null;
}
}
public Line getLine() {
return line;
}
public void setLine(Line line) {
this.line = line;
}
public String getTrainDestinationColor() {
return destinationColor;
}
public void setTrainDestinationColor(String destinationColor) {
this.destinationColor = destinationColor;
}
public String getPlatform() {
return platform;
}
public void setPlatform(String platform) {
this.platform = platform;
}
public String getDirection() {
return direction;
}
public void setDirection(String direction) {
this.direction = direction;
}
public boolean isBikeAllowed() {
return bikeAllowed;
}
public void setBikeAllowed(boolean bikeAllowed) {
this.bikeAllowed = bikeAllowed;
}
public String getTrainLength() {
return trainLength;
}
public void setTrainLength(String trainLength) {
this.trainLength = trainLength;
}
public String getTrainLengthText() {
return trainLength + " car train";
}
public boolean getRequiresTransfer() {
return requiresTransfer;
}
public void setRequiresTransfer(boolean requiresTransfer) {
this.requiresTransfer = requiresTransfer;
}
public boolean isTransferScheduled() {
return transferScheduled;
}
public void setTransferScheduled(boolean transferScheduled) {
this.transferScheduled = transferScheduled;
}
public int getMinutes() {
return minutes;
}
public void setMinutes(int minutes) {
this.minutes = minutes;
if (minutes == 0) {
beganAsDeparted = true;
}
}
public long getMinEstimate() {
return minEstimate;
}
public void setMinEstimate(long minEstimate) {
this.minEstimate = minEstimate;
}
public long getMaxEstimate() {
return maxEstimate;
}
public void setMaxEstimate(long maxEstimate) {
this.maxEstimate = maxEstimate;
}
public int getEstimatedTripTime() {
return estimatedTripTime;
}
public void setEstimatedTripTime(int estimatedTripTime) {
this.estimatedTripTime = estimatedTripTime;
}
public boolean hasEstimatedTripTime() {
return this.estimatedTripTime > 0;
}
public boolean hasAnyArrivalEstimate() {
return this.estimatedTripTime > 0 || this.arrivalTimeOverride > 0;
}
public int getUncertaintySeconds() {
return (int) (maxEstimate - minEstimate + 1000) / 2000;
}
public int getMinSecondsLeft() {
return (int) ((getMinEstimate() - System.currentTimeMillis()) / 1000);
}
public int getMaxSecondsLeft() {
return (int) ((getMaxEstimate() - System.currentTimeMillis()) / 1000);
}
public int getMeanSecondsLeft() {
return (int) getMeanSecondsLeft(getMinEstimate(), getMaxEstimate());
}
public int getMeanSecondsLeft(long min, long max) {
return (int) ((getMeanEstimate(min, max) - System.currentTimeMillis()) / 1000);
}
public long getMeanEstimate() {
return getMeanEstimate(getMinEstimate(), getMaxEstimate());
}
public long getMeanEstimate(long min, long max) {
return (min + max) / 2;
}
public long getArrivalTimeOverride() {
return arrivalTimeOverride;
}
public void setArrivalTimeOverride(long arrivalTimeOverride) {
this.arrivalTimeOverride = arrivalTimeOverride;
}
public long getEstimatedArrivalTime() {
if (arrivalTimeOverride > 0) {
return arrivalTimeOverride;
}
return getMeanEstimate() + getEstimatedTripTime();
}
public long getEstimatedArrivalMinutesLeft() {
long millisLeft = getEstimatedArrivalTime()
- System.currentTimeMillis();
if (millisLeft < 0) {
return -1;
} else {
// Add ~30s to emulate rounding
return (millisLeft + 29999) / (60 * 1000);
}
}
public String getEstimatedArrivalMinutesLeftText(Context context) {
if (!hasAnyArrivalEstimate()) {
return "Estimated arrival unknown";
}
long minutesLeft = getEstimatedArrivalMinutesLeft();
if (minutesLeft < 0) {
return "Arrived at destination";
} else if (minutesLeft == 0) {
return "Arrives ~" + getEstimatedArrivalTimeText(context)
+ " (<1 min)";
} else if (minutesLeft == 1) {
return "Arrives ~" + getEstimatedArrivalTimeText(context)
+ " (1 min)";
} else {
return "Arrives ~" + getEstimatedArrivalTimeText(context) + " ("
+ minutesLeft + " mins)";
}
}
public String getEstimatedArrivalTimeText(Context context) {
if (getEstimatedTripTime() > 0 || arrivalTimeOverride > 0) {
return DateFormat.getTimeFormat(context).format(
new Date(getEstimatedArrivalTime()));
} else {
return "";
}
}
public boolean hasDeparted() {
return getMeanSecondsLeft() <= 0;
}
public void calculateEstimates(long originalEstimateTime) {
setMinEstimate(originalEstimateTime + (getMinutes() * 60 * 1000)
- (30000));
setMaxEstimate(getMinEstimate() + 60000);
}
public void mergeEstimate(Departure departure) {
if (departure.hasDeparted() && origin.longStationLinger
&& getMinEstimate() > 0 && !beganAsDeparted) {
/*
* This is probably not a true departure, but an indication that the
* train is in the station. Don't update the estimates.
*/
return;
}
boolean wasDeparted = hasDeparted();
if (!hasAnyArrivalEstimate() && departure.hasAnyArrivalEstimate()) {
setArrivalTimeOverride(departure.getArrivalTimeOverride());
setEstimatedTripTime(departure.getEstimatedTripTime());
}
long newMin = Math.max(getMinEstimate(), departure.getMinEstimate());
long newMax = Math.min(getMaxEstimate(), departure.getMaxEstimate());
if ((getMaxEstimate() - departure.getMinEstimate()) < MINIMUM_MERGE_OVERLAP_MILLIS
|| departure.getMaxEstimate() - getMinEstimate() < MINIMUM_MERGE_OVERLAP_MILLIS) {
/*
* The estimate must have changed... just use the latest incoming
* values
*/
newMin = departure.getMinEstimate();
newMax = departure.getMaxEstimate();
}
/*
* If the new departure would mark this as departed, and we have < 60
* seconds left on a fairly accurate local estimate, ignore the incoming
* departure
*/
if (!wasDeparted && getMeanSecondsLeft(newMin, newMax) <= 0
&& getMeanSecondsLeft() < 60 && getUncertaintySeconds() < 30) {
Log.d(Constants.TAG,
"Skipping estimate merge, since it would make this departure show as 'departed' prematurely");
return;
}
if (newMax > newMin) {
// We must never have 0 or negative uncertainty
setMinEstimate(newMin);
setMaxEstimate(newMax);
}
}
public boolean hasExpired() {
final long now = System.currentTimeMillis();
return getMaxEstimate() < now
&& getEstimatedArrivalTime() + EXPIRE_MINUTES_AFTER_ARRIVAL
* 60000 < now;
}
public int compareTo(Departure another) {
return (this.getMeanSecondsLeft() > another.getMeanSecondsLeft()) ? 1
: ((this.getMeanSecondsLeft() == another.getMeanSecondsLeft()) ? 0
: -1);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + (bikeAllowed ? 1231 : 1237);
result = prime
* result
+ ((trainDestination == null) ? 0 : trainDestination.hashCode());
result = prime
* result
+ ((destinationColor == null) ? 0 : destinationColor.hashCode());
result = prime * result
+ ((direction == null) ? 0 : direction.hashCode());
result = prime * result + ((line == null) ? 0 : line.hashCode());
result = prime * result + (int) (maxEstimate ^ (maxEstimate >>> 32));
result = prime * result + (int) (minEstimate ^ (minEstimate >>> 32));
result = prime * result + minutes;
result = prime * result
+ ((platform == null) ? 0 : platform.hashCode());
result = prime * result + (requiresTransfer ? 1231 : 1237);
result = prime * result
+ ((trainLength == null) ? 0 : trainLength.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Departure other = (Departure) obj;
if (bikeAllowed != other.bikeAllowed)
return false;
if (trainDestination != other.trainDestination)
return false;
if (destinationColor == null) {
if (other.destinationColor != null)
return false;
} else if (!destinationColor.equals(other.destinationColor))
return false;
if (direction == null) {
if (other.direction != null)
return false;
} else if (!direction.equals(other.direction))
return false;
if (line != other.line)
return false;
if (Math.abs(maxEstimate - other.maxEstimate) > getEqualsTolerance())
return false;
if (platform == null) {
if (other.platform != null)
return false;
} else if (!platform.equals(other.platform))
return false;
if (requiresTransfer != other.requiresTransfer)
return false;
if (trainLength == null) {
if (other.trainLength != null)
return false;
} else if (!trainLength.equals(other.trainLength))
return false;
return true;
}
private int getEqualsTolerance() {
if (origin != null) {
return origin.departureEqualityTolerance;
} else {
return Station.DEFAULT_DEPARTURE_EQUALITY_TOLERANCE;
}
}
public String getCountdownText() {
StringBuilder builder = new StringBuilder();
int secondsLeft = getMeanSecondsLeft();
if (hasDeparted()) {
if (origin != null && origin.longStationLinger && beganAsDeparted) {
builder.append("At station");
} else if (isListedInETDs()) {
builder.append(BartRunnerApplication.getAppContext().getString(
R.string.leaving));
} else {
builder.append(BartRunnerApplication.getAppContext().getString(
R.string.departed));
}
} else {
builder.append(secondsLeft / 60);
builder.append("m, ");
builder.append(secondsLeft % 60);
builder.append("s");
}
return builder.toString();
}
public String getUncertaintyText() {
if (hasDeparted()) {
return "";
} else {
return "" + getUncertaintySeconds() + "s)";
}
}
public boolean isListedInETDs() {
return listedInETDs;
}
public void setListedInETDs(boolean listedInETDs) {
this.listedInETDs = listedInETDs;
}
public boolean isSelected() {
return selected;
}
public void setSelected(boolean selected) {
this.selected = selected;
}
public int getAlarmLeadTimeMinutes() {
return alarmLeadTimeMinutes.getValue();
}
public Observable<Integer> getAlarmLeadTimeMinutesObservable() {
return alarmLeadTimeMinutes;
}
public boolean isAlarmPending() {
return alarmPending.getValue();
}
public Observable<Boolean> getAlarmPendingObservable() {
return alarmPending;
}
private PendingIntent getAlarmIntent(Context context) {
return PendingIntent.getBroadcast(context, 0, new Intent(
Constants.ACTION_ALARM, getStationPair().getUri()),
PendingIntent.FLAG_UPDATE_CURRENT);
}
private long getAlarmClockTime() {
return getMeanEstimate() - alarmLeadTimeMinutes.getValue() * 60 * 1000;
}
public int getSecondsUntilAlarm() {
return getMeanSecondsLeft() - getAlarmLeadTimeMinutes() * 60;
}
public void setUpAlarm(int leadTimeMinutes) {
this.alarmLeadTimeMinutes.setValue(leadTimeMinutes);
this.alarmPending.setValue(true);
}
public void updateAlarm(Context context, AlarmManager alarmManager) {
if (alarmManager == null)
return;
if (isAlarmPending() && getAlarmLeadTimeMinutes() > 0) {
final PendingIntent alarmIntent = getAlarmIntent(context);
alarmManager.cancel(alarmIntent);
long alarmTime = getAlarmClockTime();
alarmManager.set(AlarmManager.RTC_WAKEUP, alarmTime, alarmIntent);
if (Log.isLoggable(Constants.TAG, Log.VERBOSE))
Log.v(Constants.TAG,
"Scheduling alarm for "
+ DateFormatUtils.format(alarmTime, "h:mm:ss"));
}
}
public void cancelAlarm(Context context, AlarmManager alarmManager) {
alarmManager.cancel(getAlarmIntent(context));
this.alarmPending.setValue(false);
}
private PendingIntent notificationIntent;
private PendingIntent getNotificationIntent(Context context) {
if (notificationIntent == null) {
Intent targetIntent = new Intent(Intent.ACTION_VIEW,
getStationPair().getUri());
targetIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
notificationIntent = PendingIntent.getActivity(context, 0,
targetIntent, PendingIntent.FLAG_UPDATE_CURRENT);
}
return notificationIntent;
}
public Notification createNotification(Context context) {
final int halfMinutes = (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(context,
BoardedDepartureService.class);
cancelAlarmIntent.putExtra("cancelNotifications", true);
Builder notificationBuilder = new NotificationCompat.Builder(context)
.setOngoing(true)
.setSmallIcon(R.drawable.ic_stat_notification)
.setContentTitle(
getOrigin().shortName + " to "
+ getPassengerDestination().shortName)
.setContentIntent(getNotificationIntent(context)).setWhen(0);
if (android.os.Build.VERSION.SDK_INT >= 16) {
notificationBuilder.setPriority(NotificationCompat.PRIORITY_HIGH)
.setContentText(minutesText + " until departure");
if (isAlarmPending()) {
notificationBuilder.addAction(
R.drawable.ic_action_cancel_alarm,
"Cancel alarm",
PendingIntent.getService(context, 0, cancelAlarmIntent,
PendingIntent.FLAG_UPDATE_CURRENT)).setSubText(
"Alarm " + getAlarmLeadTimeMinutes()
+ " minutes before departure");
}
} else if (isAlarmPending()) {
notificationBuilder.setContentText(minutesText
+ " to departure (alarm at " + getAlarmLeadTimeMinutes()
+ " min" + ((getAlarmLeadTimeMinutes() == 1) ? "" : "s")
+ ")");
} else {
notificationBuilder
.setContentText(minutesText + " until departure");
}
return notificationBuilder.build();
}
@Override
public String toString() {
java.text.DateFormat format = SimpleDateFormat.getTimeInstance();
StringBuilder builder = new StringBuilder();
builder.append(trainDestination);
if (requiresTransfer) {
builder.append(" (w/ xfer)");
}
builder.append(", ");
builder.append(getCountdownText());
builder.append(", ");
builder.append(format.format(new Date(getMeanEstimate())));
return builder.toString();
}
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(origin.abbreviation);
dest.writeString(trainDestination.abbreviation);
dest.writeString(passengerDestination == null ? null
: passengerDestination.abbreviation);
dest.writeString(destinationColor);
dest.writeString(platform);
dest.writeString(direction);
dest.writeByte((byte) (bikeAllowed ? 1 : 0));
dest.writeString(trainLength);
dest.writeByte((byte) (requiresTransfer ? 1 : 0));
dest.writeInt(minutes);
dest.writeLong(minEstimate);
dest.writeLong(maxEstimate);
dest.writeLong(arrivalTimeOverride);
dest.writeInt(estimatedTripTime);
dest.writeInt(line.ordinal());
dest.writeByte(beganAsDeparted ? (byte) 1 : (byte) 0);
dest.writeByte(bikeAllowed ? (byte) 1 : (byte) 0);
dest.writeByte(requiresTransfer ? (byte) 1 : (byte) 0);
dest.writeByte(transferScheduled ? (byte) 1 : (byte) 0);
}
private void readFromParcel(Parcel in) {
origin = Station.getByAbbreviation(in.readString());
trainDestination = Station.getByAbbreviation(in.readString());
passengerDestination = Station.getByAbbreviation(in.readString());
destinationColor = in.readString();
platform = in.readString();
direction = in.readString();
bikeAllowed = in.readByte() != 0;
trainLength = in.readString();
requiresTransfer = in.readByte() != 0;
minutes = in.readInt();
minEstimate = in.readLong();
maxEstimate = in.readLong();
arrivalTimeOverride = in.readLong();
estimatedTripTime = in.readInt();
line = Line.values()[in.readInt()];
beganAsDeparted = in.readByte() == (byte) 1;
bikeAllowed = in.readByte() == (byte) 1;
requiresTransfer = in.readByte() == (byte) 1;
transferScheduled = in.readByte() == (byte) 1;
}
public static final Parcelable.Creator<Departure> CREATOR = new Parcelable.Creator<Departure>() {
public Departure createFromParcel(Parcel in) {
return new Departure(in);
}
public Departure[] newArray(int size) {
return new Departure[size];
}
};
public void notifyAlarmHasBeenHandled() {
this.alarmPending.setValue(false);
}
}