Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## it.gotoandplay.smartfoxserver.util.scheduling
Class Scheduler

    java.lang.Object
      it.gotoandplay.smartfoxserver.util.scheduling.Scheduler

All Implemented Interfaces:
  it.gotoandplay.smartfoxserver.lib.IService, java.lang.Runnable

    public class Scheduler

extends java.lang.Object
implements it.gotoandplay.smartfoxserver.lib.IService, java.lang.Runnable

Task Scheduler class
Handles multiple timed tasks and providing a simple call-back mechanism to notify when it's time to execute the job.
You can add any number of timed tasks to execute.
Behind the scenes the Scheduler uses 1 single thread to handle multiple timed jobs.

Example of usage:

    package it.gotoandplay.smartfoxserver.extensions.examples;

    import java.util.HashMap;
    import java.util.Map;

    import it.gotoandplay.smartfoxserver.data.User;
    import it.gotoandplay.smartfoxserver.events.InternalEventObject;
    import it.gotoandplay.smartfoxserver.extensions.AbstractExtension;
    import it.gotoandplay.smartfoxserver.lib.ActionscriptObject;
    import it.gotoandplay.smartfoxserver.util.scheduling.ITaskHandler;
    import it.gotoandplay.smartfoxserver.util.scheduling.Scheduler;
    import it.gotoandplay.smartfoxserver.util.scheduling.Task;

    public class SchedulerExample extends AbstractExtension
    {
             //This is the class that will handle the callbacks from the Scheduler
            class MyTaskHandler implements ITaskHandler
            {
                    int loopCount = 0;

                    public void doTask(Task task) throws Exception
                    {
                            String id = (String) task.id;
                            String message = "Handling Task >>> { " + id + " }";

                            if (id.equals("looping"))
                            {
                                    loopCount++;
                                    message += ", Loop count: " + loopCount;

                                    if (loopCount == 5)
                                    {
                                            message += ", Stopping Loop!";

                                            // This will stop the execution of the looping task
                                            task.active = false;
                                    }
                            }

                            else if (id.equals("param"))
                            {
                                    message += ", Passed params: " + task.parameters;
                            }

                            System.out.println(message);

                    }
            }

            Scheduler scheduler;
            ITaskHandler handler;

            public void init()
            {
                    trace("Scheduler Example Starts");

                    // Create an instance of the scheduler
                    scheduler = new Scheduler();

                    // Create and instance of the callback handler
                    handler = new MyTaskHandler();

                    // Create a new task
                    Task loopingTaks = new Task("looping");

                    // Create a new task
                    Task normalTask = new Task("normal");

                    // Create a map of parameters that we'll add to the 3rd task
                    Map params = new HashMap();
                    params.put("Italy", "Europe");
                    params.put("Canada", "America");
                    params.put("China", "Asia");

                    // create a new task with the additional parameters
                    Task paramTask = new Task("param", params);

                    // Add tasks to the scheduler
                    scheduler.addScheduledTask(loopingTaks, 3, true, handler);
                    scheduler.addScheduledTask(normalTask, 5, false, handler);
                    scheduler.addScheduledTask(paramTask, 2, false, handler);

                    // Start the scheduler
                    scheduler.startService();

                    //... you can keep adding more tasks at runtime...
            }

            public void destroy()
            {
                    // Remember to stop the scheduler, in order to release its resources
                    scheduler.stopService();
                trace("Scheduler Example Stops");
            }

            public void handleRequest(String cmd, String[] params, User u, int fromRoom)
            {
            }

            public void handleRequest(String cmd, ActionscriptObject ao, User u,int fromRoom)
            {
            }

            public void handleInternalEvent(InternalEventObject ieo)
            {
            }
    }

Since:
  1.6.0
See Also:
  `Task`, `ITaskHandler`

Constructor Summary
`Scheduler()` Default constructor
`Scheduler(long interval)` Constructor with additional parameter Allows to specify the minimum time interval at which the Scheduler checks the list of jobs to execute.

Method Summary
`void` | `addScheduledTask(Task task, int interval, boolean loop, ITaskHandler callback)` Add a new scheduled task
`void` | `destroy(java.lang.Object param)` Destroy the Scheduler and release resources.
`void` | `init(java.lang.Object param)` Initializes the object.
`boolean` | `isRunning()`
`void` | `removeScheduledTask(Task task)` Deprecated.
`void` | `run()`
`void` | `startService()` Starts the service
`void` | `stopService()` Stops the service.

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### Scheduler

    public Scheduler()

  Default constructor

### Scheduler

    public Scheduler(long interval)

  Constructor with additional parameter Allows to specify the minimum time interval at which the Scheduler checks the list of jobs to execute. Example: if you plan that your faster interval will be > 30 seconds then you can set the interval to that value and avoid fast thread switching

  Parameters:
    `interval` - the minimum thread interval

Method Detail

### init

    public void init(java.lang.Object param)

  Initializes the object. This method is already called by the constructor.

  Specified by:
    `init` in interface `it.gotoandplay.smartfoxserver.lib.IService`

### destroy

    public void destroy(java.lang.Object param)

  Destroy the Scheduler and release resources.
  Always use this method when the object is not needed anymore

  Specified by:
    `destroy` in interface `it.gotoandplay.smartfoxserver.lib.IService`

### startService

    public void startService()

  Starts the service

### stopService

    public void stopService()

  Stops the service.

### run

    public void run()

  Specified by:
    `run` in interface `java.lang.Runnable`

### addScheduledTask

    public void addScheduledTask(Task task,
                                 int interval,
                                 boolean loop,
                                 ITaskHandler callback)

  Add a new scheduled task

  Parameters:
    `task` - the task
    `interval` - an amount of time in seconds
    `loop` - true if the task must loop
    `callback` - the callback handler

### removeScheduledTask

    public void removeScheduledTask(Task task)

  Deprecated.

  Removes a scheduled task.
  Instead of using this method, you can remove a task by simply setting its active flag to false.
  This will mark the Task as inactive and ready for deletion inside the Scheduler process list.

  Parameters:
    `task` - the task

### isRunning

    public boolean isRunning()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD