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.newSingleThreadExecutor();
        
        private int nextId = 1;

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

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