728 lines
26 KiB
Java
728 lines
26 KiB
Java
package com.adjust.sdk;
|
|
|
|
import android.content.ContentResolver;
|
|
import android.content.Context;
|
|
import android.content.res.Configuration;
|
|
import android.net.ConnectivityManager;
|
|
import android.net.Network;
|
|
import android.net.NetworkCapabilities;
|
|
import android.net.Uri;
|
|
import android.os.AsyncTask;
|
|
import android.os.Build;
|
|
import android.os.LocaleList;
|
|
import android.os.Looper;
|
|
import android.provider.Settings;
|
|
import android.telephony.TelephonyManager;
|
|
import android.text.TextUtils;
|
|
import c.d.b.a.a;
|
|
import com.adjust.sdk.GooglePlayServicesClient;
|
|
import com.adjust.sdk.scheduler.SingleThreadFutureScheduler;
|
|
import java.io.BufferedInputStream;
|
|
import java.io.BufferedOutputStream;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.NotSerializableException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.io.OutputStream;
|
|
import java.io.PrintWriter;
|
|
import java.io.StringWriter;
|
|
import java.math.BigInteger;
|
|
import java.security.MessageDigest;
|
|
import java.text.DecimalFormat;
|
|
import java.text.DecimalFormatSymbols;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.HashMap;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Random;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.Callable;
|
|
import java.util.concurrent.ExecutionException;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.TimeoutException;
|
|
import java.util.regex.Pattern;
|
|
public class Util {
|
|
private static final String DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'Z";
|
|
public static final DecimalFormat SecondsDisplayFormat = newLocalDecimalFormat();
|
|
public static final SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'Z", Locale.US);
|
|
private static final String fieldReadErrorMessage = "Unable to read '%s' field in migration device with message (%s)";
|
|
private static volatile SingleThreadFutureScheduler playAdIdScheduler = null;
|
|
|
|
/* renamed from: com.adjust.sdk.Util$1 reason: invalid class name */
|
|
public static class AnonymousClass1 implements Callable<Object> {
|
|
public final /* synthetic */ Context val$context;
|
|
|
|
public AnonymousClass1(Context context) {
|
|
this.val$context = context;
|
|
}
|
|
|
|
@Override // java.util.concurrent.Callable
|
|
public Object call() {
|
|
try {
|
|
return Reflection.getAdvertisingInfoObject(this.val$context);
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: com.adjust.sdk.Util$2 reason: invalid class name */
|
|
public static class AnonymousClass2 implements Callable<String> {
|
|
public final /* synthetic */ Object val$advertisingInfoObject;
|
|
public final /* synthetic */ Context val$context;
|
|
|
|
public AnonymousClass2(Context context, Object obj) {
|
|
this.val$context = context;
|
|
this.val$advertisingInfoObject = obj;
|
|
}
|
|
|
|
@Override // java.util.concurrent.Callable
|
|
public String call() {
|
|
return Reflection.getPlayAdId(this.val$context, this.val$advertisingInfoObject);
|
|
}
|
|
}
|
|
|
|
/* renamed from: com.adjust.sdk.Util$3 reason: invalid class name */
|
|
public static class AnonymousClass3 implements Callable<Boolean> {
|
|
public final /* synthetic */ Object val$advertisingInfoObject;
|
|
public final /* synthetic */ Context val$context;
|
|
|
|
public AnonymousClass3(Context context, Object obj) {
|
|
this.val$context = context;
|
|
this.val$advertisingInfoObject = obj;
|
|
}
|
|
|
|
@Override // java.util.concurrent.Callable
|
|
public Boolean call() {
|
|
return Reflection.isPlayTrackingEnabled(this.val$context, this.val$advertisingInfoObject);
|
|
}
|
|
}
|
|
|
|
/* renamed from: com.adjust.sdk.Util$4 reason: invalid class name */
|
|
public static class AnonymousClass4 extends AsyncTask<Object, Void, Void> {
|
|
@Override // android.os.AsyncTask
|
|
public Void doInBackground(Object... objArr) {
|
|
((Runnable) objArr[0]).run();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/* renamed from: com.adjust.sdk.Util$5 reason: invalid class name */
|
|
public static class AnonymousClass5 extends AsyncTask<Context, Void, String> {
|
|
public final /* synthetic */ OnDeviceIdsRead val$onDeviceIdRead;
|
|
|
|
public AnonymousClass5(OnDeviceIdsRead onDeviceIdsRead) {
|
|
this.val$onDeviceIdRead = onDeviceIdsRead;
|
|
}
|
|
|
|
public String doInBackground(Context... contextArr) {
|
|
ILogger logger = AdjustFactory.getLogger();
|
|
String access$000 = Util.access$000(contextArr[0]);
|
|
logger.debug(a.s("GoogleAdId read ", access$000), new Object[0]);
|
|
return access$000;
|
|
}
|
|
|
|
public void onPostExecute(String str) {
|
|
AdjustFactory.getLogger();
|
|
this.val$onDeviceIdRead.onGoogleAdIdRead(str);
|
|
}
|
|
}
|
|
|
|
public static /* synthetic */ String access$000(Context context) {
|
|
return getGoogleAdId(context);
|
|
}
|
|
|
|
public static boolean checkPermission(Context context, String str) {
|
|
try {
|
|
return context.checkCallingOrSelfPermission(str) == 0;
|
|
} catch (Exception e) {
|
|
getLogger().debug("Unable to check permission '%s' with message (%s)", str, e.getMessage());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static String convertToHex(byte[] bArr) {
|
|
return formatString(a.w(a.K("%0"), bArr.length << 1, "x"), new BigInteger(1, bArr));
|
|
}
|
|
|
|
public static String createUuid() {
|
|
return UUID.randomUUID().toString();
|
|
}
|
|
|
|
public static boolean equalBoolean(Boolean bool, Boolean bool2) {
|
|
return equalObject(bool, bool2);
|
|
}
|
|
|
|
public static boolean equalEnum(Enum r0, Enum r1) {
|
|
return equalObject(r0, r1);
|
|
}
|
|
|
|
public static boolean equalInt(Integer num, Integer num2) {
|
|
return equalObject(num, num2);
|
|
}
|
|
|
|
public static boolean equalLong(Long l, Long l2) {
|
|
return equalObject(l, l2);
|
|
}
|
|
|
|
public static boolean equalObject(Object obj, Object obj2) {
|
|
return (obj == null || obj2 == null) ? obj == null && obj2 == null : obj.equals(obj2);
|
|
}
|
|
|
|
public static boolean equalString(String str, String str2) {
|
|
return equalObject(str, str2);
|
|
}
|
|
|
|
public static boolean equalsDouble(Double d, Double d2) {
|
|
return (d == null || d2 == null) ? d == null && d2 == null : Double.doubleToLongBits(d.doubleValue()) == Double.doubleToLongBits(d2.doubleValue());
|
|
}
|
|
|
|
public static String formatString(String str, Object... objArr) {
|
|
return String.format(Locale.US, str, objArr);
|
|
}
|
|
|
|
public static Object getAdvertisingInfoObject(Context context, long j) {
|
|
return runSyncInPlayAdIdSchedulerWithTimeout(context, new AnonymousClass1(context), j);
|
|
}
|
|
|
|
public static String getAndroidId(Context context) {
|
|
return AndroidIdUtil.getAndroidId(context);
|
|
}
|
|
|
|
public static int getConnectivityType(Context context) {
|
|
NetworkCapabilities networkCapabilities;
|
|
try {
|
|
ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
|
|
if (connectivityManager == null) {
|
|
return -1;
|
|
}
|
|
int i = Build.VERSION.SDK_INT;
|
|
if (i < 23) {
|
|
return connectivityManager.getActiveNetworkInfo().getType();
|
|
}
|
|
Network activeNetwork = connectivityManager.getActiveNetwork();
|
|
if (activeNetwork == null || (networkCapabilities = connectivityManager.getNetworkCapabilities(activeNetwork)) == null) {
|
|
return -1;
|
|
}
|
|
if (networkCapabilities.hasTransport(1)) {
|
|
return 1;
|
|
}
|
|
if (networkCapabilities.hasTransport(0)) {
|
|
return 0;
|
|
}
|
|
if (networkCapabilities.hasTransport(3)) {
|
|
return 3;
|
|
}
|
|
if (networkCapabilities.hasTransport(4)) {
|
|
return 4;
|
|
}
|
|
if (networkCapabilities.hasTransport(2)) {
|
|
return 2;
|
|
}
|
|
if (i < 26) {
|
|
return -1;
|
|
}
|
|
if (networkCapabilities.hasTransport(5)) {
|
|
return 5;
|
|
}
|
|
return (i >= 27 && networkCapabilities.hasTransport(6)) ? 6 : -1;
|
|
} catch (Exception e) {
|
|
getLogger().warn("Couldn't read connectivity type (%s)", e.getMessage());
|
|
}
|
|
}
|
|
|
|
public static String getCpuAbi() {
|
|
return null;
|
|
}
|
|
|
|
public static String getFireAdvertisingId(ContentResolver contentResolver) {
|
|
if (contentResolver == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
return Settings.Secure.getString(contentResolver, "advertising_id");
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static Boolean getFireTrackingEnabled(ContentResolver contentResolver) {
|
|
try {
|
|
return Boolean.valueOf(Settings.Secure.getInt(contentResolver, "limit_ad_tracking") == 0);
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static String getGoogleAdId(Context context) {
|
|
Object advertisingInfoObject;
|
|
String str = null;
|
|
try {
|
|
GooglePlayServicesClient.GooglePlayServicesInfo googlePlayServicesInfo = GooglePlayServicesClient.getGooglePlayServicesInfo(context, 11000);
|
|
if (googlePlayServicesInfo != null) {
|
|
str = googlePlayServicesInfo.getGpsAdid();
|
|
}
|
|
} catch (Exception unused) {
|
|
}
|
|
return (str != null || (advertisingInfoObject = getAdvertisingInfoObject(context, 11000)) == null) ? str : getPlayAdId(context, advertisingInfoObject, 1000);
|
|
}
|
|
|
|
public static void getGoogleAdId(Context context, OnDeviceIdsRead onDeviceIdsRead) {
|
|
ILogger logger = AdjustFactory.getLogger();
|
|
if (Looper.myLooper() != Looper.getMainLooper()) {
|
|
logger.debug("GoogleAdId being read in the background", new Object[0]);
|
|
String googleAdId = getGoogleAdId(context);
|
|
logger.debug(a.s("GoogleAdId read ", googleAdId), new Object[0]);
|
|
onDeviceIdsRead.onGoogleAdIdRead(googleAdId);
|
|
return;
|
|
}
|
|
logger.debug("GoogleAdId being read in the foreground", new Object[0]);
|
|
new AnonymousClass5(onDeviceIdsRead).execute(context);
|
|
}
|
|
|
|
public static Locale getLocale(Configuration configuration) {
|
|
LocaleList locales;
|
|
int i = Build.VERSION.SDK_INT;
|
|
if (i >= 24 && (locales = configuration.getLocales()) != null && !locales.isEmpty()) {
|
|
return locales.get(0);
|
|
}
|
|
if (i < 24) {
|
|
return configuration.locale;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static ILogger getLogger() {
|
|
return AdjustFactory.getLogger();
|
|
}
|
|
|
|
public static String getMacAddress(Context context) {
|
|
return MacAddressUtil.getMacAddress(context);
|
|
}
|
|
|
|
public static String getMcc(Context context) {
|
|
try {
|
|
String networkOperator = ((TelephonyManager) context.getSystemService("phone")).getNetworkOperator();
|
|
if (!TextUtils.isEmpty(networkOperator)) {
|
|
return networkOperator.substring(0, 3);
|
|
}
|
|
AdjustFactory.getLogger().warn("Couldn't receive networkOperator string to read MCC", new Object[0]);
|
|
return null;
|
|
} catch (Exception unused) {
|
|
AdjustFactory.getLogger().warn("Couldn't return mcc", new Object[0]);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static String getMnc(Context context) {
|
|
try {
|
|
String networkOperator = ((TelephonyManager) context.getSystemService("phone")).getNetworkOperator();
|
|
if (!TextUtils.isEmpty(networkOperator)) {
|
|
return networkOperator.substring(3);
|
|
}
|
|
AdjustFactory.getLogger().warn("Couldn't receive networkOperator string to read MNC", new Object[0]);
|
|
return null;
|
|
} catch (Exception unused) {
|
|
AdjustFactory.getLogger().warn("Couldn't return mnc", new Object[0]);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static int getNetworkType(Context context) {
|
|
try {
|
|
return ((TelephonyManager) context.getSystemService("phone")).getNetworkType();
|
|
} catch (Exception e) {
|
|
getLogger().warn("Couldn't read network type (%s)", e.getMessage());
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
public static String getPlayAdId(Context context, Object obj, long j) {
|
|
return (String) runSyncInPlayAdIdSchedulerWithTimeout(context, new AnonymousClass2(context, obj), j);
|
|
}
|
|
|
|
public static String getReasonString(String str, Throwable th) {
|
|
return th != null ? formatString("%s: %s", str, th) : formatString("%s", str);
|
|
}
|
|
|
|
public static String getRootCause(Exception exc) {
|
|
if (!hasRootCause(exc)) {
|
|
return null;
|
|
}
|
|
StringWriter stringWriter = new StringWriter();
|
|
exc.printStackTrace(new PrintWriter(stringWriter));
|
|
String stringWriter2 = stringWriter.toString();
|
|
int indexOf = stringWriter2.indexOf("Caused by:");
|
|
return stringWriter2.substring(indexOf, stringWriter2.indexOf("\n", indexOf));
|
|
}
|
|
|
|
private static String getSdkPrefix(String str) {
|
|
String[] split;
|
|
if (str != null && str.contains("@") && (split = str.split("@")) != null && split.length == 2) {
|
|
return split[0];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static String getSdkPrefixPlatform(String str) {
|
|
String[] split;
|
|
String sdkPrefix = getSdkPrefix(str);
|
|
if (sdkPrefix == null || (split = sdkPrefix.split("\\d+", 2)) == null || split.length == 0) {
|
|
return null;
|
|
}
|
|
return split[0];
|
|
}
|
|
|
|
public static String getSdkVersion() {
|
|
return "android4.22.0";
|
|
}
|
|
|
|
public static String[] getSupportedAbis() {
|
|
return Build.SUPPORTED_ABIS;
|
|
}
|
|
|
|
public static long getWaitingTime(int i, BackoffStrategy backoffStrategy) {
|
|
int i2 = backoffStrategy.minRetries;
|
|
if (i < i2) {
|
|
return 0;
|
|
}
|
|
return (long) (((double) Math.min(((long) Math.pow(2.0d, (double) (i - i2))) * backoffStrategy.milliSecondMultiplier, backoffStrategy.maxWait)) * randomInRange(backoffStrategy.minRange, backoffStrategy.maxRange));
|
|
}
|
|
|
|
public static boolean hasRootCause(Exception exc) {
|
|
StringWriter stringWriter = new StringWriter();
|
|
exc.printStackTrace(new PrintWriter(stringWriter));
|
|
return stringWriter.toString().contains("Caused by:");
|
|
}
|
|
|
|
public static String hash(String str, String str2) {
|
|
try {
|
|
byte[] bytes = str.getBytes("UTF-8");
|
|
MessageDigest instance = MessageDigest.getInstance(str2);
|
|
instance.update(bytes, 0, bytes.length);
|
|
return convertToHex(instance.digest());
|
|
} catch (Exception unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static int hashBoolean(Boolean bool) {
|
|
if (bool == null) {
|
|
return 0;
|
|
}
|
|
return bool.hashCode();
|
|
}
|
|
|
|
public static int hashEnum(Enum r0) {
|
|
if (r0 == null) {
|
|
return 0;
|
|
}
|
|
return r0.hashCode();
|
|
}
|
|
|
|
public static int hashLong(Long l) {
|
|
if (l == null) {
|
|
return 0;
|
|
}
|
|
return l.hashCode();
|
|
}
|
|
|
|
public static int hashObject(Object obj) {
|
|
if (obj == null) {
|
|
return 0;
|
|
}
|
|
return obj.hashCode();
|
|
}
|
|
|
|
public static int hashString(String str) {
|
|
if (str == null) {
|
|
return 0;
|
|
}
|
|
return str.hashCode();
|
|
}
|
|
|
|
public static Boolean isPlayTrackingEnabled(Context context, Object obj, long j) {
|
|
return (Boolean) runSyncInPlayAdIdSchedulerWithTimeout(context, new AnonymousClass3(context, obj), j);
|
|
}
|
|
|
|
public static boolean isUrlFilteredOut(Uri uri) {
|
|
String uri2;
|
|
return uri == null || (uri2 = uri.toString()) == null || uri2.length() == 0 || uri2.matches("^(fb|vk)[0-9]{5,}[^:]*://authorize.*access_token=.*");
|
|
}
|
|
|
|
public static boolean isValidParameter(String str, String str2, String str3) {
|
|
if (str == null) {
|
|
getLogger().error("%s parameter %s is missing", str3, str2);
|
|
return false;
|
|
} else if (!str.equals("")) {
|
|
return true;
|
|
} else {
|
|
getLogger().error("%s parameter %s is empty", str3, str2);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static String md5(String str) {
|
|
return hash(str, "MD5");
|
|
}
|
|
|
|
public static Map<String, String> mergeParameters(Map<String, String> map, Map<String, String> map2, String str) {
|
|
if (map == null) {
|
|
return map2;
|
|
}
|
|
if (map2 == null) {
|
|
return map;
|
|
}
|
|
HashMap hashMap = new HashMap(map);
|
|
ILogger logger = getLogger();
|
|
for (Map.Entry<String, String> entry : map2.entrySet()) {
|
|
String str2 = (String) hashMap.put(entry.getKey(), entry.getValue());
|
|
if (str2 != null) {
|
|
logger.warn("Key %s with value %s from %s parameter was replaced by value %s", entry.getKey(), str2, str, entry.getValue());
|
|
}
|
|
}
|
|
return hashMap;
|
|
}
|
|
|
|
private static DecimalFormat newLocalDecimalFormat() {
|
|
return new DecimalFormat("0.0", new DecimalFormatSymbols(Locale.US));
|
|
}
|
|
|
|
public static String quote(String str) {
|
|
if (str == null) {
|
|
return null;
|
|
}
|
|
return !Pattern.compile("\\s").matcher(str).find() ? str : formatString("'%s'", str);
|
|
}
|
|
|
|
private static double randomInRange(double d, double d2) {
|
|
return (new Random().nextDouble() * (d2 - d)) + d;
|
|
}
|
|
|
|
public static boolean readBooleanField(ObjectInputStream.GetField getField, String str, boolean z2) {
|
|
try {
|
|
return getField.get(str, z2);
|
|
} catch (Exception e) {
|
|
getLogger().debug("Unable to read '%s' field in migration device with message (%s)", str, e.getMessage());
|
|
return z2;
|
|
}
|
|
}
|
|
|
|
public static int readIntField(ObjectInputStream.GetField getField, String str, int i) {
|
|
try {
|
|
return getField.get(str, i);
|
|
} catch (Exception e) {
|
|
getLogger().debug("Unable to read '%s' field in migration device with message (%s)", str, e.getMessage());
|
|
return i;
|
|
}
|
|
}
|
|
|
|
public static long readLongField(ObjectInputStream.GetField getField, String str, long j) {
|
|
try {
|
|
return getField.get(str, j);
|
|
} catch (Exception e) {
|
|
getLogger().debug("Unable to read '%s' field in migration device with message (%s)", str, e.getMessage());
|
|
return j;
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Multi-variable type inference failed */
|
|
/* JADX WARNING: Removed duplicated region for block: B:31:0x00a2 A[SYNTHETIC, Splitter:B:31:0x00a2] */
|
|
/* JADX WARNING: Unknown variable types count: 1 */
|
|
public static <T> T readObject(Context context, String str, String str2, Class<T> cls) {
|
|
ObjectInputStream objectInputStream;
|
|
T t;
|
|
Exception e;
|
|
T t2 = null;
|
|
try {
|
|
FileInputStream openFileInput = context.openFileInput(str);
|
|
try {
|
|
?? bufferedInputStream = new BufferedInputStream(openFileInput);
|
|
try {
|
|
objectInputStream = new ObjectInputStream(bufferedInputStream);
|
|
try {
|
|
t2 = cls.cast(objectInputStream.readObject());
|
|
getLogger().debug("Read %s: %s", str2, t2);
|
|
} catch (ClassNotFoundException e2) {
|
|
getLogger().error("Failed to find %s class (%s)", str2, e2.getMessage());
|
|
} catch (ClassCastException e3) {
|
|
getLogger().error("Failed to cast %s object (%s)", str2, e3.getMessage());
|
|
} catch (Exception e4) {
|
|
getLogger().error("Failed to read %s object (%s)", str2, e4.getMessage());
|
|
}
|
|
} catch (FileNotFoundException unused) {
|
|
t = null;
|
|
t2 = bufferedInputStream;
|
|
getLogger().debug("%s file not found", str2);
|
|
t2 = t;
|
|
objectInputStream = t2;
|
|
if (objectInputStream != null) {
|
|
}
|
|
return t2;
|
|
} catch (Exception e5) {
|
|
e = e5;
|
|
t = null;
|
|
t2 = bufferedInputStream;
|
|
getLogger().error("Failed to open %s file for reading (%s)", str2, e);
|
|
t2 = t;
|
|
objectInputStream = t2;
|
|
if (objectInputStream != null) {
|
|
}
|
|
return t2;
|
|
}
|
|
} catch (FileNotFoundException unused2) {
|
|
t2 = (T) openFileInput;
|
|
t = null;
|
|
getLogger().debug("%s file not found", str2);
|
|
t2 = t;
|
|
objectInputStream = t2;
|
|
if (objectInputStream != null) {
|
|
}
|
|
return t2;
|
|
} catch (Exception e6) {
|
|
e = e6;
|
|
t2 = (T) openFileInput;
|
|
t = null;
|
|
getLogger().error("Failed to open %s file for reading (%s)", str2, e);
|
|
t2 = t;
|
|
objectInputStream = t2;
|
|
if (objectInputStream != null) {
|
|
}
|
|
return t2;
|
|
}
|
|
} catch (FileNotFoundException unused3) {
|
|
t = null;
|
|
getLogger().debug("%s file not found", str2);
|
|
t2 = t;
|
|
objectInputStream = t2;
|
|
if (objectInputStream != null) {
|
|
}
|
|
return t2;
|
|
} catch (Exception e7) {
|
|
e = e7;
|
|
t = null;
|
|
getLogger().error("Failed to open %s file for reading (%s)", str2, e);
|
|
t2 = t;
|
|
objectInputStream = t2;
|
|
if (objectInputStream != null) {
|
|
}
|
|
return t2;
|
|
}
|
|
if (objectInputStream != null) {
|
|
try {
|
|
objectInputStream.close();
|
|
} catch (Exception e8) {
|
|
getLogger().error("Failed to close %s file for reading (%s)", str2, e8);
|
|
}
|
|
}
|
|
return t2;
|
|
}
|
|
|
|
public static <T> T readObjectField(ObjectInputStream.GetField getField, String str, T t) {
|
|
try {
|
|
return (T) getField.get(str, t);
|
|
} catch (Exception e) {
|
|
getLogger().debug("Unable to read '%s' field in migration device with message (%s)", str, e.getMessage());
|
|
return t;
|
|
}
|
|
}
|
|
|
|
public static String readStringField(ObjectInputStream.GetField getField, String str, String str2) {
|
|
return (String) readObjectField(getField, str, str2);
|
|
}
|
|
|
|
public static boolean resolveContentProvider(Context context, String str) {
|
|
try {
|
|
return context.getPackageManager().resolveContentProvider(str, 0) != null;
|
|
} catch (Exception unused) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static void runInBackground(Runnable runnable) {
|
|
if (Looper.myLooper() != Looper.getMainLooper()) {
|
|
runnable.run();
|
|
} else {
|
|
new AnonymousClass4().execute(runnable);
|
|
}
|
|
}
|
|
|
|
private static <R> R runSyncInPlayAdIdSchedulerWithTimeout(Context context, Callable<R> callable, long j) {
|
|
if (playAdIdScheduler == null) {
|
|
synchronized (Util.class) {
|
|
if (playAdIdScheduler == null) {
|
|
playAdIdScheduler = new SingleThreadFutureScheduler("PlayAdIdLibrary", true);
|
|
}
|
|
}
|
|
}
|
|
try {
|
|
return (R) playAdIdScheduler.scheduleFutureWithReturn(callable, 0).get(j, TimeUnit.MILLISECONDS);
|
|
} catch (InterruptedException | ExecutionException | TimeoutException unused) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static String sha1(String str) {
|
|
return hash(str, "SHA-1");
|
|
}
|
|
|
|
public static String sha256(String str) {
|
|
return hash(str, "SHA-256");
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:18:0x004a A[SYNTHETIC, Splitter:B:18:0x004a] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:23:? A[RETURN, SYNTHETIC] */
|
|
public static <T> void writeObject(T t, Context context, String str, String str2) {
|
|
ObjectOutputStream objectOutputStream;
|
|
ObjectOutputStream objectOutputStream2;
|
|
Exception e;
|
|
OutputStream bufferedOutputStream;
|
|
try {
|
|
OutputStream openFileOutput = context.openFileOutput(str, 0);
|
|
try {
|
|
bufferedOutputStream = new BufferedOutputStream(openFileOutput);
|
|
} catch (Exception e2) {
|
|
e = e2;
|
|
objectOutputStream2 = openFileOutput;
|
|
getLogger().error("Failed to open %s for writing (%s)", str2, e);
|
|
objectOutputStream = objectOutputStream2;
|
|
if (objectOutputStream == null) {
|
|
}
|
|
}
|
|
try {
|
|
ObjectOutputStream objectOutputStream3 = new ObjectOutputStream(bufferedOutputStream);
|
|
try {
|
|
objectOutputStream3.writeObject(t);
|
|
getLogger().debug("Wrote %s: %s", str2, t);
|
|
objectOutputStream = objectOutputStream3;
|
|
} catch (NotSerializableException unused) {
|
|
getLogger().error("Failed to serialize %s", str2);
|
|
objectOutputStream = objectOutputStream3;
|
|
}
|
|
} catch (Exception e3) {
|
|
e = e3;
|
|
objectOutputStream2 = bufferedOutputStream;
|
|
getLogger().error("Failed to open %s for writing (%s)", str2, e);
|
|
objectOutputStream = objectOutputStream2;
|
|
if (objectOutputStream == null) {
|
|
}
|
|
}
|
|
} catch (Exception e4) {
|
|
e = e4;
|
|
objectOutputStream2 = null;
|
|
getLogger().error("Failed to open %s for writing (%s)", str2, e);
|
|
objectOutputStream = objectOutputStream2;
|
|
if (objectOutputStream == null) {
|
|
}
|
|
}
|
|
if (objectOutputStream == null) {
|
|
try {
|
|
objectOutputStream.close();
|
|
} catch (Exception e5) {
|
|
getLogger().error("Failed to close %s file for writing (%s)", str2, e5);
|
|
}
|
|
}
|
|
}
|
|
}
|