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.serviceprovider.manager;
19 import org.eclipse.jface.resource.ImageRegistry;
20 import org.eclipse.swt.graphics.Image;
22 import java.util.ArrayList;
23 import java.util.Date;
24 import java.util.HashMap;
25 import java.util.LinkedList;
27 import org.oic.simulator.ILogger;
28 import org.oic.simulator.ILogger.Level;
29 import org.oic.simulator.SimulatorManager;
31 import oic.simulator.logger.LogEntry;
32 import oic.simulator.logger.LoggerCallback;
33 import oic.simulator.serviceprovider.Activator;
34 import oic.simulator.serviceprovider.listener.ILogListener;
35 import oic.simulator.serviceprovider.utils.Constants;
38 * Class which handles the native logs, maintains log entries and updates the
41 public class LogManager {
42 private LinkedList<LogEntry> entries = new LinkedList<LogEntry>();
43 private ArrayList<ILogListener> listeners = new ArrayList<ILogListener>();
44 private LinkedList<LogEntry> visibleEntries = new LinkedList<LogEntry>();
45 private HashMap<Integer, Boolean> visibleSeverities = new HashMap<Integer, Boolean>();
47 private ILogger logger;
48 private LogManagerSynchronizerThread synchronizerThread;
49 private Thread threadHandle;
52 synchronizerThread = new LogManagerSynchronizerThread();
53 threadHandle = new Thread(synchronizerThread);
54 threadHandle.setName("OIC Simulator event queue");
57 // Set the logger callback with the native layer
58 logger = new LoggerCallback();
59 SimulatorManager.setLogger(logger);
62 private static class LogManagerSynchronizerThread implements Runnable {
64 LinkedList<Runnable> eventQueue = new LinkedList<Runnable>();
68 while (!Thread.interrupted()) {
72 while (eventQueue.isEmpty()) {
76 } catch (InterruptedException e) {
83 pop = eventQueue.pop();
87 } catch (Exception e) {
88 if (e instanceof InterruptedException) {
96 public void addToQueue(Runnable event) {
98 eventQueue.add(event);
104 public void log(int severity, Date date, String msg) {
105 final LogEntry logEntry = new LogEntry(severity, date, msg);
106 synchronizerThread.addToQueue(new Runnable() {
109 boolean notify = false;
110 synchronized (entries) {
111 entries.add(logEntry);
112 Boolean showEntry = LogManager.this.visibleSeverities
113 .get(logEntry.getSeverity());
114 if (showEntry != null) {
116 visibleEntries.add(logEntry);
120 if (entries.size() > Constants.LOG_SIZE) {
123 if (visibleEntries.size() > Constants.LOG_SIZE) {
124 visibleEntries.pop();
129 notifyListeners(logEntry);
135 public void applyFilter(final HashMap<Integer, Boolean> visibleSeverities) {
136 synchronizerThread.addToQueue(new Runnable() {
140 LinkedList<LogEntry> newLogs = new LinkedList<LogEntry>();
141 synchronized (entries) {
142 LogManager.this.visibleSeverities = visibleSeverities;
143 for (LogEntry logEntry : entries) {
144 if (LogManager.this.visibleSeverities.get(logEntry
146 newLogs.add(logEntry);
150 visibleEntries = newLogs;
157 private void notifyListeners() {
158 for (ILogListener l : listeners) {
159 l.logChanged(new ArrayList<LogEntry>(visibleEntries));
163 private void notifyListeners(LogEntry added) {
164 for (ILogListener l : listeners) {
169 public void clearLog() {
170 synchronizerThread.addToQueue(new Runnable() {
174 synchronized (entries) {
175 entries = new LinkedList<LogEntry>();
176 visibleEntries = new LinkedList<LogEntry>();
183 public void removeEntry(final LogEntry element) {
184 synchronizerThread.addToQueue(new Runnable() {
188 synchronized (entries) {
189 entries.remove(element);
190 visibleEntries.remove(element);
197 public ArrayList<LogEntry> getLogEntries() {
198 synchronized (entries) {
199 return new ArrayList<LogEntry>(entries);
203 public void addLogListener(final ILogListener listener) {
204 synchronizerThread.addToQueue(new Runnable() {
207 if (!listeners.contains(listener)) {
208 listeners.add(listener);
214 public void removeLogListener(final ILogListener listener) {
215 synchronizerThread.addToQueue(new Runnable() {
218 if (!listeners.contains(listener)) {
219 listeners.remove(listener);
225 public void shutdown() {
226 threadHandle.interrupt();
229 public static String getSeverityName(int severity) {
230 if (severity == Level.INFO.ordinal()) {
231 return Constants.INFO;
232 } else if (severity == Level.WARNING.ordinal()) {
233 return Constants.WARNING;
234 } else if (severity == Level.ERROR.ordinal()) {
235 return Constants.ERROR;
236 } else if (severity == Level.DEBUG.ordinal()) {
237 return Constants.DEBUG;
239 return Constants.UNKNOWN;
243 public static Image getSeverityIcon(int severity) {
244 ImageRegistry r = Activator.getDefault().getImageRegistry();
245 if (severity == Level.INFO.ordinal()) {
246 return r.get(Constants.INFO_LOG);
247 } else if (severity == Level.WARNING.ordinal()) {
248 return r.get(Constants.WARNING_LOG);
249 } else if (severity == Level.ERROR.ordinal()) {
250 return r.get(Constants.ERROR_LOG);
251 } else if (severity == Level.DEBUG.ordinal()) {
252 return r.get(Constants.DEBUG_LOG);
254 return r.get(Constants.UNKNOWN_LOG);