forked from jens/Automation
264 lines
7.5 KiB
Java
264 lines
7.5 KiB
Java
/*
|
|
* Copyright (C) 2012-2019 Jorrit "Chainfire" Jongma
|
|
*
|
|
* 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 eu.chainfire.libsuperuser;
|
|
|
|
import android.os.Looper;
|
|
import android.util.Log;
|
|
import android.os.Process;
|
|
|
|
import androidx.annotation.AnyThread;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
|
|
import com.jens.automation2.BuildConfig;
|
|
|
|
/**
|
|
* Utility class for logging and debug features that (by default) does nothing when not in debug mode
|
|
*/
|
|
@SuppressWarnings({"WeakerAccess", "UnusedReturnValue", "unused"})
|
|
@AnyThread
|
|
public class Debug {
|
|
|
|
// ----- DEBUGGING -----
|
|
|
|
private static boolean debug = BuildConfig.DEBUG;
|
|
|
|
/**
|
|
* <p>Enable or disable debug mode</p>
|
|
*
|
|
* <p>By default, debug mode is enabled for development
|
|
* builds and disabled for exported APKs - see
|
|
* BuildConfig.DEBUG</p>
|
|
*
|
|
* @param enable Enable debug mode ?
|
|
*/
|
|
public static void setDebug(boolean enable) {
|
|
debug = enable;
|
|
}
|
|
|
|
/**
|
|
* <p>Is debug mode enabled ?</p>
|
|
*
|
|
* @return Debug mode enabled
|
|
*/
|
|
public static boolean getDebug() {
|
|
return debug;
|
|
}
|
|
|
|
// ----- LOGGING -----
|
|
|
|
public interface OnLogListener {
|
|
void onLog(int type, String typeIndicator, String message);
|
|
}
|
|
|
|
public static final String TAG = "libsuperuser";
|
|
|
|
public static final int LOG_GENERAL = 0x0001;
|
|
public static final int LOG_COMMAND = 0x0002;
|
|
public static final int LOG_OUTPUT = 0x0004;
|
|
public static final int LOG_POOL = 0x0008;
|
|
|
|
public static final int LOG_NONE = 0x0000;
|
|
public static final int LOG_ALL = 0xFFFF;
|
|
|
|
private static int logTypes = LOG_ALL;
|
|
|
|
@Nullable
|
|
private static OnLogListener logListener = null;
|
|
|
|
/**
|
|
* <p>Log a message (internal)</p>
|
|
*
|
|
* <p>Current debug and enabled logtypes decide what gets logged -
|
|
* even if a custom callback is registered</p>
|
|
*
|
|
* @param type Type of message to log
|
|
* @param typeIndicator String indicator for message type
|
|
* @param message The message to log
|
|
*/
|
|
private static void logCommon(int type, @NonNull String typeIndicator, @NonNull String message) {
|
|
if (debug && ((logTypes & type) == type)) {
|
|
if (logListener != null) {
|
|
logListener.onLog(type, typeIndicator, message);
|
|
} else {
|
|
Log.d(TAG, "[" + TAG + "][" + typeIndicator + "]" + (!message.startsWith("[") && !message.startsWith(" ") ? " " : "") + message);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <p>Log a "general" message</p>
|
|
*
|
|
* <p>These messages are infrequent and mostly occur at startup/shutdown or on error</p>
|
|
*
|
|
* @param message The message to log
|
|
*/
|
|
public static void log(@NonNull String message) {
|
|
logCommon(LOG_GENERAL, "G", message);
|
|
}
|
|
|
|
/**
|
|
* <p>Log a "per-command" message</p>
|
|
*
|
|
* <p>This could produce a lot of output if the client runs many commands in the session</p>
|
|
*
|
|
* @param message The message to log
|
|
*/
|
|
public static void logCommand(@NonNull String message) {
|
|
logCommon(LOG_COMMAND, "C", message);
|
|
}
|
|
|
|
/**
|
|
* <p>Log a line of stdout/stderr output</p>
|
|
*
|
|
* <p>This could produce a lot of output if the shell commands are noisy</p>
|
|
*
|
|
* @param message The message to log
|
|
*/
|
|
public static void logOutput(@NonNull String message) {
|
|
logCommon(LOG_OUTPUT, "O", message);
|
|
}
|
|
|
|
/**
|
|
* <p>Log pool event</p>
|
|
*
|
|
* @param message The message to log
|
|
*/
|
|
public static void logPool(@NonNull String message) {
|
|
logCommon(LOG_POOL, "P", message);
|
|
}
|
|
|
|
/**
|
|
* <p>Enable or disable logging specific types of message</p>
|
|
*
|
|
* <p>You may | (or) LOG_* constants together. Note that
|
|
* debug mode must also be enabled for actual logging to
|
|
* occur.</p>
|
|
*
|
|
* @param type LOG_* constants
|
|
* @param enable Enable or disable
|
|
*/
|
|
public static void setLogTypeEnabled(int type, boolean enable) {
|
|
if (enable) {
|
|
logTypes |= type;
|
|
} else {
|
|
logTypes &= ~type;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <p>Is logging for specific types of messages enabled ?</p>
|
|
*
|
|
* <p>You may | (or) LOG_* constants together, to learn if
|
|
* <b>all</b> passed message types are enabled for logging. Note
|
|
* that debug mode must also be enabled for actual logging
|
|
* to occur.</p>
|
|
*
|
|
* @param type LOG_* constants
|
|
* @return enabled?
|
|
*/
|
|
public static boolean getLogTypeEnabled(int type) {
|
|
return ((logTypes & type) == type);
|
|
}
|
|
|
|
/**
|
|
* <p>Is logging for specific types of messages enabled ?</p>
|
|
*
|
|
* <p>You may | (or) LOG_* constants together, to learn if
|
|
* <b>all</b> message types are enabled for logging. Takes
|
|
* debug mode into account for the result.</p>
|
|
*
|
|
* @param type LOG_* constants
|
|
* @return enabled and in debug mode?
|
|
*/
|
|
public static boolean getLogTypeEnabledEffective(int type) {
|
|
return getDebug() && getLogTypeEnabled(type);
|
|
}
|
|
|
|
/**
|
|
* <p>Register a custom log handler</p>
|
|
*
|
|
* <p>Replaces the log method (write to logcat) with your own
|
|
* handler. Whether your handler gets called is still dependent
|
|
* on debug mode and message types being enabled for logging.</p>
|
|
*
|
|
* @param onLogListener Custom log listener or NULL to revert to default
|
|
*/
|
|
public static void setOnLogListener(@Nullable OnLogListener onLogListener) {
|
|
logListener = onLogListener;
|
|
}
|
|
|
|
/**
|
|
* <p>Get the currently registered custom log handler</p>
|
|
*
|
|
* @return Current custom log handler or NULL if none is present
|
|
*/
|
|
@Nullable
|
|
public static OnLogListener getOnLogListener() {
|
|
return logListener;
|
|
}
|
|
|
|
// ----- SANITY CHECKS -----
|
|
|
|
private static boolean sanityChecks = true;
|
|
|
|
/**
|
|
* <p>Enable or disable sanity checks</p>
|
|
*
|
|
* <p>Enables or disables the library crashing when su is called
|
|
* from the main thread.</p>
|
|
*
|
|
* @param enable Enable or disable
|
|
*/
|
|
public static void setSanityChecksEnabled(boolean enable) {
|
|
sanityChecks = enable;
|
|
}
|
|
|
|
/**
|
|
* <p>Are sanity checks enabled ?</p>
|
|
*
|
|
* <p>Note that debug mode must also be enabled for actual
|
|
* sanity checks to occur.</p>
|
|
*
|
|
* @return True if enabled
|
|
*/
|
|
public static boolean getSanityChecksEnabled() {
|
|
return sanityChecks;
|
|
}
|
|
|
|
/**
|
|
* <p>Are sanity checks enabled ?</p>
|
|
*
|
|
* <p>Takes debug mode into account for the result.</p>
|
|
*
|
|
* @return True if enabled
|
|
*/
|
|
public static boolean getSanityChecksEnabledEffective() {
|
|
return getDebug() && getSanityChecksEnabled();
|
|
}
|
|
|
|
/**
|
|
* <p>Are we running on the main thread ?</p>
|
|
*
|
|
* @return Running on main thread ?
|
|
*/
|
|
public static boolean onMainThread() {
|
|
return ((Looper.myLooper() != null) && (Looper.myLooper() == Looper.getMainLooper()) && (Process.myUid() != 0));
|
|
}
|
|
|
|
}
|