2 * Copyright 2015 Samsung Electronics All Rights Reserved.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package oic.simulator.clientcontroller.manager;
19 import java.util.ArrayList;
20 import java.util.Date;
21 import java.util.HashMap;
22 import java.util.LinkedList;
24 import oic.simulator.clientcontroller.Activator;
25 import oic.simulator.clientcontroller.listener.ILogUIListener;
26 import oic.simulator.clientcontroller.utils.Constants;
27 import oic.simulator.logger.LogEntry;
28 import oic.simulator.logger.LoggerCallback;
30 import org.eclipse.jface.resource.ImageRegistry;
31 import org.eclipse.swt.graphics.Image;
32 import org.oic.simulator.ILogger;
33 import org.oic.simulator.ILogger.Level;
34 import org.oic.simulator.SimulatorManager;
37 * Class which handles the native logs, maintains log entries and updates the
40 public class LogManager {
41 private LinkedList<LogEntry> entries = new LinkedList<LogEntry>();
42 private ArrayList<ILogUIListener> listeners = new ArrayList<ILogUIListener>();
43 private LinkedList<LogEntry> visibleEntries = new LinkedList<LogEntry>();
44 private HashMap<Integer, Boolean> visibleSeverities = new HashMap<Integer, Boolean>();
46 private ILogger logger;
47 private LogManagerSynchronizerThread synchronizerThread;
48 private Thread threadHandle;
51 synchronizerThread = new LogManagerSynchronizerThread();
52 threadHandle = new Thread(synchronizerThread);
53 threadHandle.setName("OIC Simulator event queue");
56 // Set the logger callback with the native layer
57 logger = new LoggerCallback();
58 SimulatorManager.setLogger(logger);
61 private static class LogManagerSynchronizerThread implements Runnable {
63 LinkedList<Runnable> eventQueue = new LinkedList<Runnable>();
67 while (!Thread.interrupted()) {
71 while (eventQueue.isEmpty()) {
75 } catch (InterruptedException e) {
82 pop = eventQueue.pop();
86 } catch (Exception e) {
87 if (e instanceof InterruptedException) {
95 public void addToQueue(Runnable event) {
97 eventQueue.add(event);
103 public void log(int severity, Date date, String msg) {
104 final LogEntry logEntry = new LogEntry(severity, date, msg);
105 synchronizerThread.addToQueue(new Runnable() {
108 boolean notify = false;
109 synchronized (entries) {
110 entries.add(logEntry);
111 Boolean showEntry = LogManager.this.visibleSeverities
112 .get(logEntry.getSeverity());
113 if (showEntry != null) {
115 visibleEntries.add(logEntry);
119 if (entries.size() > Constants.LOG_SIZE) {
122 if (visibleEntries.size() > Constants.LOG_SIZE) {
123 visibleEntries.pop();
128 notifyListeners(logEntry);
134 public void applyFilter(final HashMap<Integer, Boolean> visibleSeverities) {
135 synchronizerThread.addToQueue(new Runnable() {
139 LinkedList<LogEntry> newLogs = new LinkedList<LogEntry>();
140 synchronized (entries) {
141 LogManager.this.visibleSeverities = visibleSeverities;
142 for (LogEntry logEntry : entries) {
143 if (LogManager.this.visibleSeverities.get(logEntry
145 newLogs.add(logEntry);
149 visibleEntries = newLogs;
156 private void notifyListeners() {
157 for (ILogUIListener l : listeners) {
158 l.logChanged(new ArrayList<LogEntry>(visibleEntries));
162 private void notifyListeners(LogEntry added) {
163 for (ILogUIListener l : listeners) {
168 public void clearLog() {
169 synchronizerThread.addToQueue(new Runnable() {
173 synchronized (entries) {
174 entries = new LinkedList<LogEntry>();
175 visibleEntries = new LinkedList<LogEntry>();
182 public void removeEntry(final LogEntry element) {
183 synchronizerThread.addToQueue(new Runnable() {
187 synchronized (entries) {
188 entries.remove(element);
189 visibleEntries.remove(element);
196 public ArrayList<LogEntry> getLogEntries() {
197 synchronized (entries) {
198 return new ArrayList<LogEntry>(entries);
202 public void addLogListener(final ILogUIListener listener) {
203 synchronizerThread.addToQueue(new Runnable() {
206 if (!listeners.contains(listener)) {
207 listeners.add(listener);
213 public void removeLogListener(final ILogUIListener listener) {
214 synchronizerThread.addToQueue(new Runnable() {
217 if (!listeners.contains(listener)) {
218 listeners.remove(listener);
224 public void shutdown() {
225 threadHandle.interrupt();
228 public static String getSeverityName(int severity) {
229 if (severity == Level.INFO.ordinal()) {
230 return Constants.INFO;
231 } else if (severity == Level.WARNING.ordinal()) {
232 return Constants.WARNING;
233 } else if (severity == Level.ERROR.ordinal()) {
234 return Constants.ERROR;
235 } else if (severity == Level.DEBUG.ordinal()) {
236 return Constants.DEBUG;
238 return Constants.UNKNOWN;
242 public static Image getSeverityIcon(int severity) {
243 ImageRegistry r = Activator.getDefault().getImageRegistry();
244 if (severity == Level.INFO.ordinal()) {
245 return r.get(Constants.INFO_LOG);
246 } else if (severity == Level.WARNING.ordinal()) {
247 return r.get(Constants.WARNING_LOG);
248 } else if (severity == Level.ERROR.ordinal()) {
249 return r.get(Constants.ERROR_LOG);
250 } else if (severity == Level.DEBUG.ordinal()) {
251 return r.get(Constants.DEBUG_LOG);
253 return r.get(Constants.UNKNOWN_LOG);