package com.discord.utilities.networking;

import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.os.Build;
import com.discord.utilities.io.NetworkUtils;
import com.discord.utilities.logging.Logger;
import d0.z.d.m;
import rx.Observable;
import rx.subjects.BehaviorSubject;
/* compiled from: NetworkMonitor.kt */
public final class NetworkMonitor {
    private Logger logger;
    private final BehaviorSubject<State> networkStateSubject;

    /* compiled from: NetworkMonitor.kt */
    public enum State {
        ONLINE,
        OFFLINE,
        OFFLINE_AIRPLANE_MODE
    }

    public NetworkMonitor(Context context, Logger logger) {
        m.checkNotNullParameter(context, "context");
        m.checkNotNullParameter(logger, "logger");
        this.logger = logger;
        this.networkStateSubject = BehaviorSubject.l0(getState$default(this, context, null, 2, null));
        registerConnectivityNetworkMonitor(context);
    }

    public static final /* synthetic */ Logger access$getLogger$p(NetworkMonitor networkMonitor) {
        return networkMonitor.logger;
    }

    public static final /* synthetic */ void access$setLogger$p(NetworkMonitor networkMonitor, Logger logger) {
        networkMonitor.logger = logger;
    }

    public static final /* synthetic */ void access$updateNetworkState(NetworkMonitor networkMonitor, Context context, Intent intent) {
        networkMonitor.updateNetworkState(context, intent);
    }

    private final State getState(Context context, Intent intent) {
        NetworkUtils networkUtils = NetworkUtils.INSTANCE;
        State state = networkUtils.isDeviceConnected(context, intent, this.logger) ? State.ONLINE : networkUtils.isAirplaneModeOn(context) ? State.OFFLINE_AIRPLANE_MODE : State.OFFLINE;
        Logger logger = this.logger;
        Logger.i$default(logger, "[NetworkMonitor]", "Updating network state to " + state + ", API: " + Build.VERSION.SDK_INT, null, 4, null);
        return state;
    }

    public static /* synthetic */ State getState$default(NetworkMonitor networkMonitor, Context context, Intent intent, int i, Object obj) {
        if ((i & 2) != 0) {
            intent = null;
        }
        return networkMonitor.getState(context, intent);
    }

    private final void registerBroadcastAirplaneMode(Context context) {
        context.registerReceiver(new NetworkMonitor$registerBroadcastAirplaneMode$1(this), new IntentFilter("android.intent.action.AIRPLANE_MODE"));
    }

    private final void registerBroadcastConnectivityNetworkMonitor(Context context) {
        context.registerReceiver(new NetworkMonitor$registerBroadcastConnectivityNetworkMonitor$1(this), new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"));
    }

    private final void registerConnectivityNetworkMonitor(Context context) {
        Object systemService = context.getSystemService("connectivity");
        if (!(systemService instanceof ConnectivityManager)) {
            systemService = null;
        }
        ConnectivityManager connectivityManager = (ConnectivityManager) systemService;
        if (connectivityManager != null) {
            NetworkMonitor$registerConnectivityNetworkMonitor$networkCallback$1 networkMonitor$registerConnectivityNetworkMonitor$networkCallback$1 = new NetworkMonitor$registerConnectivityNetworkMonitor$networkCallback$1(this, context);
            NetworkMonitor$registerConnectivityNetworkMonitor$1 networkMonitor$registerConnectivityNetworkMonitor$1 = new NetworkMonitor$registerConnectivityNetworkMonitor$1(this, connectivityManager, networkMonitor$registerConnectivityNetworkMonitor$networkCallback$1);
            if (Build.VERSION.SDK_INT >= 24) {
                try {
                    connectivityManager.registerDefaultNetworkCallback(networkMonitor$registerConnectivityNetworkMonitor$networkCallback$1);
                } catch (Exception unused) {
                    networkMonitor$registerConnectivityNetworkMonitor$1.mo1invoke();
                }
            } else {
                networkMonitor$registerConnectivityNetworkMonitor$1.mo1invoke();
            }
            registerBroadcastConnectivityNetworkMonitor(context);
            registerBroadcastAirplaneMode(context);
        }
    }

    private final void updateNetworkState(Context context, Intent intent) {
        this.networkStateSubject.onNext(getState(context, intent));
    }

    public static /* synthetic */ void updateNetworkState$default(NetworkMonitor networkMonitor, Context context, Intent intent, int i, Object obj) {
        if ((i & 2) != 0) {
            intent = null;
        }
        networkMonitor.updateNetworkState(context, intent);
    }

    public final Observable<Boolean> observeIsConnected() {
        Observable<Boolean> r = observeState().F(NetworkMonitor$observeIsConnected$1.INSTANCE).r();
        m.checkNotNullExpressionValue(r, "observeState().map { sta… }.distinctUntilChanged()");
        return r;
    }

    public final Observable<State> observeState() {
        Observable<State> r = this.networkStateSubject.J().r();
        m.checkNotNullExpressionValue(r, "networkStateSubject.onBa…().distinctUntilChanged()");
        return r;
    }
}