1/*
2 * Copyright (c) 2015, Motorola Mobility LLC
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *     - Redistributions of source code must retain the above copyright
8 *       notice, this list of conditions and the following disclaimer.
9 *     - Redistributions in binary form must reproduce the above copyright
10 *       notice, this list of conditions and the following disclaimer in the
11 *       documentation and/or other materials provided with the distribution.
12 *     - Neither the name of Motorola Mobility nor the
13 *       names of its contributors may be used to endorse or promote products
14 *       derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
18 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MOTOROLA MOBILITY LLC BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
26 * DAMAGE.
27 */
28
29package com.android.ims.internal;
30
31import java.lang.String;
32import android.util.Log;
33
34import android.text.TextUtils;
35
36/**
37 * Logger
38 *
39 * @hide
40 */
41public class Logger {
42
43    private static boolean VERBOSE = isLoggable(android.util.Log.VERBOSE);
44    private static boolean DEBUG = isLoggable(android.util.Log.DEBUG);
45    private static boolean INFO = isLoggable(android.util.Log.INFO);
46    private static boolean WARN = isLoggable(android.util.Log.WARN);
47    private static boolean ERROR = isLoggable(android.util.Log.ERROR);
48
49    /**
50     * RCS test mode flag
51     */
52    private static boolean mRcsTestMode = false;
53
54    /**
55     * Log tag name
56     */
57    private static String TAG = "rcs";
58
59    /**
60     * Classname
61     */
62    private String mClassName;
63
64    /**
65     * Constructor
66     *
67     * @param mClassName Classname
68     */
69    private Logger(String tagName, String mClassName) {
70        if(!TextUtils.isEmpty(tagName)) {
71            TAG = tagName;
72        }
73
74        int index = mClassName.lastIndexOf('.');
75        if (index != -1) {
76            this.mClassName = mClassName.substring(index+1);
77        } else {
78            this.mClassName = mClassName;
79        }
80    }
81
82    public static void setRcsTestMode(boolean test) {
83        mRcsTestMode = test;
84        // Reset log-ability of each mode.
85        DEBUG = isLoggable(android.util.Log.DEBUG);
86        INFO = isLoggable(android.util.Log.INFO);
87        VERBOSE = isLoggable(android.util.Log.VERBOSE);
88        WARN = isLoggable(android.util.Log.WARN);
89        ERROR = isLoggable(android.util.Log.ERROR);
90    }
91
92    /**
93     * Is logger activated. Reserved for future debug tool to turn on/off the log only.
94     *
95     * @return boolean
96     */
97    private boolean isActivated() {
98        return true;
99    }
100
101    /**
102     * Verbose trace
103     *
104     * @param trace Trace
105     */
106    public void verbose(String trace) {
107        if (isActivated() && VERBOSE) {
108            Log.d(TAG, "[" + mClassName +"] " + trace);
109        }
110    }
111
112    /**
113     * Debug trace
114     *
115     * @param trace Trace
116     */
117    public void debug(String trace) {
118        if (isActivated() && DEBUG) {
119            Log.d(TAG, "[" + mClassName +"] " + trace);
120        }
121    }
122
123    /**
124     * Debug trace
125     *
126     * @param trace Trace
127     * @param e the exception which need to be printed.
128     */
129    public void debug(String trace, Throwable e) {
130        if (isActivated() && DEBUG) {
131            Log.d(TAG, "[" + mClassName +"] " + trace, e);
132        }
133    }
134
135    /**
136     * Info trace
137     *
138     * @param trace Trace
139     */
140    public void info(String trace) {
141        if (isActivated() && INFO) {
142            Log.i(TAG, "[" + mClassName +"] " + trace);
143        }
144    }
145
146    /**
147     * Warning trace
148     *
149     * @param trace Trace
150     */
151    public void warn(String trace) {
152        if (isActivated() && WARN) {
153            Log.w(TAG, "[" + mClassName +"] " + trace);
154        }
155    }
156
157    /**
158     * Error trace
159     *
160     * @param trace Trace
161     */
162    public void error(String trace) {
163        if (isActivated() && ERROR) {
164            Log.e(TAG, "[" + mClassName +"] " + trace);
165        }
166    }
167
168    /**
169     * Error trace
170     *
171     * @param trace Trace
172     * @param e Exception
173     */
174    public void error(String trace, Throwable e) {
175        if (isActivated() && ERROR) {
176            Log.e(TAG, "[" + mClassName +"] " + trace, e);
177        }
178    }
179
180    /*
181     * Print the debug log and don't consider the traceLevel
182     *
183     * @param trace Trace
184     * @param e Exception
185     */
186    public void print(String trace) {
187        Log.i(TAG, "[" + mClassName +"] " + trace);
188    }
189
190    /**
191     * Print the debug log and don't consider the traceLevel
192     *
193     * @param trace Trace
194     * @param e Exception
195     */
196    public void print(String trace, Throwable e) {
197        Log.i(TAG, "[" + mClassName +"] " + trace, e);
198    }
199
200    // Hide all numbers except for the last two
201    public static String hidePhoneNumberPii(String number) {
202        if(TextUtils.isEmpty(number) || mRcsTestMode || number.length() <= 2) {
203            return number;
204        }
205        StringBuilder sb = new StringBuilder(number.length());
206        sb.append("...*");
207        sb.append(number.substring(number.length()-2, number.length()));
208        return sb.toString();
209    }
210
211    /**
212     * Determines if the debug level is currently loggable.
213     */
214    private static boolean isLoggable(int level) {
215        return mRcsTestMode || android.util.Log.isLoggable(TAG, level);
216    }
217
218    /**
219     * Create a static instance
220     *
221     * @param classname Classname
222     * @return Instance
223     */
224    public static synchronized Logger getLogger(String tagName, String classname) {
225        return new Logger(tagName, classname);
226    }
227
228    /**
229     * Create a static instance
230     *
231     * @param classname Classname
232     * @return Instance
233     */
234    public static synchronized Logger getLogger(String classname) {
235        return new Logger(TAG, classname);
236    }
237}
238
239