Daniel Elliott
f9d20bb3fc
- 28,932 files - Full Java source code - Smali files - Resources Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
914 lines
42 KiB
Java
914 lines
42 KiB
Java
package com.facebook;
|
|
|
|
import android.app.Application;
|
|
import android.content.Context;
|
|
import android.content.SharedPreferences;
|
|
import android.content.pm.ApplicationInfo;
|
|
import android.content.pm.PackageInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.Signature;
|
|
import android.os.AsyncTask;
|
|
import android.support.v4.media.session.PlaybackStateCompat;
|
|
import android.util.Base64;
|
|
import android.util.Log;
|
|
import androidx.annotation.RestrictTo;
|
|
import androidx.annotation.VisibleForTesting;
|
|
import com.facebook.FacebookSdk;
|
|
import com.facebook.GraphRequest;
|
|
import com.facebook.Profile;
|
|
import com.facebook.appevents.AppEventsLogger;
|
|
import com.facebook.appevents.AppEventsLoggerImpl;
|
|
import com.facebook.appevents.AppEventsManager;
|
|
import com.facebook.appevents.internal.ActivityLifecycleTracker;
|
|
import com.facebook.appevents.internal.AppEventsLoggerUtility;
|
|
import com.facebook.appevents.ondeviceprocessing.OnDeviceProcessingManager;
|
|
import com.facebook.internal.AttributionIdentifiers;
|
|
import com.facebook.internal.BoltsMeasurementEventListener;
|
|
import com.facebook.internal.FeatureManager;
|
|
import com.facebook.internal.FetchedAppGateKeepersManager;
|
|
import com.facebook.internal.FetchedAppSettingsManager;
|
|
import com.facebook.internal.LockOnGetVariable;
|
|
import com.facebook.internal.Logger;
|
|
import com.facebook.internal.NativeProtocol;
|
|
import com.facebook.internal.ServerProtocol;
|
|
import com.facebook.internal.Utility;
|
|
import com.facebook.internal.Validate;
|
|
import com.facebook.internal.instrument.InstrumentManager;
|
|
import com.facebook.internal.instrument.crashshield.CrashShieldHandler;
|
|
import com.unity3d.ads.core.data.datasource.AndroidStaticDeviceInfoDataSource;
|
|
import java.io.File;
|
|
import java.security.MessageDigest;
|
|
import java.security.NoSuchAlgorithmException;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Set;
|
|
import java.util.concurrent.Callable;
|
|
import java.util.concurrent.Executor;
|
|
import java.util.concurrent.FutureTask;
|
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
import java.util.concurrent.atomic.AtomicLong;
|
|
import java.util.concurrent.locks.ReentrantLock;
|
|
import kotlin.Unit;
|
|
import kotlin.collections.ArraysKt___ArraysKt;
|
|
import kotlin.collections.SetsKt__SetsKt;
|
|
import kotlin.jvm.internal.Intrinsics;
|
|
import kotlin.jvm.internal.StringCompanionObject;
|
|
import kotlin.text.StringsKt__StringsJVMKt;
|
|
import org.json.JSONArray;
|
|
import org.json.JSONException;
|
|
import org.json.JSONObject;
|
|
|
|
/* loaded from: classes2.dex */
|
|
public final class FacebookSdk {
|
|
public static final String ADVERTISER_ID_COLLECTION_ENABLED_PROPERTY = "com.facebook.sdk.AdvertiserIDCollectionEnabled";
|
|
public static final String APPLICATION_ID_PROPERTY = "com.facebook.sdk.ApplicationId";
|
|
public static final String APPLICATION_NAME_PROPERTY = "com.facebook.sdk.ApplicationName";
|
|
public static final String APP_EVENT_PREFERENCES = "com.facebook.sdk.appEventPreferences";
|
|
private static final String ATTRIBUTION_PREFERENCES = "com.facebook.sdk.attributionTracking";
|
|
public static final String AUTO_INIT_ENABLED_PROPERTY = "com.facebook.sdk.AutoInitEnabled";
|
|
public static final String AUTO_LOG_APP_EVENTS_ENABLED_PROPERTY = "com.facebook.sdk.AutoLogAppEventsEnabled";
|
|
public static final String CALLBACK_OFFSET_CHANGED_AFTER_INIT = "The callback request code offset can't be updated once the SDK is initialized. Call FacebookSdk.setCallbackRequestCodeOffset inside your Application.onCreate method";
|
|
public static final String CALLBACK_OFFSET_NEGATIVE = "The callback request code offset can't be negative.";
|
|
public static final String CALLBACK_OFFSET_PROPERTY = "com.facebook.sdk.CallbackOffset";
|
|
public static final String CLIENT_TOKEN_PROPERTY = "com.facebook.sdk.ClientToken";
|
|
public static final String CLOUDBRIDGE_SAVED_CREDENTIALS = "com.facebook.sdk.CloudBridgeSavedCredentials";
|
|
public static final String CODELESS_DEBUG_LOG_ENABLED_PROPERTY = "com.facebook.sdk.CodelessDebugLogEnabled";
|
|
public static final String DATA_PROCESSING_OPTIONS_PREFERENCES = "com.facebook.sdk.DataProcessingOptions";
|
|
public static final String DATA_PROCESSION_OPTIONS = "data_processing_options";
|
|
public static final String DATA_PROCESSION_OPTIONS_COUNTRY = "data_processing_options_country";
|
|
public static final String DATA_PROCESSION_OPTIONS_STATE = "data_processing_options_state";
|
|
private static final int DEFAULT_CALLBACK_REQUEST_CODE_OFFSET = 64206;
|
|
public static final String FACEBOOK_COM = "facebook.com";
|
|
public static final String FB_GG = "fb.gg";
|
|
public static final String GAMING = "gaming";
|
|
public static final String INSTAGRAM = "instagram";
|
|
public static final String INSTAGRAM_COM = "instagram.com";
|
|
private static final ReentrantLock LOCK;
|
|
private static final int MAX_REQUEST_CODE_RANGE = 100;
|
|
public static final String MONITOR_ENABLED_PROPERTY = "com.facebook.sdk.MonitorEnabled";
|
|
private static final String PUBLISH_ACTIVITY_PATH = "%s/activities";
|
|
public static final String WEB_DIALOG_THEME = "com.facebook.sdk.WebDialogTheme";
|
|
private static volatile String appClientToken;
|
|
private static Context applicationContext;
|
|
private static volatile String applicationId;
|
|
private static volatile String applicationName;
|
|
public static boolean bypassAppSwitch;
|
|
private static LockOnGetVariable<File> cacheDir;
|
|
private static int callbackRequestCodeOffset;
|
|
private static volatile Boolean codelessDebugLogEnabled;
|
|
private static Executor executor;
|
|
private static volatile String facebookDomain;
|
|
private static String graphApiVersion;
|
|
private static GraphRequestCreator graphRequestCreator;
|
|
public static boolean hasCustomTabsPrefetching;
|
|
public static boolean ignoreAppSwitchToLoggedOut;
|
|
private static volatile String instagramDomain;
|
|
private static volatile boolean isDebugEnabledField;
|
|
private static boolean isFullyInitialized;
|
|
private static boolean isLegacyTokenUpgradeSupported;
|
|
private static final HashSet<LoggingBehavior> loggingBehaviors;
|
|
private static AtomicLong onProgressThreshold;
|
|
private static final AtomicBoolean sdkInitialized;
|
|
public static final FacebookSdk INSTANCE = new FacebookSdk();
|
|
private static final String TAG = FacebookSdk.class.getCanonicalName();
|
|
|
|
@VisibleForTesting
|
|
public interface GraphRequestCreator {
|
|
GraphRequest createPostRequest(AccessToken accessToken, String str, JSONObject jSONObject, GraphRequest.Callback callback);
|
|
}
|
|
|
|
public interface InitializeCallback {
|
|
void onInitialized();
|
|
}
|
|
|
|
public static final void fullyInitialize() {
|
|
isFullyInitialized = true;
|
|
}
|
|
|
|
public static final String getFacebookDomain() {
|
|
return facebookDomain;
|
|
}
|
|
|
|
public static final String getFacebookGamingDomain() {
|
|
return "fb.gg";
|
|
}
|
|
|
|
public static final String getInstagramDomain() {
|
|
return instagramDomain;
|
|
}
|
|
|
|
public static final String getSdkVersion() {
|
|
return FacebookSdkVersion.BUILD;
|
|
}
|
|
|
|
public static final boolean isDebugEnabled() {
|
|
return isDebugEnabledField;
|
|
}
|
|
|
|
public static final boolean isFacebookRequestCode(int i) {
|
|
int i2 = callbackRequestCodeOffset;
|
|
return i >= i2 && i < i2 + 100;
|
|
}
|
|
|
|
public static final boolean isLegacyTokenUpgradeSupported() {
|
|
return isLegacyTokenUpgradeSupported;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: sdkInitialize$lambda-6, reason: not valid java name */
|
|
public static final void m430sdkInitialize$lambda6(boolean z) {
|
|
if (z) {
|
|
hasCustomTabsPrefetching = true;
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: sdkInitialize$lambda-7, reason: not valid java name */
|
|
public static final void m431sdkInitialize$lambda7(boolean z) {
|
|
if (z) {
|
|
ignoreAppSwitchToLoggedOut = true;
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: sdkInitialize$lambda-8, reason: not valid java name */
|
|
public static final void m432sdkInitialize$lambda8(boolean z) {
|
|
if (z) {
|
|
bypassAppSwitch = true;
|
|
}
|
|
}
|
|
|
|
public static final void setApplicationName(String str) {
|
|
applicationName = str;
|
|
}
|
|
|
|
public static final void setClientToken(String str) {
|
|
appClientToken = str;
|
|
}
|
|
|
|
@VisibleForTesting
|
|
public static final void setGraphRequestCreator$facebook_core_release(GraphRequestCreator graphRequestCreator2) {
|
|
Intrinsics.checkNotNullParameter(graphRequestCreator2, "graphRequestCreator");
|
|
graphRequestCreator = graphRequestCreator2;
|
|
}
|
|
|
|
public static final void setIsDebugEnabled(boolean z) {
|
|
isDebugEnabledField = z;
|
|
}
|
|
|
|
public static final void setLegacyTokenUpgradeSupported(boolean z) {
|
|
isLegacyTokenUpgradeSupported = z;
|
|
}
|
|
|
|
private FacebookSdk() {
|
|
}
|
|
|
|
static {
|
|
HashSet<LoggingBehavior> hashSetOf;
|
|
hashSetOf = SetsKt__SetsKt.hashSetOf(LoggingBehavior.DEVELOPER_ERRORS);
|
|
loggingBehaviors = hashSetOf;
|
|
onProgressThreshold = new AtomicLong(PlaybackStateCompat.ACTION_PREPARE_FROM_SEARCH);
|
|
callbackRequestCodeOffset = DEFAULT_CALLBACK_REQUEST_CODE_OFFSET;
|
|
LOCK = new ReentrantLock();
|
|
graphApiVersion = ServerProtocol.getDefaultAPIVersion();
|
|
sdkInitialized = new AtomicBoolean(false);
|
|
instagramDomain = INSTAGRAM_COM;
|
|
facebookDomain = FACEBOOK_COM;
|
|
graphRequestCreator = new GraphRequestCreator() { // from class: com.facebook.FacebookSdk$$ExternalSyntheticLambda8
|
|
@Override // com.facebook.FacebookSdk.GraphRequestCreator
|
|
public final GraphRequest createPostRequest(AccessToken accessToken, String str, JSONObject jSONObject, GraphRequest.Callback callback) {
|
|
GraphRequest m425graphRequestCreator$lambda0;
|
|
m425graphRequestCreator$lambda0 = FacebookSdk.m425graphRequestCreator$lambda0(accessToken, str, jSONObject, callback);
|
|
return m425graphRequestCreator$lambda0;
|
|
}
|
|
};
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: graphRequestCreator$lambda-0, reason: not valid java name */
|
|
public static final GraphRequest m425graphRequestCreator$lambda0(AccessToken accessToken, String str, JSONObject jSONObject, GraphRequest.Callback callback) {
|
|
return GraphRequest.Companion.newPostRequest(accessToken, str, jSONObject, callback);
|
|
}
|
|
|
|
public static final Executor getExecutor() {
|
|
ReentrantLock reentrantLock = LOCK;
|
|
reentrantLock.lock();
|
|
try {
|
|
if (executor == null) {
|
|
executor = AsyncTask.THREAD_POOL_EXECUTOR;
|
|
}
|
|
Unit unit = Unit.INSTANCE;
|
|
reentrantLock.unlock();
|
|
Executor executor2 = executor;
|
|
if (executor2 != null) {
|
|
return executor2;
|
|
}
|
|
throw new IllegalStateException("Required value was null.".toString());
|
|
} catch (Throwable th) {
|
|
reentrantLock.unlock();
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
public static final void setExecutor(Executor executor2) {
|
|
Intrinsics.checkNotNullParameter(executor2, "executor");
|
|
ReentrantLock reentrantLock = LOCK;
|
|
reentrantLock.lock();
|
|
try {
|
|
executor = executor2;
|
|
Unit unit = Unit.INSTANCE;
|
|
} finally {
|
|
reentrantLock.unlock();
|
|
}
|
|
}
|
|
|
|
public static final long getOnProgressThreshold() {
|
|
Validate.sdkInitialized();
|
|
return onProgressThreshold.get();
|
|
}
|
|
|
|
public static final void setOnProgressThreshold(long j) {
|
|
onProgressThreshold.set(j);
|
|
}
|
|
|
|
public static final String getGraphApiVersion() {
|
|
Utility utility = Utility.INSTANCE;
|
|
String str = TAG;
|
|
StringCompanionObject stringCompanionObject = StringCompanionObject.INSTANCE;
|
|
String format = String.format("getGraphApiVersion: %s", Arrays.copyOf(new Object[]{graphApiVersion}, 1));
|
|
Intrinsics.checkNotNullExpressionValue(format, "java.lang.String.format(format, *args)");
|
|
Utility.logd(str, format);
|
|
return graphApiVersion;
|
|
}
|
|
|
|
public static final void setGraphApiVersion(String graphApiVersion2) {
|
|
Intrinsics.checkNotNullParameter(graphApiVersion2, "graphApiVersion");
|
|
Log.w(TAG, "WARNING: Calling setGraphApiVersion from non-DEBUG code.");
|
|
if (Utility.isNullOrEmpty(graphApiVersion2) || Intrinsics.areEqual(graphApiVersion, graphApiVersion2)) {
|
|
return;
|
|
}
|
|
graphApiVersion = graphApiVersion2;
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
|
|
public static final synchronized boolean isFullyInitialized() {
|
|
boolean z;
|
|
synchronized (FacebookSdk.class) {
|
|
z = isFullyInitialized;
|
|
}
|
|
return z;
|
|
}
|
|
|
|
public static final void setFacebookDomain(String facebookDomain2) {
|
|
Intrinsics.checkNotNullParameter(facebookDomain2, "facebookDomain");
|
|
Log.w(TAG, "WARNING: Calling setFacebookDomain from non-DEBUG code.");
|
|
facebookDomain = facebookDomain2;
|
|
}
|
|
|
|
public static final synchronized void sdkInitialize(Context applicationContext2, int i) {
|
|
synchronized (FacebookSdk.class) {
|
|
Intrinsics.checkNotNullParameter(applicationContext2, "applicationContext");
|
|
sdkInitialize(applicationContext2, i, null);
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:13:0x0021, code lost:
|
|
|
|
com.facebook.FacebookSdk.callbackRequestCodeOffset = r3;
|
|
sdkInitialize(r2, r4);
|
|
*/
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public static final synchronized void sdkInitialize(android.content.Context r2, int r3, com.facebook.FacebookSdk.InitializeCallback r4) {
|
|
/*
|
|
java.lang.Class<com.facebook.FacebookSdk> r0 = com.facebook.FacebookSdk.class
|
|
monitor-enter(r0)
|
|
java.lang.String r1 = "applicationContext"
|
|
kotlin.jvm.internal.Intrinsics.checkNotNullParameter(r2, r1) // Catch: java.lang.Throwable -> L1d
|
|
java.util.concurrent.atomic.AtomicBoolean r1 = com.facebook.FacebookSdk.sdkInitialized // Catch: java.lang.Throwable -> L1d
|
|
boolean r1 = r1.get() // Catch: java.lang.Throwable -> L1d
|
|
if (r1 == 0) goto L1f
|
|
int r1 = com.facebook.FacebookSdk.callbackRequestCodeOffset // Catch: java.lang.Throwable -> L1d
|
|
if (r3 != r1) goto L15
|
|
goto L1f
|
|
L15:
|
|
com.facebook.FacebookException r2 = new com.facebook.FacebookException // Catch: java.lang.Throwable -> L1d
|
|
java.lang.String r3 = "The callback request code offset can't be updated once the SDK is initialized. Call FacebookSdk.setCallbackRequestCodeOffset inside your Application.onCreate method"
|
|
r2.<init>(r3) // Catch: java.lang.Throwable -> L1d
|
|
throw r2 // Catch: java.lang.Throwable -> L1d
|
|
L1d:
|
|
r2 = move-exception
|
|
goto L30
|
|
L1f:
|
|
if (r3 < 0) goto L28
|
|
com.facebook.FacebookSdk.callbackRequestCodeOffset = r3 // Catch: java.lang.Throwable -> L1d
|
|
sdkInitialize(r2, r4) // Catch: java.lang.Throwable -> L1d
|
|
monitor-exit(r0)
|
|
return
|
|
L28:
|
|
com.facebook.FacebookException r2 = new com.facebook.FacebookException // Catch: java.lang.Throwable -> L1d
|
|
java.lang.String r3 = "The callback request code offset can't be negative."
|
|
r2.<init>(r3) // Catch: java.lang.Throwable -> L1d
|
|
throw r2 // Catch: java.lang.Throwable -> L1d
|
|
L30:
|
|
monitor-exit(r0)
|
|
throw r2
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: com.facebook.FacebookSdk.sdkInitialize(android.content.Context, int, com.facebook.FacebookSdk$InitializeCallback):void");
|
|
}
|
|
|
|
public static final synchronized void sdkInitialize(Context applicationContext2) {
|
|
synchronized (FacebookSdk.class) {
|
|
Intrinsics.checkNotNullParameter(applicationContext2, "applicationContext");
|
|
sdkInitialize(applicationContext2, (InitializeCallback) null);
|
|
}
|
|
}
|
|
|
|
public static final synchronized void sdkInitialize(Context applicationContext2, final InitializeCallback initializeCallback) {
|
|
synchronized (FacebookSdk.class) {
|
|
Intrinsics.checkNotNullParameter(applicationContext2, "applicationContext");
|
|
AtomicBoolean atomicBoolean = sdkInitialized;
|
|
if (atomicBoolean.get()) {
|
|
if (initializeCallback != null) {
|
|
initializeCallback.onInitialized();
|
|
}
|
|
return;
|
|
}
|
|
Validate.hasFacebookActivity(applicationContext2, false);
|
|
Validate.hasInternetPermissions(applicationContext2, false);
|
|
Context applicationContext3 = applicationContext2.getApplicationContext();
|
|
Intrinsics.checkNotNullExpressionValue(applicationContext3, "applicationContext.applicationContext");
|
|
applicationContext = applicationContext3;
|
|
AppEventsLogger.Companion.getAnonymousAppDeviceGUID(applicationContext2);
|
|
Context context = applicationContext;
|
|
if (context != null) {
|
|
loadDefaultsFromMetadata$facebook_core_release(context);
|
|
String str = applicationId;
|
|
if (str == null || str.length() == 0) {
|
|
throw new FacebookException("A valid Facebook app id must be set in the AndroidManifest.xml or set by calling FacebookSdk.setApplicationId before initializing the sdk.");
|
|
}
|
|
String str2 = appClientToken;
|
|
if (str2 == null || str2.length() == 0) {
|
|
throw new FacebookException("A valid Facebook app client token must be set in the AndroidManifest.xml or set by calling FacebookSdk.setClientToken before initializing the sdk.");
|
|
}
|
|
atomicBoolean.set(true);
|
|
if (getAutoInitEnabled()) {
|
|
fullyInitialize();
|
|
}
|
|
Context context2 = applicationContext;
|
|
if (context2 != null) {
|
|
if ((context2 instanceof Application) && UserSettingsManager.getAutoLogAppEventsEnabled()) {
|
|
ActivityLifecycleTracker activityLifecycleTracker = ActivityLifecycleTracker.INSTANCE;
|
|
Context context3 = applicationContext;
|
|
if (context3 == null) {
|
|
Intrinsics.throwUninitializedPropertyAccessException("applicationContext");
|
|
throw null;
|
|
}
|
|
ActivityLifecycleTracker.startTracking((Application) context3, applicationId);
|
|
}
|
|
FetchedAppSettingsManager.loadAppSettingsAsync();
|
|
NativeProtocol.updateAllAvailableProtocolVersionsAsync();
|
|
BoltsMeasurementEventListener.Companion companion = BoltsMeasurementEventListener.Companion;
|
|
Context context4 = applicationContext;
|
|
if (context4 == null) {
|
|
Intrinsics.throwUninitializedPropertyAccessException("applicationContext");
|
|
throw null;
|
|
}
|
|
companion.getInstance(context4);
|
|
cacheDir = new LockOnGetVariable<>(new Callable() { // from class: com.facebook.FacebookSdk$$ExternalSyntheticLambda1
|
|
@Override // java.util.concurrent.Callable
|
|
public final Object call() {
|
|
File m427sdkInitialize$lambda3;
|
|
m427sdkInitialize$lambda3 = FacebookSdk.m427sdkInitialize$lambda3();
|
|
return m427sdkInitialize$lambda3;
|
|
}
|
|
});
|
|
FeatureManager featureManager = FeatureManager.INSTANCE;
|
|
FeatureManager.checkFeature(FeatureManager.Feature.Instrument, new FeatureManager.Callback() { // from class: com.facebook.FacebookSdk$$ExternalSyntheticLambda2
|
|
@Override // com.facebook.internal.FeatureManager.Callback
|
|
public final void onCompleted(boolean z) {
|
|
FacebookSdk.m428sdkInitialize$lambda4(z);
|
|
}
|
|
});
|
|
FeatureManager.checkFeature(FeatureManager.Feature.AppEvents, new FeatureManager.Callback() { // from class: com.facebook.FacebookSdk$$ExternalSyntheticLambda3
|
|
@Override // com.facebook.internal.FeatureManager.Callback
|
|
public final void onCompleted(boolean z) {
|
|
FacebookSdk.m429sdkInitialize$lambda5(z);
|
|
}
|
|
});
|
|
FeatureManager.checkFeature(FeatureManager.Feature.ChromeCustomTabsPrefetching, new FeatureManager.Callback() { // from class: com.facebook.FacebookSdk$$ExternalSyntheticLambda4
|
|
@Override // com.facebook.internal.FeatureManager.Callback
|
|
public final void onCompleted(boolean z) {
|
|
FacebookSdk.m430sdkInitialize$lambda6(z);
|
|
}
|
|
});
|
|
FeatureManager.checkFeature(FeatureManager.Feature.IgnoreAppSwitchToLoggedOut, new FeatureManager.Callback() { // from class: com.facebook.FacebookSdk$$ExternalSyntheticLambda5
|
|
@Override // com.facebook.internal.FeatureManager.Callback
|
|
public final void onCompleted(boolean z) {
|
|
FacebookSdk.m431sdkInitialize$lambda7(z);
|
|
}
|
|
});
|
|
FeatureManager.checkFeature(FeatureManager.Feature.BypassAppSwitch, new FeatureManager.Callback() { // from class: com.facebook.FacebookSdk$$ExternalSyntheticLambda6
|
|
@Override // com.facebook.internal.FeatureManager.Callback
|
|
public final void onCompleted(boolean z) {
|
|
FacebookSdk.m432sdkInitialize$lambda8(z);
|
|
}
|
|
});
|
|
getExecutor().execute(new FutureTask(new Callable() { // from class: com.facebook.FacebookSdk$$ExternalSyntheticLambda7
|
|
@Override // java.util.concurrent.Callable
|
|
public final Object call() {
|
|
Void m433sdkInitialize$lambda9;
|
|
m433sdkInitialize$lambda9 = FacebookSdk.m433sdkInitialize$lambda9(FacebookSdk.InitializeCallback.this);
|
|
return m433sdkInitialize$lambda9;
|
|
}
|
|
}));
|
|
return;
|
|
}
|
|
Intrinsics.throwUninitializedPropertyAccessException("applicationContext");
|
|
throw null;
|
|
}
|
|
Intrinsics.throwUninitializedPropertyAccessException("applicationContext");
|
|
throw null;
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: sdkInitialize$lambda-3, reason: not valid java name */
|
|
public static final File m427sdkInitialize$lambda3() {
|
|
Context context = applicationContext;
|
|
if (context != null) {
|
|
return context.getCacheDir();
|
|
}
|
|
Intrinsics.throwUninitializedPropertyAccessException("applicationContext");
|
|
throw null;
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: sdkInitialize$lambda-4, reason: not valid java name */
|
|
public static final void m428sdkInitialize$lambda4(boolean z) {
|
|
if (z) {
|
|
InstrumentManager.start();
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: sdkInitialize$lambda-5, reason: not valid java name */
|
|
public static final void m429sdkInitialize$lambda5(boolean z) {
|
|
if (z) {
|
|
AppEventsManager.start();
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: sdkInitialize$lambda-9, reason: not valid java name */
|
|
public static final Void m433sdkInitialize$lambda9(InitializeCallback initializeCallback) {
|
|
AccessTokenManager.Companion.getInstance().loadCurrentAccessToken();
|
|
ProfileManager.Companion.getInstance().loadCurrentProfile();
|
|
if (AccessToken.Companion.isCurrentAccessTokenActive()) {
|
|
Profile.Companion companion = Profile.Companion;
|
|
if (companion.getCurrentProfile() == null) {
|
|
companion.fetchProfileForCurrentAccessToken();
|
|
}
|
|
}
|
|
if (initializeCallback != null) {
|
|
initializeCallback.onInitialized();
|
|
}
|
|
AppEventsLogger.Companion companion2 = AppEventsLogger.Companion;
|
|
companion2.initializeLib(getApplicationContext(), applicationId);
|
|
UserSettingsManager.logIfAutoAppLinkEnabled();
|
|
Context applicationContext2 = getApplicationContext().getApplicationContext();
|
|
Intrinsics.checkNotNullExpressionValue(applicationContext2, "getApplicationContext().applicationContext");
|
|
companion2.newLogger(applicationContext2).flush();
|
|
return null;
|
|
}
|
|
|
|
public static final boolean isInitialized() {
|
|
return sdkInitialized.get();
|
|
}
|
|
|
|
public static final Set<LoggingBehavior> getLoggingBehaviors() {
|
|
Set<LoggingBehavior> unmodifiableSet;
|
|
HashSet<LoggingBehavior> hashSet = loggingBehaviors;
|
|
synchronized (hashSet) {
|
|
unmodifiableSet = Collections.unmodifiableSet(new HashSet(hashSet));
|
|
Intrinsics.checkNotNullExpressionValue(unmodifiableSet, "unmodifiableSet(HashSet(loggingBehaviors))");
|
|
}
|
|
return unmodifiableSet;
|
|
}
|
|
|
|
public static final void addLoggingBehavior(LoggingBehavior behavior) {
|
|
Intrinsics.checkNotNullParameter(behavior, "behavior");
|
|
HashSet<LoggingBehavior> hashSet = loggingBehaviors;
|
|
synchronized (hashSet) {
|
|
hashSet.add(behavior);
|
|
INSTANCE.updateGraphDebugBehavior();
|
|
Unit unit = Unit.INSTANCE;
|
|
}
|
|
}
|
|
|
|
public static final void removeLoggingBehavior(LoggingBehavior behavior) {
|
|
Intrinsics.checkNotNullParameter(behavior, "behavior");
|
|
HashSet<LoggingBehavior> hashSet = loggingBehaviors;
|
|
synchronized (hashSet) {
|
|
hashSet.remove(behavior);
|
|
}
|
|
}
|
|
|
|
public static final void clearLoggingBehaviors() {
|
|
HashSet<LoggingBehavior> hashSet = loggingBehaviors;
|
|
synchronized (hashSet) {
|
|
hashSet.clear();
|
|
Unit unit = Unit.INSTANCE;
|
|
}
|
|
}
|
|
|
|
public static final boolean isLoggingBehaviorEnabled(LoggingBehavior behavior) {
|
|
boolean z;
|
|
Intrinsics.checkNotNullParameter(behavior, "behavior");
|
|
HashSet<LoggingBehavior> hashSet = loggingBehaviors;
|
|
synchronized (hashSet) {
|
|
if (isDebugEnabled()) {
|
|
z = hashSet.contains(behavior);
|
|
}
|
|
}
|
|
return z;
|
|
}
|
|
|
|
private final void updateGraphDebugBehavior() {
|
|
HashSet<LoggingBehavior> hashSet = loggingBehaviors;
|
|
if (hashSet.contains(LoggingBehavior.GRAPH_API_DEBUG_INFO)) {
|
|
LoggingBehavior loggingBehavior = LoggingBehavior.GRAPH_API_DEBUG_WARNING;
|
|
if (hashSet.contains(loggingBehavior)) {
|
|
return;
|
|
}
|
|
hashSet.add(loggingBehavior);
|
|
}
|
|
}
|
|
|
|
public static final String getGraphDomain() {
|
|
AccessToken currentAccessToken = AccessToken.Companion.getCurrentAccessToken();
|
|
return Utility.getGraphDomainFromTokenDomain(currentAccessToken != null ? currentAccessToken.getGraphDomain() : null);
|
|
}
|
|
|
|
public static final Context getApplicationContext() {
|
|
Validate.sdkInitialized();
|
|
Context context = applicationContext;
|
|
if (context != null) {
|
|
return context;
|
|
}
|
|
Intrinsics.throwUninitializedPropertyAccessException("applicationContext");
|
|
throw null;
|
|
}
|
|
|
|
@VisibleForTesting(otherwise = 3)
|
|
public static final void publishInstallAsync(Context context, final String applicationId2) {
|
|
if (CrashShieldHandler.isObjectCrashing(FacebookSdk.class)) {
|
|
return;
|
|
}
|
|
try {
|
|
Intrinsics.checkNotNullParameter(context, "context");
|
|
Intrinsics.checkNotNullParameter(applicationId2, "applicationId");
|
|
final Context applicationContext2 = context.getApplicationContext();
|
|
if (applicationContext2 == null) {
|
|
return;
|
|
}
|
|
FetchedAppGateKeepersManager fetchedAppGateKeepersManager = FetchedAppGateKeepersManager.INSTANCE;
|
|
if (!FetchedAppGateKeepersManager.getGateKeeperForKey(AppEventsLoggerImpl.APP_EVENTS_KILLSWITCH, getApplicationId(), false)) {
|
|
getExecutor().execute(new Runnable() { // from class: com.facebook.FacebookSdk$$ExternalSyntheticLambda0
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
FacebookSdk.m426publishInstallAsync$lambda15(applicationContext2, applicationId2);
|
|
}
|
|
});
|
|
}
|
|
FeatureManager featureManager = FeatureManager.INSTANCE;
|
|
if (FeatureManager.isEnabled(FeatureManager.Feature.OnDeviceEventProcessing) && OnDeviceProcessingManager.isOnDeviceProcessingEnabled()) {
|
|
OnDeviceProcessingManager.sendInstallEventAsync(applicationId2, ATTRIBUTION_PREFERENCES);
|
|
}
|
|
} catch (Throwable th) {
|
|
CrashShieldHandler.handleThrowable(th, FacebookSdk.class);
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: publishInstallAsync$lambda-15, reason: not valid java name */
|
|
public static final void m426publishInstallAsync$lambda15(Context applicationContext2, String applicationId2) {
|
|
Intrinsics.checkNotNullParameter(applicationContext2, "$applicationContext");
|
|
Intrinsics.checkNotNullParameter(applicationId2, "$applicationId");
|
|
INSTANCE.publishInstallAndWaitForResponse(applicationContext2, applicationId2);
|
|
}
|
|
|
|
private final void publishInstallAndWaitForResponse(Context context, String str) {
|
|
try {
|
|
if (CrashShieldHandler.isObjectCrashing(this)) {
|
|
return;
|
|
}
|
|
try {
|
|
AttributionIdentifiers attributionIdentifiers = AttributionIdentifiers.Companion.getAttributionIdentifiers(context);
|
|
SharedPreferences sharedPreferences = context.getSharedPreferences(ATTRIBUTION_PREFERENCES, 0);
|
|
String stringPlus = Intrinsics.stringPlus(str, "ping");
|
|
long j = sharedPreferences.getLong(stringPlus, 0L);
|
|
try {
|
|
AppEventsLoggerUtility appEventsLoggerUtility = AppEventsLoggerUtility.INSTANCE;
|
|
JSONObject jSONObjectForGraphAPICall = AppEventsLoggerUtility.getJSONObjectForGraphAPICall(AppEventsLoggerUtility.GraphAPIActivityType.MOBILE_INSTALL_EVENT, attributionIdentifiers, AppEventsLogger.Companion.getAnonymousAppDeviceGUID(context), getLimitEventAndDataUsage(context), context);
|
|
StringCompanionObject stringCompanionObject = StringCompanionObject.INSTANCE;
|
|
String format = String.format(PUBLISH_ACTIVITY_PATH, Arrays.copyOf(new Object[]{str}, 1));
|
|
Intrinsics.checkNotNullExpressionValue(format, "java.lang.String.format(format, *args)");
|
|
GraphRequest createPostRequest = graphRequestCreator.createPostRequest(null, format, jSONObjectForGraphAPICall, null);
|
|
if (j == 0 && createPostRequest.executeAndWait().getError() == null) {
|
|
SharedPreferences.Editor edit = sharedPreferences.edit();
|
|
edit.putLong(stringPlus, System.currentTimeMillis());
|
|
edit.apply();
|
|
Logger.Companion companion = Logger.Companion;
|
|
LoggingBehavior loggingBehavior = LoggingBehavior.APP_EVENTS;
|
|
String TAG2 = TAG;
|
|
Intrinsics.checkNotNullExpressionValue(TAG2, "TAG");
|
|
companion.log(loggingBehavior, TAG2, "MOBILE_APP_INSTALL has been logged");
|
|
}
|
|
} catch (JSONException e) {
|
|
throw new FacebookException("An error occurred while publishing install.", e);
|
|
}
|
|
} catch (Exception e2) {
|
|
Utility.logd("Facebook-publish", e2);
|
|
}
|
|
} catch (Throwable th) {
|
|
CrashShieldHandler.handleThrowable(th, this);
|
|
}
|
|
}
|
|
|
|
public static final boolean getLimitEventAndDataUsage(Context context) {
|
|
Intrinsics.checkNotNullParameter(context, "context");
|
|
Validate.sdkInitialized();
|
|
return context.getSharedPreferences(APP_EVENT_PREFERENCES, 0).getBoolean("limitEventUsage", false);
|
|
}
|
|
|
|
public static final void setLimitEventAndDataUsage(Context context, boolean z) {
|
|
Intrinsics.checkNotNullParameter(context, "context");
|
|
context.getSharedPreferences(APP_EVENT_PREFERENCES, 0).edit().putBoolean("limitEventUsage", z).apply();
|
|
}
|
|
|
|
public static final void loadDefaultsFromMetadata$facebook_core_release(Context context) {
|
|
if (context == null) {
|
|
return;
|
|
}
|
|
try {
|
|
ApplicationInfo applicationInfo = context.getPackageManager().getApplicationInfo(context.getPackageName(), 128);
|
|
Intrinsics.checkNotNullExpressionValue(applicationInfo, "try {\n context.packageManager.getApplicationInfo(\n context.packageName, PackageManager.GET_META_DATA)\n } catch (e: PackageManager.NameNotFoundException) {\n return\n }");
|
|
if (applicationInfo.metaData == null) {
|
|
return;
|
|
}
|
|
if (applicationId == null) {
|
|
Object obj = applicationInfo.metaData.get(APPLICATION_ID_PROPERTY);
|
|
if (obj instanceof String) {
|
|
String str = (String) obj;
|
|
Locale ROOT = Locale.ROOT;
|
|
Intrinsics.checkNotNullExpressionValue(ROOT, "ROOT");
|
|
String lowerCase = str.toLowerCase(ROOT);
|
|
Intrinsics.checkNotNullExpressionValue(lowerCase, "(this as java.lang.String).toLowerCase(locale)");
|
|
if (StringsKt__StringsJVMKt.startsWith$default(lowerCase, "fb", false, 2, null)) {
|
|
String substring = str.substring(2);
|
|
Intrinsics.checkNotNullExpressionValue(substring, "(this as java.lang.String).substring(startIndex)");
|
|
applicationId = substring;
|
|
} else {
|
|
applicationId = str;
|
|
}
|
|
} else if (obj instanceof Number) {
|
|
throw new FacebookException("App Ids cannot be directly placed in the manifest.They must be prefixed by 'fb' or be placed in the string resource file.");
|
|
}
|
|
}
|
|
if (applicationName == null) {
|
|
applicationName = applicationInfo.metaData.getString(APPLICATION_NAME_PROPERTY);
|
|
}
|
|
if (appClientToken == null) {
|
|
appClientToken = applicationInfo.metaData.getString(CLIENT_TOKEN_PROPERTY);
|
|
}
|
|
if (callbackRequestCodeOffset == DEFAULT_CALLBACK_REQUEST_CODE_OFFSET) {
|
|
callbackRequestCodeOffset = applicationInfo.metaData.getInt(CALLBACK_OFFSET_PROPERTY, DEFAULT_CALLBACK_REQUEST_CODE_OFFSET);
|
|
}
|
|
if (codelessDebugLogEnabled == null) {
|
|
codelessDebugLogEnabled = Boolean.valueOf(applicationInfo.metaData.getBoolean(CODELESS_DEBUG_LOG_ENABLED_PROPERTY, false));
|
|
}
|
|
} catch (PackageManager.NameNotFoundException unused) {
|
|
}
|
|
}
|
|
|
|
public static final String getApplicationSignature(Context context) {
|
|
PackageManager packageManager;
|
|
if (CrashShieldHandler.isObjectCrashing(FacebookSdk.class)) {
|
|
return null;
|
|
}
|
|
try {
|
|
Validate.sdkInitialized();
|
|
if (context == null || (packageManager = context.getPackageManager()) == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
PackageInfo packageInfo = packageManager.getPackageInfo(context.getPackageName(), 64);
|
|
Signature[] signatureArr = packageInfo.signatures;
|
|
if (signatureArr != null && signatureArr.length != 0) {
|
|
MessageDigest messageDigest = MessageDigest.getInstance(AndroidStaticDeviceInfoDataSource.ALGORITHM_SHA1);
|
|
messageDigest.update(packageInfo.signatures[0].toByteArray());
|
|
return Base64.encodeToString(messageDigest.digest(), 9);
|
|
}
|
|
} catch (PackageManager.NameNotFoundException | NoSuchAlgorithmException unused) {
|
|
}
|
|
return null;
|
|
} catch (Throwable th) {
|
|
CrashShieldHandler.handleThrowable(th, FacebookSdk.class);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static final String getApplicationId() {
|
|
Validate.sdkInitialized();
|
|
String str = applicationId;
|
|
if (str != null) {
|
|
return str;
|
|
}
|
|
throw new FacebookException("A valid Facebook app id must be set in the AndroidManifest.xml or set by calling FacebookSdk.setApplicationId before initializing the sdk.");
|
|
}
|
|
|
|
public static final void setApplicationId(String applicationId2) {
|
|
Intrinsics.checkNotNullParameter(applicationId2, "applicationId");
|
|
Validate.notEmpty(applicationId2, "applicationId");
|
|
applicationId = applicationId2;
|
|
}
|
|
|
|
public static final String getApplicationName() {
|
|
Validate.sdkInitialized();
|
|
return applicationName;
|
|
}
|
|
|
|
public static final String getClientToken() {
|
|
Validate.sdkInitialized();
|
|
String str = appClientToken;
|
|
if (str != null) {
|
|
return str;
|
|
}
|
|
throw new FacebookException("A valid Facebook client token must be set in the AndroidManifest.xml or set by calling FacebookSdk.setClientToken before initializing the sdk. Visit https://developers.facebook.com/docs/android/getting-started#add-app_id for more information.");
|
|
}
|
|
|
|
public static final boolean getAutoInitEnabled() {
|
|
return UserSettingsManager.getAutoInitEnabled();
|
|
}
|
|
|
|
public static final void setAutoInitEnabled(boolean z) {
|
|
UserSettingsManager.setAutoInitEnabled(z);
|
|
if (z) {
|
|
fullyInitialize();
|
|
}
|
|
}
|
|
|
|
public static final boolean getAutoLogAppEventsEnabled() {
|
|
return UserSettingsManager.getAutoLogAppEventsEnabled();
|
|
}
|
|
|
|
public static final void setAutoLogAppEventsEnabled(boolean z) {
|
|
UserSettingsManager.setAutoLogAppEventsEnabled(z);
|
|
if (z) {
|
|
Application application = (Application) getApplicationContext();
|
|
ActivityLifecycleTracker activityLifecycleTracker = ActivityLifecycleTracker.INSTANCE;
|
|
ActivityLifecycleTracker.startTracking(application, getApplicationId());
|
|
}
|
|
}
|
|
|
|
public static final boolean getCodelessDebugLogEnabled() {
|
|
Validate.sdkInitialized();
|
|
Boolean bool = codelessDebugLogEnabled;
|
|
if (bool == null) {
|
|
return false;
|
|
}
|
|
return bool.booleanValue();
|
|
}
|
|
|
|
public static final boolean getCodelessSetupEnabled() {
|
|
return UserSettingsManager.getCodelessSetupEnabled();
|
|
}
|
|
|
|
public static final boolean getAdvertiserIDCollectionEnabled() {
|
|
return UserSettingsManager.getAdvertiserIDCollectionEnabled();
|
|
}
|
|
|
|
public static final void setAdvertiserIDCollectionEnabled(boolean z) {
|
|
UserSettingsManager.setAdvertiserIDCollectionEnabled(z);
|
|
}
|
|
|
|
public static final void setCodelessDebugLogEnabled(boolean z) {
|
|
codelessDebugLogEnabled = Boolean.valueOf(z);
|
|
}
|
|
|
|
public static final boolean getMonitorEnabled() {
|
|
return UserSettingsManager.getMonitorEnabled();
|
|
}
|
|
|
|
public static final void setMonitorEnabled(boolean z) {
|
|
UserSettingsManager.setMonitorEnabled(z);
|
|
}
|
|
|
|
public static final void setDataProcessingOptions(String[] strArr) {
|
|
if (CrashShieldHandler.isObjectCrashing(FacebookSdk.class)) {
|
|
return;
|
|
}
|
|
try {
|
|
setDataProcessingOptions(strArr, 0, 0);
|
|
} catch (Throwable th) {
|
|
CrashShieldHandler.handleThrowable(th, FacebookSdk.class);
|
|
}
|
|
}
|
|
|
|
public static final void setDataProcessingOptions(String[] strArr, int i, int i2) {
|
|
List list;
|
|
if (CrashShieldHandler.isObjectCrashing(FacebookSdk.class)) {
|
|
return;
|
|
}
|
|
if (strArr == null) {
|
|
try {
|
|
strArr = new String[0];
|
|
} catch (Throwable th) {
|
|
CrashShieldHandler.handleThrowable(th, FacebookSdk.class);
|
|
return;
|
|
}
|
|
}
|
|
try {
|
|
JSONObject jSONObject = new JSONObject();
|
|
list = ArraysKt___ArraysKt.toList(strArr);
|
|
jSONObject.put(DATA_PROCESSION_OPTIONS, new JSONArray((Collection) list));
|
|
jSONObject.put(DATA_PROCESSION_OPTIONS_COUNTRY, i);
|
|
jSONObject.put(DATA_PROCESSION_OPTIONS_STATE, i2);
|
|
Context context = applicationContext;
|
|
if (context == null) {
|
|
Intrinsics.throwUninitializedPropertyAccessException("applicationContext");
|
|
throw null;
|
|
}
|
|
context.getSharedPreferences(DATA_PROCESSING_OPTIONS_PREFERENCES, 0).edit().putString(DATA_PROCESSION_OPTIONS, jSONObject.toString()).apply();
|
|
} catch (JSONException unused) {
|
|
}
|
|
}
|
|
|
|
public static final File getCacheDir() {
|
|
Validate.sdkInitialized();
|
|
LockOnGetVariable<File> lockOnGetVariable = cacheDir;
|
|
if (lockOnGetVariable != null) {
|
|
return lockOnGetVariable.getValue();
|
|
}
|
|
Intrinsics.throwUninitializedPropertyAccessException("cacheDir");
|
|
throw null;
|
|
}
|
|
|
|
public static final void setCacheDir(File cacheDir2) {
|
|
Intrinsics.checkNotNullParameter(cacheDir2, "cacheDir");
|
|
cacheDir = new LockOnGetVariable<>(cacheDir2);
|
|
}
|
|
|
|
public static final int getCallbackRequestCodeOffset() {
|
|
Validate.sdkInitialized();
|
|
return callbackRequestCodeOffset;
|
|
}
|
|
}
|