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
464 lines
19 KiB
Java
464 lines
19 KiB
Java
package com.ea.nimble;
|
|
|
|
import android.app.Activity;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.pm.ActivityInfo;
|
|
import android.content.pm.ApplicationInfo;
|
|
import android.content.pm.PackageInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.ResolveInfo;
|
|
import android.os.AsyncTask;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.os.Looper;
|
|
import androidx.localbroadcastmanager.content.LocalBroadcastManager;
|
|
import com.applovin.exoplayer2.common.base.Ascii;
|
|
import com.ea.nimble.Log;
|
|
import com.google.gson.GsonBuilder;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.InputStreamReader;
|
|
import java.io.Serializable;
|
|
import java.io.StringWriter;
|
|
import java.nio.charset.Charset;
|
|
import java.security.MessageDigest;
|
|
import java.security.NoSuchAlgorithmException;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.TimeZone;
|
|
import org.json.JSONArray;
|
|
import org.json.JSONException;
|
|
import org.json.JSONObject;
|
|
|
|
/* loaded from: classes2.dex */
|
|
public final class Utility {
|
|
public static boolean getTestResult() {
|
|
return true;
|
|
}
|
|
|
|
public static String safeString(String str) {
|
|
return str == null ? "" : str;
|
|
}
|
|
|
|
private Utility() {
|
|
}
|
|
|
|
public static void loadLibrary(String str) {
|
|
String obj;
|
|
if (str == null) {
|
|
Log.Helper.LOGDS("Utility", "loadLibrary(): libName is null", new Object[0]);
|
|
return;
|
|
}
|
|
try {
|
|
System.loadLibrary(str);
|
|
obj = "Success";
|
|
} catch (NullPointerException e) {
|
|
obj = e.toString();
|
|
} catch (SecurityException e2) {
|
|
obj = e2.toString();
|
|
} catch (Exception e3) {
|
|
obj = e3.toString();
|
|
} catch (UnsatisfiedLinkError e4) {
|
|
obj = e4.toString();
|
|
}
|
|
Log.Helper.LOGDS("Utility", "loadLibrary(" + str + "): " + obj, new Object[0]);
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARN: Removed duplicated region for block: B:36:0x0070 */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public static java.util.Map<java.lang.String, java.lang.String> parseXmlFile(int r6) {
|
|
/*
|
|
r0 = 0
|
|
com.ea.nimble.IApplicationEnvironment r1 = com.ea.nimble.ApplicationEnvironment.getComponent() // Catch: java.lang.Throwable -> L48 java.lang.Exception -> L4d
|
|
android.content.Context r1 = r1.getApplicationContext() // Catch: java.lang.Throwable -> L48 java.lang.Exception -> L4d
|
|
android.content.res.Resources r1 = r1.getResources() // Catch: java.lang.Throwable -> L48 java.lang.Exception -> L4d
|
|
android.content.res.XmlResourceParser r6 = r1.getXml(r6) // Catch: java.lang.Throwable -> L48 java.lang.Exception -> L4d
|
|
if (r6 == 0) goto L42
|
|
java.util.LinkedHashMap r1 = new java.util.LinkedHashMap // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
r1.<init>() // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
int r2 = r6.getEventType() // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
r3 = r0
|
|
L1d:
|
|
r4 = 1
|
|
if (r2 == r4) goto L3b
|
|
r4 = 2
|
|
if (r2 != r4) goto L2c
|
|
java.lang.String r3 = r6.getName() // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
goto L36
|
|
L28:
|
|
r0 = move-exception
|
|
goto L6e
|
|
L2a:
|
|
r1 = move-exception
|
|
goto L4f
|
|
L2c:
|
|
r4 = 4
|
|
if (r2 != r4) goto L36
|
|
java.lang.String r2 = r6.getText() // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
r1.put(r3, r2) // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
L36:
|
|
int r2 = r6.next() // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
goto L1d
|
|
L3b:
|
|
r6.close() // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
r6.close()
|
|
return r1
|
|
L42:
|
|
java.lang.Exception r1 = new java.lang.Exception // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
r1.<init>() // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
throw r1 // Catch: java.lang.Throwable -> L28 java.lang.Exception -> L2a
|
|
L48:
|
|
r6 = move-exception
|
|
r5 = r0
|
|
r0 = r6
|
|
r6 = r5
|
|
goto L6e
|
|
L4d:
|
|
r1 = move-exception
|
|
r6 = r0
|
|
L4f:
|
|
java.lang.String r2 = "Utility"
|
|
java.lang.StringBuilder r3 = new java.lang.StringBuilder // Catch: java.lang.Throwable -> L28
|
|
r3.<init>() // Catch: java.lang.Throwable -> L28
|
|
java.lang.String r4 = "Error reading xml file: "
|
|
r3.append(r4) // Catch: java.lang.Throwable -> L28
|
|
r3.append(r1) // Catch: java.lang.Throwable -> L28
|
|
java.lang.String r1 = r3.toString() // Catch: java.lang.Throwable -> L28
|
|
r3 = 0
|
|
java.lang.Object[] r3 = new java.lang.Object[r3] // Catch: java.lang.Throwable -> L28
|
|
com.ea.nimble.Log.Helper.LOGES(r2, r1, r3) // Catch: java.lang.Throwable -> L28
|
|
if (r6 == 0) goto L6d
|
|
r6.close()
|
|
L6d:
|
|
return r0
|
|
L6e:
|
|
if (r6 == 0) goto L73
|
|
r6.close()
|
|
L73:
|
|
throw r0
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: com.ea.nimble.Utility.parseXmlFile(int):java.util.Map");
|
|
}
|
|
|
|
public static String readStringFromStream(InputStream inputStream) throws IOException {
|
|
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, Charset.defaultCharset());
|
|
char[] cArr = new char[4096];
|
|
StringWriter stringWriter = new StringWriter();
|
|
while (true) {
|
|
int read = inputStreamReader.read(cArr, 0, 4096);
|
|
if (read > 0) {
|
|
stringWriter.write(cArr, 0, read);
|
|
} else {
|
|
return stringWriter.toString();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static String getUTCDateStringFormat(Date date) {
|
|
if (date == null) {
|
|
return "";
|
|
}
|
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US);
|
|
simpleDateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
|
|
return simpleDateFormat.format(date);
|
|
}
|
|
|
|
public static boolean validString(String str) {
|
|
return str != null && str.length() > 0;
|
|
}
|
|
|
|
public static boolean validStringObject(Object obj) {
|
|
return obj != null && (obj instanceof String) && ((String) obj).length() > 0;
|
|
}
|
|
|
|
public static String convertObjectToJSONString(Object obj) {
|
|
return new GsonBuilder().disableHtmlEscaping().create().toJson(obj);
|
|
}
|
|
|
|
public static Map<String, Object> convertJSONObjectToMap(JSONObject jSONObject) {
|
|
HashMap hashMap = new HashMap();
|
|
Iterator<String> keys = jSONObject.keys();
|
|
while (keys.hasNext()) {
|
|
String next = keys.next();
|
|
if (jSONObject.isNull(next)) {
|
|
hashMap.put(next, null);
|
|
} else {
|
|
JSONObject optJSONObject = jSONObject.optJSONObject(next);
|
|
if (optJSONObject != null) {
|
|
hashMap.put(next, convertJSONObjectToMap(optJSONObject));
|
|
} else {
|
|
JSONArray optJSONArray = jSONObject.optJSONArray(next);
|
|
if (optJSONArray != null) {
|
|
hashMap.put(next, convertJSONArrayToList(optJSONArray));
|
|
} else {
|
|
try {
|
|
hashMap.put(next, jSONObject.get(next));
|
|
} catch (JSONException e) {
|
|
e.printStackTrace();
|
|
hashMap.put(next, null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return hashMap;
|
|
}
|
|
|
|
public static Map<String, Object> convertJSONObjectStringToMap(String str) {
|
|
try {
|
|
return convertJSONObjectToMap(new JSONObject(str));
|
|
} catch (JSONException e) {
|
|
e.printStackTrace();
|
|
return new HashMap();
|
|
}
|
|
}
|
|
|
|
public static List<Object> convertJSONArrayToList(JSONArray jSONArray) {
|
|
ArrayList arrayList = new ArrayList();
|
|
for (int i = 0; i < jSONArray.length(); i++) {
|
|
if (jSONArray.isNull(i)) {
|
|
arrayList.add(null);
|
|
} else {
|
|
JSONObject optJSONObject = jSONArray.optJSONObject(i);
|
|
if (optJSONObject != null) {
|
|
arrayList.add(convertJSONObjectToMap(optJSONObject));
|
|
} else {
|
|
JSONArray optJSONArray = jSONArray.optJSONArray(i);
|
|
if (optJSONArray != null) {
|
|
arrayList.add(convertJSONArrayToList(optJSONArray));
|
|
} else {
|
|
try {
|
|
arrayList.add(jSONArray.get(i));
|
|
} catch (JSONException e) {
|
|
e.printStackTrace();
|
|
arrayList.add(null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return arrayList;
|
|
}
|
|
|
|
public static String readFile(String str) {
|
|
try {
|
|
InputStream open = ApplicationEnvironment.getCurrentActivity().getAssets().open(str);
|
|
byte[] bArr = new byte[open.available()];
|
|
open.read(bArr);
|
|
open.close();
|
|
return new String(bArr, "UTF-8");
|
|
} catch (IOException e) {
|
|
Log.Helper.LOGVS("Utility", "readFile(): %s", e.toString());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static void sendBroadcast(String str) {
|
|
LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext()).sendBroadcast(new Intent(str));
|
|
}
|
|
|
|
public static void sendBroadcast(String str, Map<String, String> map) {
|
|
LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext());
|
|
Intent intent = new Intent(str);
|
|
if (map != null) {
|
|
for (Map.Entry<String, String> entry : map.entrySet()) {
|
|
intent.putExtra(entry.getKey(), entry.getValue());
|
|
}
|
|
}
|
|
localBroadcastManager.sendBroadcast(intent);
|
|
}
|
|
|
|
public static void sendBroadcast(String str, Bundle bundle) {
|
|
LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext()).sendBroadcast(new Intent(str).replaceExtras(bundle));
|
|
}
|
|
|
|
public static void sendBroadcastSerializable(String str, Map<String, Serializable> map) {
|
|
LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext());
|
|
Intent intent = new Intent(str);
|
|
if (map != null) {
|
|
for (Map.Entry<String, Serializable> entry : map.entrySet()) {
|
|
intent.putExtra(entry.getKey(), entry.getValue());
|
|
}
|
|
}
|
|
localBroadcastManager.sendBroadcast(intent);
|
|
}
|
|
|
|
public static void sendExplicitBroadcast(Intent intent) {
|
|
List<ResolveInfo> queryBroadcastReceivers;
|
|
PackageManager.ResolveInfoFlags of;
|
|
Context applicationContext = ApplicationEnvironment.getComponent().getApplicationContext();
|
|
PackageManager packageManager = applicationContext.getPackageManager();
|
|
if (Build.VERSION.SDK_INT >= 33) {
|
|
of = PackageManager.ResolveInfoFlags.of(0L);
|
|
queryBroadcastReceivers = packageManager.queryBroadcastReceivers(intent, of);
|
|
} else {
|
|
queryBroadcastReceivers = packageManager.queryBroadcastReceivers(intent, 0);
|
|
}
|
|
for (ResolveInfo resolveInfo : queryBroadcastReceivers) {
|
|
Intent intent2 = new Intent(intent);
|
|
ActivityInfo activityInfo = resolveInfo.activityInfo;
|
|
intent2.setComponent(new ComponentName(activityInfo.applicationInfo.packageName, activityInfo.name));
|
|
applicationContext.sendBroadcast(intent2);
|
|
}
|
|
}
|
|
|
|
public static void registerReceiver(String str, BroadcastReceiver broadcastReceiver) {
|
|
LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext()).registerReceiver(broadcastReceiver, new IntentFilter(str));
|
|
}
|
|
|
|
public static void unregisterReceiver(BroadcastReceiver broadcastReceiver) {
|
|
LocalBroadcastManager.getInstance(ApplicationEnvironment.getComponent().getApplicationContext()).unregisterReceiver(broadcastReceiver);
|
|
}
|
|
|
|
public static String SHA256HashString(String str) {
|
|
if (str == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
|
|
messageDigest.reset();
|
|
byte[] digest = messageDigest.digest(str.getBytes());
|
|
StringBuffer stringBuffer = new StringBuffer();
|
|
for (byte b : digest) {
|
|
stringBuffer.append(Integer.toString((b & 255) + 256, 16).substring(1));
|
|
}
|
|
return stringBuffer.toString();
|
|
} catch (NoSuchAlgorithmException unused) {
|
|
Log.Helper.LOGES("Utility", "Can't find SHA-256 algorithm", new Object[0]);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static byte[] SHA256Hash(String str) {
|
|
if (str == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
|
|
messageDigest.reset();
|
|
return messageDigest.digest(str.getBytes());
|
|
} catch (NoSuchAlgorithmException unused) {
|
|
Log.Helper.LOGES("Utility", "Can't find SHA-256 algorithm", new Object[0]);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static boolean stringsAreEquivalent(String str, String str2) {
|
|
return (str == null || str2 == null) ? str == str2 : str.compareTo(str2) == 0;
|
|
}
|
|
|
|
public static String bytesToHexString(byte[] bArr) {
|
|
char[] charArray = "0123456789ABCDEF".toCharArray();
|
|
char[] cArr = new char[bArr.length * 2];
|
|
for (int i = 0; i < bArr.length; i++) {
|
|
byte b = bArr[i];
|
|
int i2 = i * 2;
|
|
cArr[i2] = charArray[(b & 255) >> 4];
|
|
cArr[i2 + 1] = charArray[b & Ascii.SI];
|
|
}
|
|
return new String(cArr);
|
|
}
|
|
|
|
public static boolean isOnlyDecimalCharacters(String str) {
|
|
if (str == null) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < str.length(); i++) {
|
|
if (!Character.isDigit(str.charAt(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static String convertLiteralMapToString(Map<String, String> map) {
|
|
if (map == null) {
|
|
return "NULL";
|
|
}
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("{\n");
|
|
for (Map.Entry<String, String> entry : map.entrySet()) {
|
|
sb.append("\t\"");
|
|
sb.append(entry.getKey());
|
|
sb.append("\" = \"");
|
|
sb.append(entry.getValue());
|
|
sb.append("\",\n");
|
|
}
|
|
sb.deleteCharAt(sb.length() - 2);
|
|
sb.append("}");
|
|
return sb.toString();
|
|
}
|
|
|
|
public static void runOnWorkerThread(Runnable runnable) {
|
|
if (Looper.getMainLooper() == Looper.myLooper()) {
|
|
AsyncTask.SERIAL_EXECUTOR.execute(runnable);
|
|
} else {
|
|
runnable.run();
|
|
}
|
|
}
|
|
|
|
public static ApplicationInfo getApplicationInfo(int i) {
|
|
PackageManager.ApplicationInfoFlags of;
|
|
Activity currentActivity = ApplicationEnvironment.getCurrentActivity();
|
|
ApplicationInfo applicationInfo = null;
|
|
if (currentActivity != null) {
|
|
try {
|
|
PackageManager packageManager = currentActivity.getPackageManager();
|
|
if (packageManager == null) {
|
|
Log.Helper.LOGES("Utility", "PackageManager could not be obtained", new Object[0]);
|
|
} else if (Build.VERSION.SDK_INT >= 33) {
|
|
String packageName = currentActivity.getPackageName();
|
|
of = PackageManager.ApplicationInfoFlags.of(i);
|
|
applicationInfo = packageManager.getApplicationInfo(packageName, of);
|
|
} else {
|
|
applicationInfo = packageManager.getApplicationInfo(currentActivity.getPackageName(), i);
|
|
}
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
Log.Helper.LOGES("Utility", "Package name %s not found. Exception: %s", currentActivity.getPackageName(), e.toString());
|
|
}
|
|
} else {
|
|
Log.Helper.LOGES("Utility", "Application Context is null", new Object[0]);
|
|
}
|
|
return applicationInfo;
|
|
}
|
|
|
|
public static PackageInfo getPackageInfo(int i) {
|
|
PackageManager.PackageInfoFlags of;
|
|
Context applicationContext = ApplicationEnvironment.getComponent().getApplicationContext();
|
|
PackageInfo packageInfo = null;
|
|
if (applicationContext != null) {
|
|
try {
|
|
PackageManager packageManager = applicationContext.getPackageManager();
|
|
if (packageManager == null) {
|
|
Log.Helper.LOGES("Utility", "PackageManager could not be obtained", new Object[0]);
|
|
} else if (Build.VERSION.SDK_INT >= 33) {
|
|
String packageName = applicationContext.getPackageName();
|
|
of = PackageManager.PackageInfoFlags.of(i);
|
|
packageInfo = packageManager.getPackageInfo(packageName, of);
|
|
} else {
|
|
packageInfo = packageManager.getPackageInfo(applicationContext.getPackageName(), i);
|
|
}
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
Log.Helper.LOGES("Utility", "Package name %s not found. Exception: %s", applicationContext.getPackageName(), e.toString());
|
|
}
|
|
} else {
|
|
Log.Helper.LOGES("Utility", "Application Context is null", new Object[0]);
|
|
}
|
|
return packageInfo;
|
|
}
|
|
}
|