adressevedligehold/tasks/TaskManager.java

package dk.daoas.adressevedligehold.tasks;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import dk.daoas.adressevedligehold.tasks.Task.TaskBean;
import dk.daoas.adressevedligehold.tasks.Task.TaskState;

public class TaskManager {
        
        public static final String TASKMANAGER = "TASKMANAGER";
        
        ExecutorService executor = Executors.newFixedThreadPool(1);
        
        private int nextId = 1;

        
        private ArrayList<Task> tasks = new ArrayList<Task>();
        private HashMap<Integer, Task> taskIdMap = new HashMap<Integer,Task>();

        private Task currentTask;
        
        public synchronized List<TaskBean> getTasks() {
                ArrayList<TaskBean> tmpList = new ArrayList<TaskBean>();
                for (Task t : tasks) {
                        tmpList.add( t.getTaskBean() );
                }
                
                Collections.reverse(tmpList);
                
                return tmpList;
        }
        
        public void setCurrentTask(Task task) {
                this.currentTask = task;
        }
        
        public Task getCurrentTask() {
                return this.currentTask;
        }
        
        public Task getTaskById(int id) {
                return taskIdMap.get(id);
        }
        
        void shutDown() {
                if (currentTask != null) {
                        currentTask.doAbort();  
                }
                
                executor.shutdownNow();
        }
        
        public synchronized void removeTask(Task removeTask) {
                if (removeTask.state == TaskState.STATE_QUEUED) {
                        removeTask.doAbort();
                }
                
                if (removeTask.state == TaskState.STATE_ABORTED || removeTask.state == TaskState.STATE_DONE || removeTask.state == TaskState.STATE_QUEUED) {
                        taskIdMap.remove( removeTask.getId() );
                        tasks.remove(removeTask);
                        return;
                }
                
                
                throw new RuntimeException("Cant remove task in current state:" + removeTask.state);
                
        }
        
        public synchronized void submitTask(Task newTask) {
                int id = getNextTaskid();
                newTask.setId(id);
                
                newTask.setManager(this);
                
                taskIdMap.put(id, newTask);
                tasks.add(newTask);
                executor.submit(newTask);
        }
        
        private synchronized int getNextTaskid() {
                return nextId++;
        }
        

}
1	torben	2838	package dk.daoas.adressevedligehold.tasks;
2
3			import java.util.ArrayList;
4			import java.util.Collections;
5	torben	2903	import java.util.HashMap;
6	torben	2838	import java.util.List;
7			import java.util.concurrent.ExecutorService;
8			import java.util.concurrent.Executors;
9
10			import dk.daoas.adressevedligehold.tasks.Task.TaskBean;
11	torben	2918	import dk.daoas.adressevedligehold.tasks.Task.TaskState;
12	torben	2838
13			public class TaskManager {
14
15			public static final String TASKMANAGER = "TASKMANAGER";
16
17			ExecutorService executor = Executors.newFixedThreadPool(1);
18	torben	2903
19			private int nextId = 1;
20	torben	2838
21
22			private ArrayList<Task> tasks = new ArrayList<Task>();
23	torben	2903	private HashMap<Integer, Task> taskIdMap = new HashMap<Integer,Task>();
24	torben	2838
25			private Task currentTask;
26
27	torben	2903	public synchronized List<TaskBean> getTasks() {
28	torben	2838	ArrayList<TaskBean> tmpList = new ArrayList<TaskBean>();
29			for (Task t : tasks) {
30			tmpList.add( t.getTaskBean() );
31			}
32
33			Collections.reverse(tmpList);
34
35			return tmpList;
36			}
37
38			public void setCurrentTask(Task task) {
39			this.currentTask = task;
40			}
41
42			public Task getCurrentTask() {
43			return this.currentTask;
44			}
45
46	torben	2903	public Task getTaskById(int id) {
47			return taskIdMap.get(id);
48			}
49
50	torben	2838	void shutDown() {
51			if (currentTask != null) {
52			currentTask.doAbort();
53			}
54
55			executor.shutdownNow();
56			}
57
58	torben	2918	public synchronized void removeTask(Task removeTask) {
59	torben	2928	if (removeTask.state == TaskState.STATE_QUEUED) {
60			removeTask.doAbort();
61			}
62
63			if (removeTask.state == TaskState.STATE_ABORTED \|\| removeTask.state == TaskState.STATE_DONE \|\| removeTask.state == TaskState.STATE_QUEUED) {
64	torben	2918	taskIdMap.remove( removeTask.getId() );
65			tasks.remove(removeTask);
66	torben	2928	return;
67	torben	2918	}
68	torben	2928
69
70			throw new RuntimeException("Cant remove task in current state:" + removeTask.state);
71
72	torben	2918	}
73
74	torben	2903	public synchronized void submitTask(Task newTask) {
75			int id = getNextTaskid();
76			newTask.setId(id);
77
78	torben	2838	newTask.setManager(this);
79
80	torben	2903	taskIdMap.put(id, newTask);
81	torben	2838	tasks.add(newTask);
82			executor.submit(newTask);
83			}
84
85	torben	2903	private synchronized int getNextTaskid() {
86			return nextId++;
87			}
88
89	torben	2838
90			}