Daniel Elliott
c080f0d97f
- Added realracing3-community.apk (71.57 MB) - Removed 32-bit support (armeabi-v7a) - Only includes arm64-v8a libraries - Decompiled source code included - Added README-community.md with analysis
466 lines
16 KiB
Java
466 lines
16 KiB
Java
package com.ea.nimble;
|
|
|
|
import android.content.pm.PackageInfo;
|
|
import android.os.Environment;
|
|
import android.support.v4.media.session.PlaybackStateCompat;
|
|
import androidx.core.app.NotificationCompat;
|
|
import com.ea.nimble.ILog;
|
|
import com.ironsource.u3;
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.nio.charset.Charset;
|
|
import java.text.DateFormat;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.Iterator;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
|
|
/* loaded from: classes2.dex */
|
|
public class LogImpl extends Component implements ILog {
|
|
private static final int DEFAULT_CHECK_INTERVAL = 3600;
|
|
private static final int DEFAULT_CONSOLE_OUTPUT_LIMIT = 4000;
|
|
private static final int DEFAULT_MESSAGE_LENGTH_LIMIT = 1000;
|
|
private static final int DEFAULT_SIZE_LIMIT = 1024;
|
|
private int m_messageLengthLimit;
|
|
private int m_sizeLimit;
|
|
private BaseCore m_core = null;
|
|
private int m_level = 0;
|
|
private File m_filePath = null;
|
|
private FileOutputStream m_logFileStream = null;
|
|
private DateFormat m_format = null;
|
|
private Timer m_guardTimer = null;
|
|
private int m_interval = 0;
|
|
private ArrayList<LogRecord> m_cache = new ArrayList<>();
|
|
private ILog.LogCallback m_callback = null;
|
|
|
|
public void disconnectFromCore() {
|
|
this.m_core = null;
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public String getComponentId() {
|
|
return Log.COMPONENT_ID;
|
|
}
|
|
|
|
@Override // com.ea.nimble.ILog
|
|
public int getThresholdLevel() {
|
|
return this.m_level;
|
|
}
|
|
|
|
@Override // com.ea.nimble.ILog
|
|
public void setLogCallback(ILog.LogCallback logCallback) {
|
|
this.m_callback = logCallback;
|
|
}
|
|
|
|
@Override // com.ea.nimble.ILog
|
|
public void setThresholdLevel(int i) {
|
|
this.m_level = i;
|
|
}
|
|
|
|
public class GuardTask implements Runnable {
|
|
private GuardTask() {
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (LogImpl.this.m_filePath == null || LogImpl.this.m_filePath.length() <= LogImpl.this.m_sizeLimit * PlaybackStateCompat.ACTION_PLAY_FROM_MEDIA_ID) {
|
|
return;
|
|
}
|
|
LogImpl.this.clearLog();
|
|
}
|
|
}
|
|
|
|
public static class LogRecord {
|
|
public int level;
|
|
public String message;
|
|
|
|
private LogRecord() {
|
|
}
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public void setup() {
|
|
configure();
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public void suspend() {
|
|
Timer timer = this.m_guardTimer;
|
|
if (timer != null) {
|
|
timer.pause();
|
|
}
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public void resume() {
|
|
Timer timer = this.m_guardTimer;
|
|
if (timer != null) {
|
|
timer.fire();
|
|
this.m_guardTimer.resume();
|
|
}
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public void teardown() {
|
|
Timer timer = this.m_guardTimer;
|
|
if (timer != null) {
|
|
timer.cancel();
|
|
this.m_guardTimer = null;
|
|
}
|
|
FileOutputStream fileOutputStream = this.m_logFileStream;
|
|
if (fileOutputStream != null) {
|
|
try {
|
|
fileOutputStream.close();
|
|
} catch (IOException unused) {
|
|
android.util.Log.e(Global.NIMBLE_ID, "LOG: Can't close log file");
|
|
}
|
|
this.m_logFileStream = null;
|
|
}
|
|
}
|
|
|
|
@Override // com.ea.nimble.ILog
|
|
public String getLogFilePath() {
|
|
File file = this.m_filePath;
|
|
if (file != null) {
|
|
return file.toString();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // com.ea.nimble.ILog
|
|
public void writeWithSource(int i, Object obj, String str, Object... objArr) {
|
|
String name;
|
|
if (obj instanceof LogSource) {
|
|
name = ((LogSource) obj).getLogSourceTitle();
|
|
} else {
|
|
name = obj != null ? obj.getClass().getName() : "";
|
|
}
|
|
writeWithTitle(i, name, str, objArr);
|
|
}
|
|
|
|
@Override // com.ea.nimble.ILog
|
|
public void writeWithTitle(int i, String str, String str2, Object... objArr) {
|
|
if (i < this.m_level || !Utility.validString(str2)) {
|
|
return;
|
|
}
|
|
if (objArr.length > 0) {
|
|
str2 = String.format(str2, objArr);
|
|
}
|
|
write(i, str, str2);
|
|
ILog.LogCallback logCallback = this.m_callback;
|
|
if (logCallback != null) {
|
|
logCallback.callback(i, str, str2);
|
|
}
|
|
}
|
|
|
|
public void connectToCore(BaseCore baseCore) {
|
|
this.m_core = baseCore;
|
|
configure();
|
|
flushCache();
|
|
}
|
|
|
|
private void configure() {
|
|
boolean z = this.m_level == 0;
|
|
Map<String, String> settings = this.m_core.getSettings(BaseCore.NIMBLE_LOG_SETTING);
|
|
if (settings == null) {
|
|
int parseLevel = parseLevel(null);
|
|
if (parseLevel != this.m_level) {
|
|
this.m_level = parseLevel;
|
|
String.format("LOG: Default Log level(%d) without log configuration file", Integer.valueOf(parseLevel));
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
int parseLevel2 = parseLevel(settings.get("Level"));
|
|
if (parseLevel2 != this.m_level) {
|
|
this.m_level = parseLevel2;
|
|
String.format("LOG: Log level(%d)", Integer.valueOf(parseLevel2));
|
|
}
|
|
if (this.m_level <= 100) {
|
|
this.m_messageLengthLimit = 0;
|
|
} else {
|
|
String str = settings.get("MessageLengthLimit");
|
|
if (str == null) {
|
|
this.m_messageLengthLimit = 1000;
|
|
} else {
|
|
try {
|
|
int parseInt = Integer.parseInt(str);
|
|
this.m_messageLengthLimit = parseInt;
|
|
if (parseInt < 0) {
|
|
this.m_messageLengthLimit = 1000;
|
|
}
|
|
} catch (NumberFormatException unused) {
|
|
this.m_messageLengthLimit = 1000;
|
|
}
|
|
}
|
|
}
|
|
String str2 = settings.get("File");
|
|
if (!Utility.validString(str2)) {
|
|
if (z || this.m_filePath != null) {
|
|
this.m_filePath = null;
|
|
this.m_logFileStream = null;
|
|
this.m_interval = 0;
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
String str3 = settings.get("Location");
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(ApplicationEnvironment.getComponent().getCachePath());
|
|
String str4 = File.separator;
|
|
sb.append(str4);
|
|
sb.append(str2);
|
|
String sb2 = sb.toString();
|
|
if (Utility.validString(str3) && str3.equalsIgnoreCase(u3.e) && Environment.getExternalStorageState().equals("mounted")) {
|
|
String name = ApplicationEnvironment.getCurrentActivity().getClass().getPackage().getName();
|
|
PackageInfo packageInfo = Utility.getPackageInfo(0);
|
|
if (packageInfo != null) {
|
|
name = packageInfo.packageName;
|
|
}
|
|
File file = new File(Environment.getExternalStorageDirectory(), name);
|
|
boolean exists = file.exists();
|
|
if (!exists) {
|
|
exists = file.mkdir();
|
|
}
|
|
if (exists) {
|
|
sb2 = file + str4 + str2;
|
|
}
|
|
}
|
|
File file2 = new File(sb2);
|
|
if (file2 != this.m_filePath) {
|
|
this.m_filePath = file2;
|
|
try {
|
|
this.m_logFileStream = new FileOutputStream(this.m_filePath, true);
|
|
StringBuilder sb3 = new StringBuilder();
|
|
sb3.append("LOG: File path: ");
|
|
sb3.append(this.m_filePath.toString());
|
|
} catch (FileNotFoundException unused2) {
|
|
android.util.Log.e(Global.NIMBLE_ID, "LOG: Can't create log file at " + sb2);
|
|
this.m_filePath = null;
|
|
return;
|
|
}
|
|
}
|
|
String str5 = settings.get("DateFormat");
|
|
if (str5 != null && str5.length() > 0) {
|
|
this.m_format = new SimpleDateFormat(str5, Locale.getDefault());
|
|
} else {
|
|
this.m_format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.getDefault());
|
|
}
|
|
try {
|
|
int parseInt2 = Integer.parseInt(settings.get("FileCheckInterval"));
|
|
this.m_interval = parseInt2;
|
|
if (parseInt2 <= 0) {
|
|
this.m_interval = 3600;
|
|
}
|
|
} catch (NumberFormatException unused3) {
|
|
this.m_interval = 3600;
|
|
}
|
|
try {
|
|
int parseInt3 = Integer.parseInt(settings.get("MaxFileSize"));
|
|
this.m_sizeLimit = parseInt3;
|
|
if (parseInt3 <= 0) {
|
|
this.m_sizeLimit = 1024;
|
|
}
|
|
} catch (NumberFormatException unused4) {
|
|
this.m_sizeLimit = 1024;
|
|
}
|
|
GuardTask guardTask = new GuardTask();
|
|
guardTask.run();
|
|
Timer timer = new Timer(guardTask);
|
|
this.m_guardTimer = timer;
|
|
timer.schedule(this.m_interval, true);
|
|
}
|
|
|
|
private void flushCache() {
|
|
Iterator<LogRecord> it = this.m_cache.iterator();
|
|
while (it.hasNext()) {
|
|
LogRecord next = it.next();
|
|
int i = next.level;
|
|
if (i >= this.m_level) {
|
|
writeLine(i, next.message);
|
|
}
|
|
}
|
|
this.m_cache = null;
|
|
}
|
|
|
|
private int parseLevel(String str) {
|
|
try {
|
|
if (Utility.validString(str)) {
|
|
int parseInt = Integer.parseInt(str);
|
|
if (parseInt != 0) {
|
|
return parseInt;
|
|
}
|
|
}
|
|
} catch (NumberFormatException unused) {
|
|
if (str.equalsIgnoreCase("all")) {
|
|
return 0;
|
|
}
|
|
if (str.equalsIgnoreCase("verbose")) {
|
|
return 100;
|
|
}
|
|
if (str.equalsIgnoreCase("debug")) {
|
|
return 200;
|
|
}
|
|
if (str.equalsIgnoreCase("info")) {
|
|
return 300;
|
|
}
|
|
if (str.equalsIgnoreCase("warn")) {
|
|
return 400;
|
|
}
|
|
if (str.equalsIgnoreCase("error")) {
|
|
return 500;
|
|
}
|
|
if (str.equalsIgnoreCase("fatal")) {
|
|
return 600;
|
|
}
|
|
if (str.equalsIgnoreCase(NotificationCompat.GROUP_KEY_SILENT)) {
|
|
return 700;
|
|
}
|
|
}
|
|
return (this.m_core.getConfiguration() == NimbleConfiguration.INTEGRATION || this.m_core.getConfiguration() == NimbleConfiguration.STAGE) ? 100 : 500;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public void clearLog() {
|
|
try {
|
|
this.m_logFileStream.close();
|
|
this.m_logFileStream = new FileOutputStream(this.m_filePath, false);
|
|
} catch (IOException unused) {
|
|
android.util.Log.e(Global.NIMBLE_ID, "LOG: Can't clear log file");
|
|
}
|
|
}
|
|
|
|
private void writeLine(int i, String str) {
|
|
int i2 = 0;
|
|
if (i == 0) {
|
|
String[] formatLine = formatLine("NIM_ALL", str);
|
|
int length = formatLine.length;
|
|
while (i2 < length) {
|
|
outputMessageToFile(formatLine[i2]);
|
|
i2++;
|
|
}
|
|
} else if (i == 100) {
|
|
String[] formatLine2 = formatLine("NIM_VERBOSE", str);
|
|
int length2 = formatLine2.length;
|
|
while (i2 < length2) {
|
|
outputMessageToFile(formatLine2[i2]);
|
|
i2++;
|
|
}
|
|
} else if (i == 200) {
|
|
String[] formatLine3 = formatLine("NIM_DEBUG", str);
|
|
int length3 = formatLine3.length;
|
|
while (i2 < length3) {
|
|
outputMessageToFile(formatLine3[i2]);
|
|
i2++;
|
|
}
|
|
} else if (i == 300) {
|
|
String[] formatLine4 = formatLine("NIM_INFO", str);
|
|
int length4 = formatLine4.length;
|
|
while (i2 < length4) {
|
|
outputMessageToFile(formatLine4[i2]);
|
|
i2++;
|
|
}
|
|
} else if (i == 400) {
|
|
String[] formatLine5 = formatLine("NIM_WARN", str);
|
|
int length5 = formatLine5.length;
|
|
while (i2 < length5) {
|
|
String str2 = formatLine5[i2];
|
|
android.util.Log.w(Global.NIMBLE_ID, str2);
|
|
outputMessageToFile(str2);
|
|
i2++;
|
|
}
|
|
} else if (i == 500) {
|
|
String[] formatLine6 = formatLine("NIM_ERROR", str);
|
|
int length6 = formatLine6.length;
|
|
while (i2 < length6) {
|
|
String str3 = formatLine6[i2];
|
|
android.util.Log.e(Global.NIMBLE_ID, str3);
|
|
outputMessageToFile(str3);
|
|
i2++;
|
|
}
|
|
} else if (i == 600) {
|
|
String[] formatLine7 = formatLine("NIM_FATAL", str);
|
|
String str4 = formatLine7[0];
|
|
while (i2 < formatLine7.length - 1) {
|
|
android.util.Log.e(Global.NIMBLE_ID, str4);
|
|
outputMessageToFile(str4);
|
|
i2++;
|
|
str4 = formatLine7[i2];
|
|
}
|
|
android.util.Log.wtf(Global.NIMBLE_ID, str4);
|
|
outputMessageToFile(str4);
|
|
} else {
|
|
String[] formatLine8 = formatLine(String.format("NIM(%d)", Integer.valueOf(i)), str);
|
|
String str5 = formatLine8[0];
|
|
while (i2 < formatLine8.length - 1) {
|
|
android.util.Log.e(Global.NIMBLE_ID, str5);
|
|
outputMessageToFile(str5);
|
|
i2++;
|
|
str5 = formatLine8[i2];
|
|
}
|
|
android.util.Log.wtf(Global.NIMBLE_ID, str5);
|
|
outputMessageToFile(str5);
|
|
}
|
|
if (i >= 600) {
|
|
if (this.m_core.getConfiguration() == NimbleConfiguration.INTEGRATION || this.m_core.getConfiguration() == NimbleConfiguration.STAGE) {
|
|
throw new AssertionError(str);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void write(int i, String str, String str2) {
|
|
String str3;
|
|
if (Utility.validString(str)) {
|
|
str3 = str + "> " + str2;
|
|
} else {
|
|
str3 = " " + str2;
|
|
}
|
|
if (this.m_cache != null) {
|
|
LogRecord logRecord = new LogRecord();
|
|
logRecord.level = i;
|
|
logRecord.message = str3;
|
|
this.m_cache.add(logRecord);
|
|
return;
|
|
}
|
|
writeLine(i, str3);
|
|
}
|
|
|
|
private String[] formatLine(String str, String str2) {
|
|
String str3 = str + ">" + str2;
|
|
int length = str3.length();
|
|
int i = this.m_messageLengthLimit;
|
|
int i2 = 0;
|
|
if (length > i && i != 0) {
|
|
str3 = str3.substring(0, this.m_messageLengthLimit) + String.format("... and %d chars more", Integer.valueOf(length - i));
|
|
length = str3.length();
|
|
}
|
|
String[] strArr = new String[(int) Math.ceil(length / 4000.0d)];
|
|
while (i2 < length) {
|
|
int i3 = i2 + DEFAULT_CONSOLE_OUTPUT_LIMIT;
|
|
if (i3 < length) {
|
|
strArr[i2 / DEFAULT_CONSOLE_OUTPUT_LIMIT] = str3.substring(i2, i3);
|
|
} else {
|
|
strArr[i2 / DEFAULT_CONSOLE_OUTPUT_LIMIT] = str3.substring(i2);
|
|
}
|
|
i2 = i3;
|
|
}
|
|
return strArr;
|
|
}
|
|
|
|
private void outputMessageToFile(String str) {
|
|
String property = System.getProperty("line.separator");
|
|
if (this.m_logFileStream != null) {
|
|
try {
|
|
this.m_logFileStream.write((this.m_format.format(new Date()) + " " + str + property).getBytes(Charset.forName("UTF-8")));
|
|
this.m_logFileStream.flush();
|
|
} catch (IOException e) {
|
|
android.util.Log.e(Global.NIMBLE_ID, "Error writing to log file: " + e.toString());
|
|
}
|
|
}
|
|
}
|
|
}
|