1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License
*/
package com.android.tv.common;
import android.content.Context;
import android.text.TextUtils;
import android.util.Log;
import com.android.tv.common.feature.Feature;
/**
* Simple static methods to be called at the start of your own methods to verify
* correct arguments and state.
*
* <p>{@code checkXXX} methods throw exceptions when {@link BuildConfig#ENG} is true, and
* logs a warning when it is false.
*
* <p>This is based on com.android.internal.util.Preconditions.
*/
public final class SoftPreconditions {
private static final String TAG = "SoftPreconditions";
/**
* Throws or logs if an expression involving the parameter of the calling
* method is not true.
*
* @param expression a boolean expression
* @param tag Used to identify the source of a log message. It usually
* identifies the class or activity where the log call occurs.
* @param msg The message you would like logged.
* @return the evaluation result of the boolean expression
* @throws IllegalArgumentException if {@code expression} is true
*/
public static boolean checkArgument(final boolean expression, String tag, String msg) {
if (!expression) {
warn(tag, "Illegal argument", msg, new IllegalArgumentException(msg));
}
return expression;
}
/**
* Throws or logs if an expression involving the parameter of the calling
* method is not true.
*
* @param expression a boolean expression
* @return the evaluation result of the boolean expression
* @throws IllegalArgumentException if {@code expression} is true
*/
public static boolean checkArgument(final boolean expression) {
checkArgument(expression, null, null);
return expression;
}
/**
* Throws or logs if an and object is null.
*
* @param reference an object reference
* @param tag Used to identify the source of a log message. It usually
* identifies the class or activity where the log call occurs.
* @param msg The message you would like logged.
* @return true if the object is null
* @throws NullPointerException if {@code reference} is null
*/
public static <T> T checkNotNull(final T reference, String tag, String msg) {
if (reference == null) {
warn(tag, "Null Pointer", msg, new NullPointerException(msg));
}
return reference;
}
/**
* Throws or logs if an and object is null.
*
* @param reference an object reference
* @return true if the object is null
* @throws NullPointerException if {@code reference} is null
*/
public static <T> T checkNotNull(final T reference) {
return checkNotNull(reference, null, null);
}
/**
* Throws or logs if an expression involving the state of the calling
* instance, but not involving any parameters to the calling method is not true.
*
* @param expression a boolean expression
* @param tag Used to identify the source of a log message. It usually
* identifies the class or activity where the log call occurs.
* @param msg The message you would like logged.
* @return the evaluation result of the boolean expression
* @throws IllegalStateException if {@code expression} is true
*/
public static boolean checkState(final boolean expression, String tag, String msg) {
if (!expression) {
warn(tag, "Illegal State", msg, new IllegalStateException(msg));
}
return expression;
}
/**
* Throws or logs if an expression involving the state of the calling
* instance, but not involving any parameters to the calling method is not true.
*
* @param expression a boolean expression
* @return the evaluation result of the boolean expression
* @throws IllegalStateException if {@code expression} is true
*/
public static boolean checkState(final boolean expression) {
checkState(expression, null, null);
return expression;
}
/**
* Throws or logs if the Feature is not enabled
*
* @param context an android context
* @param feature the required feature
* @param tag used to identify the source of a log message. It usually
* identifies the class or activity where the log call occurs
* @throws IllegalStateException if {@code feature} is not enabled
*/
public static void checkFeatureEnabled(Context context, Feature feature, String tag) {
checkState(feature.isEnabled(context), tag, feature.toString());
}
/**
* Throws a {@link RuntimeException} if {@link BuildConfig#ENG} is true, else log a warning.
*
* @param tag Used to identify the source of a log message. It usually
* identifies the class or activity where the log call occurs.
* @param msg The message you would like logged
* @param e The exception to wrap with a RuntimeException when thrown.
*/
public static void warn(String tag, String prefix, String msg, Exception e)
throws RuntimeException {
if (TextUtils.isEmpty(tag)) {
tag = TAG;
}
String logMessage;
if (TextUtils.isEmpty(msg)) {
logMessage = prefix;
} else if (TextUtils.isEmpty(prefix)) {
logMessage = msg;
} else {
logMessage = prefix + ": " + msg;
}
if (BuildConfig.ENG) {
throw new RuntimeException(msg, e);
} else {
Log.w(tag, logMessage, e);
}
}
private SoftPreconditions() {
}
}
|
