Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/scheduler/PlatformScheduler.java

@@ -0,0 +1,111 @@
+package com.mbridge.msdk.playercommon.exoplayer2.scheduler;
+
+import android.annotation.TargetApi;
+import android.app.job.JobInfo;
+import android.app.job.JobParameters;
+import android.app.job.JobScheduler;
+import android.app.job.JobService;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.PersistableBundle;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+@TargetApi(21)
+/* loaded from: classes4.dex */
+public final class PlatformScheduler implements Scheduler {
+    private static final String KEY_REQUIREMENTS = "requirements";
+    private static final String KEY_SERVICE_ACTION = "service_action";
+    private static final String KEY_SERVICE_PACKAGE = "service_package";
+    private static final String TAG = "PlatformScheduler";
+    private final int jobId;
+    private final JobScheduler jobScheduler;
+    private final ComponentName jobServiceComponentName;
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void logd(String str) {
+    }
+
+    public PlatformScheduler(Context context, int i) {
+        this.jobId = i;
+        this.jobServiceComponentName = new ComponentName(context, (Class<?>) PlatformSchedulerService.class);
+        this.jobScheduler = (JobScheduler) context.getSystemService("jobscheduler");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.scheduler.Scheduler
+    public final boolean schedule(Requirements requirements, String str, String str2) {
+        int schedule = this.jobScheduler.schedule(buildJobInfo(this.jobId, this.jobServiceComponentName, requirements, str2, str));
+        logd("Scheduling job: " + this.jobId + " result: " + schedule);
+        return schedule == 1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.scheduler.Scheduler
+    public final boolean cancel() {
+        logd("Canceling job: " + this.jobId);
+        this.jobScheduler.cancel(this.jobId);
+        return true;
+    }
+
+    private static JobInfo buildJobInfo(int i, ComponentName componentName, Requirements requirements, String str, String str2) {
+        int i2;
+        JobInfo.Builder builder = new JobInfo.Builder(i, componentName);
+        int requiredNetworkType = requirements.getRequiredNetworkType();
+        if (requiredNetworkType == 0) {
+            i2 = 0;
+        } else if (requiredNetworkType != 1) {
+            i2 = 2;
+            if (requiredNetworkType != 2) {
+                i2 = 3;
+                if (requiredNetworkType != 3) {
+                    i2 = 4;
+                    if (requiredNetworkType == 4) {
+                        if (Util.SDK_INT < 26) {
+                            throw new UnsupportedOperationException();
+                        }
+                    } else {
+                        throw new UnsupportedOperationException();
+                    }
+                } else if (Util.SDK_INT < 24) {
+                    throw new UnsupportedOperationException();
+                }
+            }
+        } else {
+            i2 = 1;
+        }
+        builder.setRequiredNetworkType(i2);
+        builder.setRequiresDeviceIdle(requirements.isIdleRequired());
+        builder.setRequiresCharging(requirements.isChargingRequired());
+        builder.setPersisted(true);
+        PersistableBundle persistableBundle = new PersistableBundle();
+        persistableBundle.putString(KEY_SERVICE_ACTION, str);
+        persistableBundle.putString(KEY_SERVICE_PACKAGE, str2);
+        persistableBundle.putInt(KEY_REQUIREMENTS, requirements.getRequirementsData());
+        builder.setExtras(persistableBundle);
+        return builder.build();
+    }
+
+    public static final class PlatformSchedulerService extends JobService {
+        @Override // android.app.job.JobService
+        public final boolean onStopJob(JobParameters jobParameters) {
+            return false;
+        }
+
+        @Override // android.app.job.JobService
+        public final boolean onStartJob(JobParameters jobParameters) {
+            PlatformScheduler.logd("PlatformSchedulerService started");
+            PersistableBundle extras = jobParameters.getExtras();
+            if (new Requirements(extras.getInt(PlatformScheduler.KEY_REQUIREMENTS)).checkRequirements(this)) {
+                PlatformScheduler.logd("Requirements are met");
+                String string = extras.getString(PlatformScheduler.KEY_SERVICE_ACTION);
+                String string2 = extras.getString(PlatformScheduler.KEY_SERVICE_PACKAGE);
+                Intent intent = new Intent(string).setPackage(string2);
+                PlatformScheduler.logd("Starting service action: " + string + " package: " + string2);
+                Util.startForegroundService(this, intent);
+                return false;
+            }
+            PlatformScheduler.logd("Requirements are not met");
+            jobFinished(jobParameters, true);
+            return false;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/scheduler/Requirements.java

@@ -0,0 +1,155 @@
+package com.mbridge.msdk.playercommon.exoplayer2.scheduler;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkInfo;
+import android.os.PowerManager;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public final class Requirements {
+    private static final int DEVICE_CHARGING = 16;
+    private static final int DEVICE_IDLE = 8;
+    public static final int NETWORK_TYPE_ANY = 1;
+    private static final int NETWORK_TYPE_MASK = 7;
+    public static final int NETWORK_TYPE_METERED = 4;
+    public static final int NETWORK_TYPE_NONE = 0;
+    public static final int NETWORK_TYPE_NOT_ROAMING = 3;
+    private static final String[] NETWORK_TYPE_STRINGS = null;
+    public static final int NETWORK_TYPE_UNMETERED = 2;
+    private static final String TAG = "Requirements";
+    private final int requirements;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface NetworkType {
+    }
+
+    private static void logd(String str) {
+    }
+
+    public final int getRequiredNetworkType() {
+        return this.requirements & 7;
+    }
+
+    public final int getRequirementsData() {
+        return this.requirements;
+    }
+
+    public final boolean isChargingRequired() {
+        return (this.requirements & 16) != 0;
+    }
+
+    public final boolean isIdleRequired() {
+        return (this.requirements & 8) != 0;
+    }
+
+    public Requirements(int i, boolean z, boolean z2) {
+        this(i | (z ? 16 : 0) | (z2 ? 8 : 0));
+    }
+
+    public Requirements(int i) {
+        this.requirements = i;
+    }
+
+    public final boolean checkRequirements(Context context) {
+        return checkNetworkRequirements(context) && checkChargingRequirement(context) && checkIdleRequirement(context);
+    }
+
+    private boolean checkNetworkRequirements(Context context) {
+        int requiredNetworkType = getRequiredNetworkType();
+        if (requiredNetworkType == 0) {
+            return true;
+        }
+        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
+        NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
+        if (activeNetworkInfo == null || !activeNetworkInfo.isConnected()) {
+            logd("No network info or no connection.");
+            return false;
+        }
+        if (!checkInternetConnectivity(connectivityManager)) {
+            return false;
+        }
+        if (requiredNetworkType == 1) {
+            return true;
+        }
+        if (requiredNetworkType == 3) {
+            boolean isRoaming = activeNetworkInfo.isRoaming();
+            logd("Roaming: " + isRoaming);
+            return !isRoaming;
+        }
+        boolean isActiveNetworkMetered = isActiveNetworkMetered(connectivityManager, activeNetworkInfo);
+        logd("Metered network: " + isActiveNetworkMetered);
+        if (requiredNetworkType == 2) {
+            return !isActiveNetworkMetered;
+        }
+        if (requiredNetworkType == 4) {
+            return isActiveNetworkMetered;
+        }
+        throw new IllegalStateException();
+    }
+
+    private boolean checkChargingRequirement(Context context) {
+        if (!isChargingRequired()) {
+            return true;
+        }
+        Intent registerReceiver = context.registerReceiver(null, new IntentFilter("android.intent.action.BATTERY_CHANGED"));
+        if (registerReceiver == null) {
+            return false;
+        }
+        int intExtra = registerReceiver.getIntExtra("status", -1);
+        return intExtra == 2 || intExtra == 5;
+    }
+
+    private boolean checkIdleRequirement(Context context) {
+        if (!isIdleRequired()) {
+            return true;
+        }
+        PowerManager powerManager = (PowerManager) context.getSystemService("power");
+        int i = Util.SDK_INT;
+        if (i >= 23) {
+            if (!powerManager.isDeviceIdleMode()) {
+                return true;
+            }
+        } else if (i >= 20) {
+            if (!powerManager.isInteractive()) {
+                return true;
+            }
+        } else if (!powerManager.isScreenOn()) {
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean checkInternetConnectivity(ConnectivityManager connectivityManager) {
+        if (Util.SDK_INT < 23) {
+            return true;
+        }
+        Network activeNetwork = connectivityManager.getActiveNetwork();
+        if (activeNetwork == null) {
+            logd("No active network.");
+            return false;
+        }
+        NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(activeNetwork);
+        boolean z = networkCapabilities == null || !networkCapabilities.hasCapability(16);
+        logd("Network capability validated: " + z);
+        return !z;
+    }
+
+    private static boolean isActiveNetworkMetered(ConnectivityManager connectivityManager, NetworkInfo networkInfo) {
+        if (Util.SDK_INT >= 16) {
+            return connectivityManager.isActiveNetworkMetered();
+        }
+        int type = networkInfo.getType();
+        return (type == 1 || type == 7 || type == 9) ? false : true;
+    }
+
+    public final String toString() {
+        return super.toString();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/scheduler/RequirementsWatcher.java

@@ -0,0 +1,156 @@
+package com.mbridge.msdk.playercommon.exoplayer2.scheduler;
+
+import android.annotation.TargetApi;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkRequest;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.RequiresApi;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+public final class RequirementsWatcher {
+    private static final String TAG = "RequirementsWatcher";
+    private final Context context;
+    private final Listener listener;
+    private CapabilityValidatedCallback networkCallback;
+    private DeviceStatusChangeReceiver receiver;
+    private final Requirements requirements;
+    private boolean requirementsWereMet;
+
+    public interface Listener {
+        void requirementsMet(RequirementsWatcher requirementsWatcher);
+
+        void requirementsNotMet(RequirementsWatcher requirementsWatcher);
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static void logd(String str) {
+    }
+
+    public final Requirements getRequirements() {
+        return this.requirements;
+    }
+
+    public RequirementsWatcher(Context context, Listener listener, Requirements requirements) {
+        this.requirements = requirements;
+        this.listener = listener;
+        this.context = context.getApplicationContext();
+        logd(this + " created");
+    }
+
+    public final void start() {
+        Assertions.checkNotNull(Looper.myLooper());
+        checkRequirements(true);
+        IntentFilter intentFilter = new IntentFilter();
+        if (this.requirements.getRequiredNetworkType() != 0) {
+            if (Util.SDK_INT >= 23) {
+                registerNetworkCallbackV23();
+            } else {
+                intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
+            }
+        }
+        if (this.requirements.isChargingRequired()) {
+            intentFilter.addAction("android.intent.action.ACTION_POWER_CONNECTED");
+            intentFilter.addAction("android.intent.action.ACTION_POWER_DISCONNECTED");
+        }
+        if (this.requirements.isIdleRequired()) {
+            if (Util.SDK_INT >= 23) {
+                intentFilter.addAction("android.os.action.DEVICE_IDLE_MODE_CHANGED");
+            } else {
+                intentFilter.addAction("android.intent.action.SCREEN_ON");
+                intentFilter.addAction("android.intent.action.SCREEN_OFF");
+            }
+        }
+        DeviceStatusChangeReceiver deviceStatusChangeReceiver = new DeviceStatusChangeReceiver();
+        this.receiver = deviceStatusChangeReceiver;
+        this.context.registerReceiver(deviceStatusChangeReceiver, intentFilter, null, new Handler());
+        logd(this + " started");
+    }
+
+    public final void stop() {
+        this.context.unregisterReceiver(this.receiver);
+        this.receiver = null;
+        if (this.networkCallback != null) {
+            unregisterNetworkCallback();
+        }
+        logd(this + " stopped");
+    }
+
+    public final String toString() {
+        return super.toString();
+    }
+
+    @TargetApi(23)
+    private void registerNetworkCallbackV23() {
+        ConnectivityManager connectivityManager = (ConnectivityManager) this.context.getSystemService("connectivity");
+        NetworkRequest build = new NetworkRequest.Builder().addCapability(16).build();
+        CapabilityValidatedCallback capabilityValidatedCallback = new CapabilityValidatedCallback();
+        this.networkCallback = capabilityValidatedCallback;
+        connectivityManager.registerNetworkCallback(build, capabilityValidatedCallback);
+    }
+
+    private void unregisterNetworkCallback() {
+        if (Util.SDK_INT >= 21) {
+            ((ConnectivityManager) this.context.getSystemService("connectivity")).unregisterNetworkCallback(this.networkCallback);
+            this.networkCallback = null;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void checkRequirements(boolean z) {
+        boolean checkRequirements = this.requirements.checkRequirements(this.context);
+        if (!z && checkRequirements == this.requirementsWereMet) {
+            logd("requirementsAreMet is still " + checkRequirements);
+            return;
+        }
+        this.requirementsWereMet = checkRequirements;
+        if (checkRequirements) {
+            logd("start job");
+            this.listener.requirementsMet(this);
+        } else {
+            logd("stop job");
+            this.listener.requirementsNotMet(this);
+        }
+    }
+
+    public class DeviceStatusChangeReceiver extends BroadcastReceiver {
+        private DeviceStatusChangeReceiver() {
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public void onReceive(Context context, Intent intent) {
+            if (isInitialStickyBroadcast()) {
+                return;
+            }
+            RequirementsWatcher.logd(RequirementsWatcher.this + " received " + intent.getAction());
+            RequirementsWatcher.this.checkRequirements(false);
+        }
+    }
+
+    @RequiresApi(api = 21)
+    public final class CapabilityValidatedCallback extends ConnectivityManager.NetworkCallback {
+        private CapabilityValidatedCallback() {
+        }
+
+        @Override // android.net.ConnectivityManager.NetworkCallback
+        public final void onAvailable(Network network) {
+            super.onAvailable(network);
+            RequirementsWatcher.logd(RequirementsWatcher.this + " NetworkCallback.onAvailable");
+            RequirementsWatcher.this.checkRequirements(false);
+        }
+
+        @Override // android.net.ConnectivityManager.NetworkCallback
+        public final void onLost(Network network) {
+            super.onLost(network);
+            RequirementsWatcher.logd(RequirementsWatcher.this + " NetworkCallback.onLost");
+            RequirementsWatcher.this.checkRequirements(false);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/scheduler/Scheduler.java

@@ -0,0 +1,10 @@
+package com.mbridge.msdk.playercommon.exoplayer2.scheduler;
+
+/* loaded from: classes4.dex */
+public interface Scheduler {
+    public static final boolean DEBUG = false;
+
+    boolean cancel();
+
+    boolean schedule(Requirements requirements, String str, String str2);
+}