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.clientcontroller.utils.Utility;
28 import oic.simulator.logger.LogEntry;
29 import oic.simulator.logger.LoggerCallback;
31 import org.eclipse.jface.resource.ImageRegistry;
32 import org.eclipse.swt.graphics.Image;
33 import org.oic.simulator.ILogger;
34 import org.oic.simulator.ILogger.Level;
35 import org.oic.simulator.SimulatorException;
36 import org.oic.simulator.SimulatorManager;
39 * Class which handles the native logs, maintains log entries and updates the
42 public class LogManager {
43 private LinkedList<LogEntry> entries = new LinkedList<LogEntry>();
44 private ArrayList<ILogUIListener> listeners = new ArrayList<ILogUIListener>();
45 private LinkedList<LogEntry> visibleEntries = new LinkedList<LogEntry>();
46 private HashMap<Integer, Boolean> visibleSeverities = new HashMap<Integer, Boolean>();
48 private ILogger logger;
49 private LogManagerSynchronizerThread synchronizerThread;
50 private Thread threadHandle;
53 synchronizerThread = new LogManagerSynchronizerThread();
54 threadHandle = new Thread(synchronizerThread);
55 threadHandle.setName("OIC Simulator event queue");
58 // Set the logger callback with the native layer
59 logger = new LoggerCallback();
61 SimulatorManager.setLogger(logger);
62 } catch (SimulatorException e) {
63 log(Level.ERROR.ordinal(),
65 "Failed to register the logger.\n"
66 + Utility.getSimulatorErrorString(e, null));
70 private static class LogManagerSynchronizerThread implements Runnable {
72 LinkedList<Runnable> eventQueue = new LinkedList<Runnable>();
76 while (!Thread.interrupted()) {
80 while (eventQueue.isEmpty()) {
84 } catch (InterruptedException e) {
91 pop = eventQueue.pop();
95 } catch (Exception e) {
96 if (e instanceof InterruptedException) {
104 public void addToQueue(Runnable event) {
105 synchronized (this) {
106 eventQueue.add(event);
112 public void log(int severity, Date date, String msg) {
113 final LogEntry logEntry = new LogEntry(severity, date, msg);
114 synchronizerThread.addToQueue(new Runnable() {
117 boolean notify = false;
118 synchronized (entries) {
119 entries.add(logEntry);
120 Boolean showEntry = LogManager.this.visibleSeverities
121 .get(logEntry.getSeverity());
122 if (showEntry != null) {
124 visibleEntries.add(logEntry);
128 if (entries.size() > Constants.LOG_SIZE) {
131 if (visibleEntries.size() > Constants.LOG_SIZE) {
132 visibleEntries.pop();
137 notifyListeners(logEntry);
143 public void applyFilter(final HashMap<Integer, Boolean> visibleSeverities) {
144 synchronizerThread.addToQueue(new Runnable() {
148 LinkedList<LogEntry> newLogs = new LinkedList<LogEntry>();
149 synchronized (entries) {
150 LogManager.this.visibleSeverities = visibleSeverities;
151 for (LogEntry logEntry : entries) {
152 if (LogManager.this.visibleSeverities.get(logEntry
154 newLogs.add(logEntry);
158 visibleEntries = newLogs;
165 private void notifyListeners() {
166 for (ILogUIListener l : listeners) {
167 l.logChanged(new ArrayList<LogEntry>(visibleEntries));
171 private void notifyListeners(LogEntry added) {
172 for (ILogUIListener l : listeners) {
177 public void clearLog() {
178 synchronizerThread.addToQueue(new Runnable() {
182 synchronized (entries) {
183 entries = new LinkedList<LogEntry>();
184 visibleEntries = new LinkedList<LogEntry>();
191 public void removeEntry(final LogEntry element) {
192 synchronizerThread.addToQueue(new Runnable() {
196 synchronized (entries) {
197 entries.remove(element);
198 visibleEntries.remove(element);
205 public ArrayList<LogEntry> getLogEntries() {
206 synchronized (entries) {
207 return new ArrayList<LogEntry>(entries);
211 public void addLogListener(final ILogUIListener listener) {
212 synchronizerThread.addToQueue(new Runnable() {
215 if (!listeners.contains(listener)) {
216 listeners.add(listener);
222 public void removeLogListener(final ILogUIListener listener) {
223 synchronizerThread.addToQueue(new Runnable() {
226 if (!listeners.contains(listener)) {
227 listeners.remove(listener);
233 public void shutdown() {
234 threadHandle.interrupt();
237 public static String getSeverityName(int severity) {
238 if (severity == Level.INFO.ordinal()) {
239 return Constants.INFO;
240 } else if (severity == Level.WARNING.ordinal()) {
241 return Constants.WARNING;
242 } else if (severity == Level.ERROR.ordinal()) {
243 return Constants.ERROR;
244 } else if (severity == Level.DEBUG.ordinal()) {
245 return Constants.DEBUG;
247 return Constants.UNKNOWN;
251 public static Image getSeverityIcon(int severity) {
252 ImageRegistry r = Activator.getDefault().getImageRegistry();
253 if (severity == Level.INFO.ordinal()) {
254 return r.get(Constants.INFO_LOG);
255 } else if (severity == Level.WARNING.ordinal()) {
256 return r.get(Constants.WARNING_LOG);
257 } else if (severity == Level.ERROR.ordinal()) {
258 return r.get(Constants.ERROR_LOG);
259 } else if (severity == Level.DEBUG.ordinal()) {
260 return r.get(Constants.DEBUG_LOG);
262 return r.get(Constants.UNKNOWN_LOG);