source: trunk/hiptop/pester/net/sabi/pester/Alarm.java@ 284

package net.sabi.pester;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import danger.app.Application;
import danger.app.IPCMessage;
import danger.audio.RingToneObject;
import danger.internal.Date;
import danger.system.Hardware;
import danger.text.Collator;
import danger.util.LocaleUtils;
import danger.util.StdActiveList;
import danger.util.StdActiveObject;
import danger.util.DEBUG;
import danger.util.format.DateFormat;
import danger.util.format.StringFormat;
import java.util.Comparator;

public class Alarm extends StdActiveObject implements Comparator {
    private static final int VERSION_1 = 1;

    // persisted
    private String mMessage;
    private int mType;
    private int mPeriod;
    private Date mDate;
    private RingToneObject mAlert;

    // transient
    private int mState;
    private int mAbsoluteFireTime; // only valid if periodic
    private danger.app.Alarm mAlarm;
    private int mUID;

    public Alarm() {
        mState = STATE_INVALID;
        mAlarm = new danger.app.Alarm(0, Application.getCurrentApp(), this);
        mUID = 0;
    }

    public String getMessage() {
        return mMessage;
    }
    public int getPeriod() {
        return mPeriod;
    }
    public boolean getUsesPeriod() {
        return mType != TYPE_DATE;
    }
    public boolean getRepeating() {
        return mType == TYPE_PERIODIC_REPEATING;
    }
    public Date getDate() {
        return mDate;
    }
    public RingToneObject getAlert() {
        return mAlert;
    }
    public int getUID() {
        return mUID;
    }

    public void setMessage(String message) {
        mMessage = message;
    }
    public void setPeriod(int period, boolean repeating) {
        mType = repeating ? TYPE_PERIODIC_REPEATING : TYPE_PERIODIC;
        mPeriod = period;
    }
    public void setDate(Date date) {
        mType = TYPE_DATE;
        mDate = date;
    }
    public void setAlert(RingToneObject alert) {
        mAlert = alert.isValid() ? alert : null;
    }
    public void setUID(int uid) {
        mUID = uid;
    }

    public byte[] toByteArray() {
        try {
            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
            DataOutputStream dataStream = new DataOutputStream(byteStream);

            dataStream.writeByte(VERSION_1);
            dataStream.writeUTF(mMessage);
            dataStream.writeInt(mPeriod);
            dataStream.writeInt(mDate.getUnixTimeGMT());
            dataStream.writeInt(mType);
            dataStream.writeInt(mAlert == null ? 0 : mAlert.getID());
            dataStream.flush();
            return byteStream.toByteArray();
        } catch (Exception e) {
            // XXX do something
            DEBUG.p("failed to write alarm:" + e);
        }
        return null;
    }
    
    public void fromByteArray(byte[] data) {
        try {
            ByteArrayInputStream byteStream = new ByteArrayInputStream(data);
            DataInputStream dataStream = new DataInputStream(byteStream);
            
            byte version = dataStream.readByte();
            if (version != VERSION_1) {
                // XXX barf
            }
            mMessage = dataStream.readUTF();
            mPeriod = dataStream.readInt();
            mDate = new Date(dataStream.readInt());
            mType = dataStream.readInt();
            int alertID = dataStream.readInt();
            mAlert = (alertID == 0 ? null : new RingToneObject(alertID));
        } catch (Exception e) {
            // XXX do something
            DEBUG.p("failed to read alarm:" + e);
        }
    }

    void beginEditing() {
        mState = STATE_EDITING;
        mAlarm.deactivate();
    }

    public static int secondsFromNow(Date date) {
        return date.getDangerTimeGMT() - new Date().getDangerTimeGMT();
    }

    protected int remainingInterval() {
        return secondsFromNow(mDate);
    }

    void resume() {
        mState = STATE_SCHEDULED;
        int interval = remainingInterval();
        if (interval < 0) interval = 0;
        mAlarm.resetWake(interval);
        DEBUG.p("resetWake: " + description() + " - " + interval + "s left");
        update();
    }

    void timeChanged() {
        if (mState != STATE_SCHEDULED)
            return;
        if (getUsesPeriod()) {
            int realSecondsLeft = mAbsoluteFireTime - Hardware.getAbsoluteTime();
            mDate = new Date();
            mDate.addSeconds(realSecondsLeft < 0 ? 0 : realSecondsLeft);
            // no need to call resume(): alarm uses absolute time
            update();
        } else {
            resume();
        }
    }

    void schedule() {
        if (getUsesPeriod()) {
            mDate = new Date();
            mDate.addSeconds(mPeriod);
            mAbsoluteFireTime = Hardware.getAbsoluteTime() + mPeriod;
        }
        resume();
    }

    void dismiss() {
        if (getRepeating())
            schedule();
        else
            ((StdActiveList)getDelegate()).removeItem(this);
    }

    void cancel() {
        mState = STATE_INVALID;
        mAlarm.deactivate();
    }

    // XXX not sure if this is featureful enough to be worthwhile
    public IPCMessage getCalendarIPCMessage() {
        if (mState != STATE_SCHEDULED)
            return null;
        IPCMessage message = new IPCMessage();
        message.addItem("action", "new");
        message.addItem("title", getMessage());
        message.addItem("start", mDate.getUnixTimeGMT());
        return message;
    }

    public String description() {
        StringBuffer sb = new StringBuffer();
        switch (mState) {
        case STATE_INVALID: sb.append("invalid "); break;
        case STATE_EDITING: sb.append("editing "); break;
        case STATE_SCHEDULED: sb.append("scheduled "); break;
        }
        switch (mType) {
        case TYPE_PERIODIC:
            sb.append("periodic (").append(mPeriod).append("s) "); break;
        case TYPE_PERIODIC_REPEATING:
            sb.append("repeating periodic (").append(mPeriod).append("s) ");
            break;
        case TYPE_DATE:
            sb.append("date (").append(getDateTimeString()).append(") "); break;
        }
        sb.append("alarm: ");
        sb.append('"').append(mMessage).append('"');
        return sb.toString();
    }

    public static String dateTimeString(Date date, boolean relative) {
        if (date == null)
            return null;
        String layout = LocaleUtils.getDateTimePattern();
        String dateFormat = LocaleUtils.getMediumDateFormat();
        String dateString;
        String timeFormat;
        if (relative) {
            timeFormat = LocaleUtils.getShortTimeFormat();
            int daysFromToday = date.getDaysBetween(new Date());
            if (daysFromToday == 0)
                dateString = "Today"; // XXX localize
            else if (daysFromToday == 1)
                dateString = "Tomorrow"; // XXX localize
            else if (daysFromToday < 7)
                dateString = date.getDayString();
            else
                dateString = DateFormat.withFormat(dateFormat, date);
        } else {
            dateString = DateFormat.withFormat(dateFormat, date);
            timeFormat = LocaleUtils.getMediumTimeFormat();
        }
        String timeString = DateFormat.withFormat(timeFormat, date);
        return StringFormat.withFormat(layout, timeString, dateString);
    }

    protected static void addUnit(StringBuffer sb, int n, String unit) {
        if (n == 0) return;
        if (sb.length() > 0) sb.append(", ");
        if (n == 1) sb.append("one ").append(unit);
        else sb.append(n).append(' ').append(unit).append("s");
    }

    public static String intervalString(int i) { // XXX localize
        if (i < 0)
            return "expired";
        StringBuffer sb = new StringBuffer();
        if (i < 60) {
            addUnit(sb, i, "second");
        } else {
            i /= 60; // minutes
            if (i < 24 * 60) {
                addUnit(sb, i / 60, "hour");
                addUnit(sb, i % 60, "minute");
            } else {
                i /= 60; // hours
                if (i < 365) {
                    addUnit(sb, i / 24, "day");
                    addUnit(sb, i % 24, "hour");
                } else {
                    i /= 24; // days
                    addUnit(sb, i / 365, "year"); // XXX actually 365.242199
                    addUnit(sb, i % 365, "day");
                }
            }
        }
        return sb.toString();
    }

    public int getSecondsUntilNextIntervalStringUpdate() {
        int i = remainingInterval();
        if (i <= 1)
            return 0;
        if (i <= 60)
            return 1;
        if (i <= 24 * 60 * 60) {
            i %= 60;
            return (i == 0 ? 60 : i + 1);
        }
        i %= 3600;
        return (i == 0 ? 3600 : i + 1);
    }

    public String getDateTimeString(boolean relative) {
        return dateTimeString(mDate, relative);
    }

    public String getDateTimeString() {
        return getDateTimeString(false);
    }

    public String getIntervalString() {
        return intervalString(remainingInterval());
    }
   
    public String toString() {
        return getDateTimeString(true) + " - " + mMessage;
    }

    public int compare(Object arg0, Object arg1) {
        Alarm alarm0 = (Alarm)arg0, alarm1 = (Alarm)arg1;
        int result = alarm0.getDate().compareTo(alarm1.getDate());
        if (result != 0) return result;
        result = Collator.getInstance().compare(alarm0.getMessage(),
                                                alarm1.getMessage());
        if (result != 0) return result;
        return alarm0.hashCode() - alarm1.hashCode();
    }

    public static final int TYPE_PERIODIC = 0;
    public static final int TYPE_PERIODIC_REPEATING = 1;
    public static final int TYPE_DATE = 2;

    public static final int STATE_INVALID = 0;
    public static final int STATE_EDITING = 1;
    public static final int STATE_SCHEDULED = 2;
}