package androidx.media3.exoplayer.util;

import Z0.o;
import android.os.SystemClock;
import androidx.media3.common.C;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.exoplayer.upstream.Loader;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.ConcurrentModificationException;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public final class SntpClient {
    public static final String DEFAULT_NTP_HOST = "time.android.com";
    private static final int NTP_LEAP_NOSYNC = 3;
    private static final int NTP_MODE_BROADCAST = 5;
    private static final int NTP_MODE_CLIENT = 3;
    private static final int NTP_MODE_SERVER = 4;
    private static final int NTP_PACKET_SIZE = 48;
    private static final int NTP_PORT = 123;
    private static final int NTP_STRATUM_DEATH = 0;
    private static final int NTP_STRATUM_MAX = 15;
    private static final int NTP_VERSION = 3;
    private static final long OFFSET_1900_TO_1970 = 2208988800L;
    private static final int ORIGINATE_TIME_OFFSET = 24;
    private static final int RECEIVE_TIME_OFFSET = 32;
    private static final int TIMEOUT_MS = 10000;
    private static final int TRANSMIT_TIME_OFFSET = 40;
    private static long elapsedRealtimeOffsetMs = 0;
    private static boolean isInitialized = false;
    private static String ntpHost = "time.android.com";
    private static final Object loaderLock = new Object();
    private static final Object valueLock = new Object();

    public interface InitializationCallback {
        void onInitializationFailed(IOException iOException);

        void onInitialized();
    }

    public static final class NtpTimeCallback implements Loader.Callback<Loader.Loadable> {
        private final InitializationCallback callback;

        public NtpTimeCallback(InitializationCallback initializationCallback) {
            this.callback = initializationCallback;
        }

        @Override // androidx.media3.exoplayer.upstream.Loader.Callback
        public void onLoadCanceled(Loader.Loadable loadable, long j4, long j6, boolean z6) {
        }

        @Override // androidx.media3.exoplayer.upstream.Loader.Callback
        public void onLoadCompleted(Loader.Loadable loadable, long j4, long j6) {
            if (this.callback != null) {
                if (SntpClient.isInitialized()) {
                    this.callback.onInitialized();
                } else {
                    this.callback.onInitializationFailed(new IOException(new ConcurrentModificationException()));
                }
            }
        }

        @Override // androidx.media3.exoplayer.upstream.Loader.Callback
        public Loader.LoadErrorAction onLoadError(Loader.Loadable loadable, long j4, long j6, IOException iOException, int i6) {
            InitializationCallback initializationCallback = this.callback;
            if (initializationCallback != null) {
                initializationCallback.onInitializationFailed(iOException);
            }
            return Loader.DONT_RETRY;
        }
    }

    public static final class NtpTimeLoadable implements Loader.Loadable {
        private NtpTimeLoadable() {
        }

        @Override // androidx.media3.exoplayer.upstream.Loader.Loadable
        public void cancelLoad() {
        }

        @Override // androidx.media3.exoplayer.upstream.Loader.Loadable
        public void load() {
            synchronized (SntpClient.loaderLock) {
                synchronized (SntpClient.valueLock) {
                    if (SntpClient.isInitialized) {
                        return;
                    }
                    long jLoadNtpTimeOffsetMs = SntpClient.loadNtpTimeOffsetMs();
                    synchronized (SntpClient.valueLock) {
                        long unused = SntpClient.elapsedRealtimeOffsetMs = jLoadNtpTimeOffsetMs;
                        boolean unused2 = SntpClient.isInitialized = true;
                    }
                }
            }
        }
    }

    private SntpClient() {
    }

    private static void checkValidServerReply(byte b5, byte b6, int i6, long j4) throws IOException {
        if (b5 == 3) {
            throw new IOException("SNTP: Unsynchronized server");
        }
        if (b6 != 4 && b6 != 5) {
            throw new IOException(o.l("SNTP: Untrusted mode: ", b6));
        }
        if (i6 == 0 || i6 > 15) {
            throw new IOException(o.l("SNTP: Untrusted stratum: ", i6));
        }
        if (j4 == 0) {
            throw new IOException("SNTP: Zero transmitTime");
        }
    }

    public static long getElapsedRealtimeOffsetMs() {
        long j4;
        synchronized (valueLock) {
            try {
                j4 = isInitialized ? elapsedRealtimeOffsetMs : C.TIME_UNSET;
            } catch (Throwable th) {
                throw th;
            }
        }
        return j4;
    }

    public static String getNtpHost() {
        String str;
        synchronized (valueLock) {
            str = ntpHost;
        }
        return str;
    }

    public static void initialize(Loader loader, InitializationCallback initializationCallback) {
        if (isInitialized()) {
            if (initializationCallback != null) {
                initializationCallback.onInitialized();
            }
        } else {
            if (loader == null) {
                loader = new Loader("SntpClient");
            }
            loader.startLoading(new NtpTimeLoadable(), new NtpTimeCallback(initializationCallback), 1);
        }
    }

    public static boolean isInitialized() {
        boolean z6;
        synchronized (valueLock) {
            z6 = isInitialized;
        }
        return z6;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static long loadNtpTimeOffsetMs() throws UnknownHostException {
        InetAddress byName = InetAddress.getByName(getNtpHost());
        DatagramSocket datagramSocket = new DatagramSocket();
        try {
            datagramSocket.setSoTimeout(10000);
            byte[] bArr = new byte[NTP_PACKET_SIZE];
            DatagramPacket datagramPacket = new DatagramPacket(bArr, NTP_PACKET_SIZE, byName, NTP_PORT);
            bArr[0] = 27;
            long jCurrentTimeMillis = System.currentTimeMillis();
            long jElapsedRealtime = SystemClock.elapsedRealtime();
            writeTimestamp(bArr, TRANSMIT_TIME_OFFSET, jCurrentTimeMillis);
            datagramSocket.send(datagramPacket);
            datagramSocket.receive(new DatagramPacket(bArr, NTP_PACKET_SIZE));
            long jElapsedRealtime2 = SystemClock.elapsedRealtime();
            long j4 = (jElapsedRealtime2 - jElapsedRealtime) + jCurrentTimeMillis;
            byte b5 = bArr[0];
            int i6 = bArr[1] & 255;
            long timestamp = readTimestamp(bArr, 24);
            long timestamp2 = readTimestamp(bArr, 32);
            long timestamp3 = readTimestamp(bArr, TRANSMIT_TIME_OFFSET);
            checkValidServerReply((byte) ((b5 >> 6) & 3), (byte) (b5 & 7), i6, timestamp3);
            long j6 = (j4 + (((timestamp3 - j4) + (timestamp2 - timestamp)) / 2)) - jElapsedRealtime2;
            datagramSocket.close();
            return j6;
        } catch (Throwable th) {
            try {
                datagramSocket.close();
            } catch (Throwable th2) {
                th.addSuppressed(th2);
            }
            throw th;
        }
    }

    private static long read32(byte[] bArr, int i6) {
        int i7 = bArr[i6];
        int i8 = bArr[i6 + 1];
        int i9 = bArr[i6 + 2];
        int i10 = bArr[i6 + 3];
        if ((i7 & 128) == 128) {
            i7 = (i7 & 127) + 128;
        }
        if ((i8 & 128) == 128) {
            i8 = (i8 & 127) + 128;
        }
        if ((i9 & 128) == 128) {
            i9 = (i9 & 127) + 128;
        }
        if ((i10 & 128) == 128) {
            i10 = (i10 & 127) + 128;
        }
        return (((long) i7) << 24) + (((long) i8) << 16) + (((long) i9) << 8) + ((long) i10);
    }

    private static long readTimestamp(byte[] bArr, int i6) {
        long j4 = read32(bArr, i6);
        long j6 = read32(bArr, i6 + 4);
        if (j4 == 0 && j6 == 0) {
            return 0L;
        }
        return ((j6 * 1000) / 4294967296L) + ((j4 - OFFSET_1900_TO_1970) * 1000);
    }

    public static void setNtpHost(String str) {
        synchronized (valueLock) {
            try {
                if (!ntpHost.equals(str)) {
                    ntpHost = str;
                    isInitialized = false;
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    private static void writeTimestamp(byte[] bArr, int i6, long j4) {
        if (j4 == 0) {
            Arrays.fill(bArr, i6, i6 + 8, (byte) 0);
            return;
        }
        long j6 = j4 / 1000;
        long j7 = j4 - (j6 * 1000);
        long j8 = j6 + OFFSET_1900_TO_1970;
        bArr[i6] = (byte) (j8 >> 24);
        bArr[i6 + 1] = (byte) (j8 >> 16);
        bArr[i6 + 2] = (byte) (j8 >> 8);
        bArr[i6 + 3] = (byte) j8;
        long j9 = (j7 * 4294967296L) / 1000;
        bArr[i6 + 4] = (byte) (j9 >> 24);
        bArr[i6 + 5] = (byte) (j9 >> 16);
        bArr[i6 + 6] = (byte) (j9 >> 8);
        bArr[i6 + 7] = (byte) (Math.random() * 255.0d);
    }
}