Cron jobs with Action Script 3.0

Question

Is there a way to schedule a task (function) to execute at a given date/time with Action Script 3.0? I mean something like schedule(myFunction:Function, dateTime:Date). Thanks

Answer 1

Not natively per se.

SetTimeout as outlined in another answer is probably you're easiest bet. But if you had many things you wanted scheduled, here is a class that could manage it: (it could be modified to use setTimeout instead of a timer, but I prefer timers)

public class Scheduler {
    public var time:Date;
    public var action:Function;
    public var parameters:Array;

    private var checkInterval:Number = NaN;
    public function get interval():Number { return checkInterval; };
    public function set interval(val:Number):void {
        checkInterval = val;
        if (schedules && (mainTimer && mainTimer.delay > val)) {
            mainTimer.delay = val;
        }
    }

    public function Scheduler(time_:Date, action_:Function, interval_:Number = NaN, parameters_:Array = null):void {
        time = time_;
        action = action_;
        checkInterval = interval_;
        parameters = parameters_;
    }

    //static stuff

    private static var mainTimer:Timer;
    public static function stop():void {
        if (mainTimer) {
            mainTimer.stop();
        }
    }

    public static function start():void {
        if (mainTimer && !mainTimer.running) {
            mainTimer.start();
        }
    }

    public static function get curInterval():Number { return (mainTimer) ? mainTimer.delay : 0; };

    private static var scheduleList:Vector.<Scheduler>;
    public static function get schedules():Vector.<Scheduler> { return scheduleList; };


    /**
     * Schedules a function to run at a certain time (with the margin of the interval)
     * @param   time - what time to run this passed action
     * @param   action - a function to call between the time passing, and the next interval
     * @param   interval - how often to check if the time has come, default is 1 second
     * @param   ... rest - parameters to pass to the action method
     * @return
     */
    public static function scheduleAction(time:Date, action:Function, interval:Number = NaN, ... rest):Scheduler {
        var s:Scheduler = new Scheduler(time, action, interval, rest);

        //if already old
        if (time.time < new Date().time) {
            action.apply(null, rest);
            return s;
        }

        if (!scheduleList) {
            scheduleList = new Vector.<Scheduler>();
        }

        scheduleList.push(s);

        if (!mainTimer) {
            mainTimer = new Timer(1000);
            mainTimer.addEventListener(TimerEvent.TIMER, timerTick);
            mainTimer.start();
        }

        if (!isNaN(interval) && interval < mainTimer.delay) {
            mainTimer.delay = interval;
        }

        return s;
    }

    private static function timerTick(e:TimerEvent):void {
        var tmpDate:Date = new Date();
        for (var i:int = scheduleList.length-1; i >= 0;i--){
            if (tmpDate.time >= scheduleList[i].time.time) {
                scheduleList[i].action.apply(null, scheduleList[i].parameters);
                removeSchedule(i);
            }
        }

        checkTimerNeeded();
    }

    private static function checkTimerNeeded():void {
        if (scheduleList && scheduleList.length < 1) {
            mainTimer.stop();
            mainTimer.removeEventListener(TimerEvent.TIMER, timerTick);
            mainTimer = null;
            scheduleList = null;
        }
    }

    private static function removeSchedule(index:int):void {
        scheduleList.splice(index, 1);
        checkTimerNeeded();
    }

    /**
     * Cancels a scheduled item
     * @param   s - the item to cancel
     * @return  returns true if the item was scheduled, false if the item wasn't scheduled
     */
    public static function cancelSchedule(s:Scheduler):Boolean {
        if (scheduleList) {
            var index:int = scheduleList.indexOf(s);
            if (index > 0) {
                removeSchedule(index);
                return true;
            }
        }

        return false;
    }

    public static function status():void {
        trace("isRunning:", (mainTimer) ? mainTimer.running : null);
        trace("List Length:", scheduleList ? scheduleList.length : null);
    }
}

Use as follows:

Scheduler.scheduleAction(myDateToRunTheFunction, myFunctionToRun, howOftenToCheckTime, functionParameter1, functionParameter2, functionParameter2);

Answer 2

Here is a way to do it, it takes in the date to run the function and finds out how long there is to run the function then calls setTimeout

var date:Date = new Date(2012,9,13);
schedule(myFunction,date);

private function myFunction():void
{
    trace("Schedule function run");
}

private function schedule(func:Function,date:Date):void 
{
    var now:Date = new Date();

    if (date.time < now.time)
        return;
    var timetorun:Number =  date.time - now.time;
    setTimeout(func, timetorun);
}