1 /*
2  * Copyright (C) 2015 The Android Open Source Project
3  *
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
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
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.
15  */
16 
17 package com.android.camera.debug;
18 
19 import com.android.camera.debug.Log.Tag;
20 import com.google.common.annotations.VisibleForTesting;
21 
22 import javax.annotation.ParametersAreNonnullByDefault;
23 
24 /**
25  * Set of commonly used loggers.
26  */
27 @ParametersAreNonnullByDefault
28 public class Loggers {
29     /**
30      * This creates a factory that will eat all log input.
31      */
noOpFactory()32     public static Logger.Factory noOpFactory() {
33         return NoOpLoggerFactory.instance();
34     }
35 
36     /**
37      * This creates a factory that will use the standard android static log
38      * methods.
39      */
tagFactory()40     public static Logger.Factory tagFactory() {
41         return TagLoggerFactory.instance();
42     }
43 
44     /**
45      * Creates a logger factory which always returns the given logger.
46      */
factoryFor(final Logger logger)47     public static Logger.Factory factoryFor(final Logger logger) {
48         return new Logger.Factory() {
49             @Override
50             public Logger create(Tag tag) {
51                 return logger;
52             }
53         };
54     }
55 
56     /**
57      * Creates loggers that eat all input and does nothing.
58      */
59     private static class NoOpLoggerFactory implements Logger.Factory {
60         private static class Singleton {
61             private static final NoOpLoggerFactory INSTANCE = new NoOpLoggerFactory();
62         }
63 
64         public static NoOpLoggerFactory instance() {
65             return Singleton.INSTANCE;
66         }
67 
68         private final NoOpLogger mNoOpLogger;
69 
70         public NoOpLoggerFactory() {
71             mNoOpLogger = new NoOpLogger();
72         }
73 
74         @Override
75         public Logger create(Tag tag) {
76             return mNoOpLogger;
77         }
78     }
79 
80     /**
81      * Creates loggers that use tag objects to write to standard android log
82      * output.
83      */
84     private static class TagLoggerFactory implements Logger.Factory {
85         private static class Singleton {
86             private static final TagLoggerFactory INSTANCE = new TagLoggerFactory();
87         }
88 
89         public static TagLoggerFactory instance() {
90             return Singleton.INSTANCE;
91         }
92 
93         @Override
94         public Logger create(Tag tag) {
95             return new TagLogger(tag);
96         }
97     }
98 
99     /**
100      * NoOp logger eats all input messages and does not display them.
101      */
102     private static class NoOpLogger implements Logger {
103         @Override
104         public void d(String msg) {
105         }
106 
107         @Override
108         public void d(String msg, Throwable tr) {
109         }
110 
111         @Override
112         public void e(String msg) {
113         }
114 
115         @Override
116         public void e(String msg, Throwable tr) {
117         }
118 
119         @Override
120         public void i(String msg) {
121         }
122 
123         @Override
124         public void i(String msg, Throwable tr) {
125         }
126 
127         @Override
128         public void v(String msg) {
129         }
130 
131         @Override
132         public void v(String msg, Throwable tr) {
133         }
134 
135         @Override
136         public void w(String msg) {
137         }
138 
139         @Override
140         public void w(String msg, Throwable tr) {
141         }
142     }
143 
144     /**
145      * TagLogger logger writes to the standard static log output with the given
146      * tag object.
147      */
148     private static class TagLogger implements Logger {
149         private final Log.Tag mTag;
150 
151         public TagLogger(Log.Tag tag) {
152             mTag = tag;
153         }
154 
155         @Override
156         public void d(String msg) {
157             Log.d(mTag, msg);
158         }
159 
160         @Override
161         public void d(String msg, Throwable tr) {
162             Log.d(mTag, msg, tr);
163         }
164 
165         @Override
166         public void e(String msg) {
167             Log.e(mTag, msg);
168         }
169 
170         @Override
171         public void e(String msg, Throwable tr) {
172             Log.e(mTag, msg, tr);
173         }
174 
175         @Override
176         public void i(String msg) {
177             Log.i(mTag, msg);
178         }
179 
180         @Override
181         public void i(String msg, Throwable tr) {
182             Log.i(mTag, msg, tr);
183         }
184 
185         @Override
186         public void v(String msg) {
187             Log.v(mTag, msg);
188         }
189 
190         @Override
191         public void v(String msg, Throwable tr) {
192             Log.v(mTag, msg, tr);
193         }
194 
195         @Override
196         public void w(String msg) {
197             Log.w(mTag, msg);
198         }
199 
200         @Override
201         public void w(String msg, Throwable tr) {
202             Log.w(mTag, msg, tr);
203         }
204     }
205 }
206