package okhttp3.internal.http2; import androidx.core.internal.view.SupportMenu; import com.mbridge.msdk.playercommon.exoplayer2.C; import java.io.Closeable; import java.io.IOException; import java.net.Socket; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ExecutorService; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.RejectedExecutionException; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.SynchronousQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import okhttp3.internal.NamedRunnable; import okhttp3.internal.Util; import okhttp3.internal.http2.Http2Reader; import okhttp3.internal.platform.Platform; import okio.Buffer; import okio.BufferedSink; import okio.BufferedSource; import okio.ByteString; /* loaded from: classes5.dex */ public final class Http2Connection implements Closeable { public static final ExecutorService listenerExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue(), Util.threadFactory("OkHttp Http2Connection", true)); public long bytesLeftInWriteWindow; public final boolean client; public final String connectionName; public final Set currentPushRequests; public int lastGoodStreamId; public final Listener listener; public int nextStreamId; public final Settings peerSettings; public final ExecutorService pushExecutor; public final PushObserver pushObserver; public final ReaderRunnable readerRunnable; public boolean shutdown; public final Socket socket; public final Http2Writer writer; public final ScheduledExecutorService writerExecutor; public final Map streams = new LinkedHashMap(); public long intervalPingsSent = 0; public long intervalPongsReceived = 0; public long degradedPingsSent = 0; public long degradedPongsReceived = 0; public long awaitPingsSent = 0; public long awaitPongsReceived = 0; public long degradedPongDeadlineNs = 0; public long unacknowledgedBytesRead = 0; public Settings okHttpSettings = new Settings(); public static abstract class Listener { public static final Listener REFUSE_INCOMING_STREAMS = new Listener() { // from class: okhttp3.internal.http2.Http2Connection.Listener.1 @Override // okhttp3.internal.http2.Http2Connection.Listener public void onStream(Http2Stream http2Stream) { http2Stream.close(ErrorCode.REFUSED_STREAM, null); } }; public void onSettings(Http2Connection http2Connection) { } public abstract void onStream(Http2Stream http2Stream); } public boolean pushedStream(int i) { return i != 0 && (i & 1) == 0; } public static /* synthetic */ long access$108(Http2Connection http2Connection) { long j = http2Connection.intervalPongsReceived; http2Connection.intervalPongsReceived = 1 + j; return j; } public static /* synthetic */ long access$208(Http2Connection http2Connection) { long j = http2Connection.intervalPingsSent; http2Connection.intervalPingsSent = 1 + j; return j; } public static /* synthetic */ long access$608(Http2Connection http2Connection) { long j = http2Connection.degradedPongsReceived; http2Connection.degradedPongsReceived = 1 + j; return j; } public static /* synthetic */ long access$708(Http2Connection http2Connection) { long j = http2Connection.awaitPongsReceived; http2Connection.awaitPongsReceived = 1 + j; return j; } public Http2Connection(Builder builder) { Settings settings = new Settings(); this.peerSettings = settings; this.currentPushRequests = new LinkedHashSet(); this.pushObserver = builder.pushObserver; boolean z = builder.client; this.client = z; this.listener = builder.listener; int i = z ? 1 : 2; this.nextStreamId = i; if (z) { this.nextStreamId = i + 2; } if (z) { this.okHttpSettings.set(7, 16777216); } String str = builder.connectionName; this.connectionName = str; ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1, Util.threadFactory(Util.format("OkHttp %s Writer", str), false)); this.writerExecutor = scheduledThreadPoolExecutor; if (builder.pingIntervalMillis != 0) { IntervalPingRunnable intervalPingRunnable = new IntervalPingRunnable(); int i2 = builder.pingIntervalMillis; scheduledThreadPoolExecutor.scheduleAtFixedRate(intervalPingRunnable, i2, i2, TimeUnit.MILLISECONDS); } this.pushExecutor = new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue(), Util.threadFactory(Util.format("OkHttp %s Push Observer", str), true)); settings.set(7, SupportMenu.USER_MASK); settings.set(5, 16384); this.bytesLeftInWriteWindow = settings.getInitialWindowSize(); this.socket = builder.socket; this.writer = new Http2Writer(builder.sink, z); this.readerRunnable = new ReaderRunnable(new Http2Reader(builder.source, z)); } public synchronized Http2Stream getStream(int i) { return (Http2Stream) this.streams.get(Integer.valueOf(i)); } public synchronized Http2Stream removeStream(int i) { Http2Stream http2Stream; http2Stream = (Http2Stream) this.streams.remove(Integer.valueOf(i)); notifyAll(); return http2Stream; } public synchronized int maxConcurrentStreams() { return this.peerSettings.getMaxConcurrentStreams(Integer.MAX_VALUE); } public synchronized void updateConnectionFlowControl(long j) { long j2 = this.unacknowledgedBytesRead + j; this.unacknowledgedBytesRead = j2; if (j2 >= this.okHttpSettings.getInitialWindowSize() / 2) { writeWindowUpdateLater(0, this.unacknowledgedBytesRead); this.unacknowledgedBytesRead = 0L; } } public Http2Stream newStream(List list, boolean z) { return newStream(0, list, z); } /* JADX WARN: Removed duplicated region for block: B:21:0x0044 A[Catch: all -> 0x0014, TryCatch #0 {all -> 0x0014, blocks: (B:6:0x0007, B:8:0x000e, B:9:0x0016, B:11:0x001a, B:13:0x002c, B:15:0x0034, B:19:0x003e, B:21:0x0044, B:22:0x004d, B:36:0x0072, B:37:0x0077), top: B:5:0x0007, outer: #1 }] */ /* Code decompiled incorrectly, please refer to instructions dump. To view partially-correct add '--show-bad-code' argument */ public final okhttp3.internal.http2.Http2Stream newStream(int r11, java.util.List r12, boolean r13) { /* r10 = this; r6 = r13 ^ 1 r4 = 0 okhttp3.internal.http2.Http2Writer r7 = r10.writer monitor-enter(r7) monitor-enter(r10) // Catch: java.lang.Throwable -> L56 int r0 = r10.nextStreamId // Catch: java.lang.Throwable -> L14 r1 = 1073741823(0x3fffffff, float:1.9999999) if (r0 <= r1) goto L16 okhttp3.internal.http2.ErrorCode r0 = okhttp3.internal.http2.ErrorCode.REFUSED_STREAM // Catch: java.lang.Throwable -> L14 r10.shutdown(r0) // Catch: java.lang.Throwable -> L14 goto L16 L14: r11 = move-exception goto L78 L16: boolean r0 = r10.shutdown // Catch: java.lang.Throwable -> L14 if (r0 != 0) goto L72 int r8 = r10.nextStreamId // Catch: java.lang.Throwable -> L14 int r0 = r8 + 2 r10.nextStreamId = r0 // Catch: java.lang.Throwable -> L14 okhttp3.internal.http2.Http2Stream r9 = new okhttp3.internal.http2.Http2Stream // Catch: java.lang.Throwable -> L14 r5 = 0 r0 = r9 r1 = r8 r2 = r10 r3 = r6 r0.(r1, r2, r3, r4, r5) // Catch: java.lang.Throwable -> L14 if (r13 == 0) goto L3d long r0 = r10.bytesLeftInWriteWindow // Catch: java.lang.Throwable -> L14 r2 = 0 int r13 = (r0 > r2 ? 1 : (r0 == r2 ? 0 : -1)) if (r13 == 0) goto L3d long r0 = r9.bytesLeftInWriteWindow // Catch: java.lang.Throwable -> L14 int r13 = (r0 > r2 ? 1 : (r0 == r2 ? 0 : -1)) if (r13 != 0) goto L3b goto L3d L3b: r13 = 0 goto L3e L3d: r13 = 1 L3e: boolean r0 = r9.isOpen() // Catch: java.lang.Throwable -> L14 if (r0 == 0) goto L4d java.util.Map r0 = r10.streams // Catch: java.lang.Throwable -> L14 java.lang.Integer r1 = java.lang.Integer.valueOf(r8) // Catch: java.lang.Throwable -> L14 r0.put(r1, r9) // Catch: java.lang.Throwable -> L14 L4d: monitor-exit(r10) // Catch: java.lang.Throwable -> L14 if (r11 != 0) goto L58 okhttp3.internal.http2.Http2Writer r11 = r10.writer // Catch: java.lang.Throwable -> L56 r11.headers(r6, r8, r12) // Catch: java.lang.Throwable -> L56 goto L61 L56: r11 = move-exception goto L7a L58: boolean r0 = r10.client // Catch: java.lang.Throwable -> L56 if (r0 != 0) goto L6a okhttp3.internal.http2.Http2Writer r0 = r10.writer // Catch: java.lang.Throwable -> L56 r0.pushPromise(r11, r8, r12) // Catch: java.lang.Throwable -> L56 L61: monitor-exit(r7) // Catch: java.lang.Throwable -> L56 if (r13 == 0) goto L69 okhttp3.internal.http2.Http2Writer r11 = r10.writer r11.flush() L69: return r9 L6a: java.lang.IllegalArgumentException r11 = new java.lang.IllegalArgumentException // Catch: java.lang.Throwable -> L56 java.lang.String r12 = "client streams shouldn't have associated stream IDs" r11.(r12) // Catch: java.lang.Throwable -> L56 throw r11 // Catch: java.lang.Throwable -> L56 L72: okhttp3.internal.http2.ConnectionShutdownException r11 = new okhttp3.internal.http2.ConnectionShutdownException // Catch: java.lang.Throwable -> L14 r11.() // Catch: java.lang.Throwable -> L14 throw r11 // Catch: java.lang.Throwable -> L14 L78: monitor-exit(r10) // Catch: java.lang.Throwable -> L14 throw r11 // Catch: java.lang.Throwable -> L56 L7a: monitor-exit(r7) // Catch: java.lang.Throwable -> L56 throw r11 */ throw new UnsupportedOperationException("Method not decompiled: okhttp3.internal.http2.Http2Connection.newStream(int, java.util.List, boolean):okhttp3.internal.http2.Http2Stream"); } public void writeHeaders(int i, boolean z, List list) { this.writer.headers(z, i, list); } /* JADX WARN: Code restructure failed: missing block: B:20:0x0032, code lost: r2 = java.lang.Math.min((int) java.lang.Math.min(r12, r4), r8.writer.maxDataLength()); r6 = r2; r8.bytesLeftInWriteWindow -= r6; */ /* Code decompiled incorrectly, please refer to instructions dump. To view partially-correct add '--show-bad-code' argument */ public void writeData(int r9, boolean r10, okio.Buffer r11, long r12) { /* r8 = this; r0 = 0 int r2 = (r12 > r0 ? 1 : (r12 == r0 ? 0 : -1)) r3 = 0 if (r2 != 0) goto Ld okhttp3.internal.http2.Http2Writer r12 = r8.writer r12.data(r10, r9, r11, r3) return Ld: int r2 = (r12 > r0 ? 1 : (r12 == r0 ? 0 : -1)) if (r2 <= 0) goto L67 monitor-enter(r8) L12: long r4 = r8.bytesLeftInWriteWindow // Catch: java.lang.Throwable -> L28 java.lang.InterruptedException -> L58 int r2 = (r4 > r0 ? 1 : (r4 == r0 ? 0 : -1)) if (r2 > 0) goto L32 java.util.Map r2 = r8.streams // Catch: java.lang.Throwable -> L28 java.lang.InterruptedException -> L58 java.lang.Integer r4 = java.lang.Integer.valueOf(r9) // Catch: java.lang.Throwable -> L28 java.lang.InterruptedException -> L58 boolean r2 = r2.containsKey(r4) // Catch: java.lang.Throwable -> L28 java.lang.InterruptedException -> L58 if (r2 == 0) goto L2a r8.wait() // Catch: java.lang.Throwable -> L28 java.lang.InterruptedException -> L58 goto L12 L28: r9 = move-exception goto L65 L2a: java.io.IOException r9 = new java.io.IOException // Catch: java.lang.Throwable -> L28 java.lang.InterruptedException -> L58 java.lang.String r10 = "stream closed" r9.(r10) // Catch: java.lang.Throwable -> L28 java.lang.InterruptedException -> L58 throw r9 // Catch: java.lang.Throwable -> L28 java.lang.InterruptedException -> L58 L32: long r4 = java.lang.Math.min(r12, r4) // Catch: java.lang.Throwable -> L28 int r2 = (int) r4 // Catch: java.lang.Throwable -> L28 okhttp3.internal.http2.Http2Writer r4 = r8.writer // Catch: java.lang.Throwable -> L28 int r4 = r4.maxDataLength() // Catch: java.lang.Throwable -> L28 int r2 = java.lang.Math.min(r2, r4) // Catch: java.lang.Throwable -> L28 long r4 = r8.bytesLeftInWriteWindow // Catch: java.lang.Throwable -> L28 long r6 = (long) r2 // Catch: java.lang.Throwable -> L28 long r4 = r4 - r6 r8.bytesLeftInWriteWindow = r4 // Catch: java.lang.Throwable -> L28 monitor-exit(r8) // Catch: java.lang.Throwable -> L28 long r12 = r12 - r6 okhttp3.internal.http2.Http2Writer r4 = r8.writer if (r10 == 0) goto L53 int r5 = (r12 > r0 ? 1 : (r12 == r0 ? 0 : -1)) if (r5 != 0) goto L53 r5 = 1 goto L54 L53: r5 = r3 L54: r4.data(r5, r9, r11, r2) goto Ld L58: java.lang.Thread r9 = java.lang.Thread.currentThread() // Catch: java.lang.Throwable -> L28 r9.interrupt() // Catch: java.lang.Throwable -> L28 java.io.InterruptedIOException r9 = new java.io.InterruptedIOException // Catch: java.lang.Throwable -> L28 r9.() // Catch: java.lang.Throwable -> L28 throw r9 // Catch: java.lang.Throwable -> L28 L65: monitor-exit(r8) // Catch: java.lang.Throwable -> L28 throw r9 L67: return */ throw new UnsupportedOperationException("Method not decompiled: okhttp3.internal.http2.Http2Connection.writeData(int, boolean, okio.Buffer, long):void"); } public void writeSynResetLater(final int i, final ErrorCode errorCode) { try { this.writerExecutor.execute(new NamedRunnable("OkHttp %s stream %d", new Object[]{this.connectionName, Integer.valueOf(i)}) { // from class: okhttp3.internal.http2.Http2Connection.1 @Override // okhttp3.internal.NamedRunnable public void execute() { try { Http2Connection.this.writeSynReset(i, errorCode); } catch (IOException e) { Http2Connection.this.failConnection(e); } } }); } catch (RejectedExecutionException unused) { } } public void writeSynReset(int i, ErrorCode errorCode) { this.writer.rstStream(i, errorCode); } public void writeWindowUpdateLater(final int i, final long j) { try { this.writerExecutor.execute(new NamedRunnable("OkHttp Window Update %s stream %d", new Object[]{this.connectionName, Integer.valueOf(i)}) { // from class: okhttp3.internal.http2.Http2Connection.2 @Override // okhttp3.internal.NamedRunnable public void execute() { try { Http2Connection.this.writer.windowUpdate(i, j); } catch (IOException e) { Http2Connection.this.failConnection(e); } } }); } catch (RejectedExecutionException unused) { } } public final class PingRunnable extends NamedRunnable { public final int payload1; public final int payload2; public final boolean reply; public PingRunnable(boolean z, int i, int i2) { super("OkHttp %s ping %08x%08x", Http2Connection.this.connectionName, Integer.valueOf(i), Integer.valueOf(i2)); this.reply = z; this.payload1 = i; this.payload2 = i2; } @Override // okhttp3.internal.NamedRunnable public void execute() { Http2Connection.this.writePing(this.reply, this.payload1, this.payload2); } } public final class IntervalPingRunnable extends NamedRunnable { public IntervalPingRunnable() { super("OkHttp %s ping", Http2Connection.this.connectionName); } @Override // okhttp3.internal.NamedRunnable public void execute() { boolean z; synchronized (Http2Connection.this) { if (Http2Connection.this.intervalPongsReceived < Http2Connection.this.intervalPingsSent) { z = true; } else { Http2Connection.access$208(Http2Connection.this); z = false; } } if (z) { Http2Connection.this.failConnection(null); } else { Http2Connection.this.writePing(false, 1, 0); } } } public void writePing(boolean z, int i, int i2) { try { this.writer.ping(z, i, i2); } catch (IOException e) { failConnection(e); } } public void flush() { this.writer.flush(); } public void shutdown(ErrorCode errorCode) { synchronized (this.writer) { synchronized (this) { if (this.shutdown) { return; } this.shutdown = true; this.writer.goAway(this.lastGoodStreamId, errorCode, Util.EMPTY_BYTE_ARRAY); } } } @Override // java.io.Closeable, java.lang.AutoCloseable public void close() { close(ErrorCode.NO_ERROR, ErrorCode.CANCEL, null); } public void close(ErrorCode errorCode, ErrorCode errorCode2, IOException iOException) { Http2Stream[] http2StreamArr; try { shutdown(errorCode); } catch (IOException unused) { } synchronized (this) { try { if (this.streams.isEmpty()) { http2StreamArr = null; } else { http2StreamArr = (Http2Stream[]) this.streams.values().toArray(new Http2Stream[this.streams.size()]); this.streams.clear(); } } catch (Throwable th) { throw th; } } if (http2StreamArr != null) { for (Http2Stream http2Stream : http2StreamArr) { try { http2Stream.close(errorCode2, iOException); } catch (IOException unused2) { } } } try { this.writer.close(); } catch (IOException unused3) { } try { this.socket.close(); } catch (IOException unused4) { } this.writerExecutor.shutdown(); this.pushExecutor.shutdown(); } public final void failConnection(IOException iOException) { ErrorCode errorCode = ErrorCode.PROTOCOL_ERROR; close(errorCode, errorCode, iOException); } public void start() { start(true); } public void start(boolean z) { if (z) { this.writer.connectionPreface(); this.writer.settings(this.okHttpSettings); if (this.okHttpSettings.getInitialWindowSize() != 65535) { this.writer.windowUpdate(0, r5 - SupportMenu.USER_MASK); } } new Thread(this.readerRunnable).start(); } public synchronized boolean isHealthy(long j) { if (this.shutdown) { return false; } if (this.degradedPongsReceived < this.degradedPingsSent) { if (j >= this.degradedPongDeadlineNs) { return false; } } return true; } public void sendDegradedPingLater() { synchronized (this) { try { long j = this.degradedPongsReceived; long j2 = this.degradedPingsSent; if (j < j2) { return; } this.degradedPingsSent = j2 + 1; this.degradedPongDeadlineNs = System.nanoTime() + C.NANOS_PER_SECOND; try { this.writerExecutor.execute(new NamedRunnable("OkHttp %s ping", this.connectionName) { // from class: okhttp3.internal.http2.Http2Connection.3 @Override // okhttp3.internal.NamedRunnable public void execute() { Http2Connection.this.writePing(false, 2, 0); } }); } catch (RejectedExecutionException unused) { } } catch (Throwable th) { throw th; } } } public static class Builder { public boolean client; public String connectionName; public int pingIntervalMillis; public BufferedSink sink; public Socket socket; public BufferedSource source; public Listener listener = Listener.REFUSE_INCOMING_STREAMS; public PushObserver pushObserver = PushObserver.CANCEL; public Builder listener(Listener listener) { this.listener = listener; return this; } public Builder pingIntervalMillis(int i) { this.pingIntervalMillis = i; return this; } public Builder socket(Socket socket, String str, BufferedSource bufferedSource, BufferedSink bufferedSink) { this.socket = socket; this.connectionName = str; this.source = bufferedSource; this.sink = bufferedSink; return this; } public Builder(boolean z) { this.client = z; } public Http2Connection build() { return new Http2Connection(this); } } public class ReaderRunnable extends NamedRunnable implements Http2Reader.Handler { public final Http2Reader reader; @Override // okhttp3.internal.http2.Http2Reader.Handler public void ackSettings() { } @Override // okhttp3.internal.http2.Http2Reader.Handler public void priority(int i, int i2, int i3, boolean z) { } public ReaderRunnable(Http2Reader http2Reader) { super("OkHttp %s", Http2Connection.this.connectionName); this.reader = http2Reader; } /* JADX WARN: Multi-variable type inference failed */ /* JADX WARN: Type inference failed for: r0v0, types: [okhttp3.internal.http2.ErrorCode] */ /* JADX WARN: Type inference failed for: r0v3 */ /* JADX WARN: Type inference failed for: r0v5, types: [java.io.Closeable, okhttp3.internal.http2.Http2Reader] */ @Override // okhttp3.internal.NamedRunnable public void execute() { ErrorCode errorCode; ErrorCode errorCode2 = ErrorCode.INTERNAL_ERROR; IOException e = null; try { try { this.reader.readConnectionPreface(this); while (this.reader.nextFrame(false, this)) { } ErrorCode errorCode3 = ErrorCode.NO_ERROR; try { Http2Connection.this.close(errorCode3, ErrorCode.CANCEL, null); errorCode = errorCode3; } catch (IOException e2) { e = e2; ErrorCode errorCode4 = ErrorCode.PROTOCOL_ERROR; Http2Connection http2Connection = Http2Connection.this; http2Connection.close(errorCode4, errorCode4, e); errorCode = http2Connection; errorCode2 = this.reader; Util.closeQuietly((Closeable) errorCode2); } } catch (Throwable th) { th = th; Http2Connection.this.close(errorCode, errorCode2, e); Util.closeQuietly(this.reader); throw th; } } catch (IOException e3) { e = e3; } catch (Throwable th2) { th = th2; errorCode = errorCode2; Http2Connection.this.close(errorCode, errorCode2, e); Util.closeQuietly(this.reader); throw th; } errorCode2 = this.reader; Util.closeQuietly((Closeable) errorCode2); } @Override // okhttp3.internal.http2.Http2Reader.Handler public void data(boolean z, int i, BufferedSource bufferedSource, int i2) { if (Http2Connection.this.pushedStream(i)) { Http2Connection.this.pushDataLater(i, bufferedSource, i2, z); return; } Http2Stream stream = Http2Connection.this.getStream(i); if (stream == null) { Http2Connection.this.writeSynResetLater(i, ErrorCode.PROTOCOL_ERROR); long j = i2; Http2Connection.this.updateConnectionFlowControl(j); bufferedSource.skip(j); return; } stream.receiveData(bufferedSource, i2); if (z) { stream.receiveHeaders(Util.EMPTY_HEADERS, true); } } @Override // okhttp3.internal.http2.Http2Reader.Handler public void headers(boolean z, int i, int i2, List list) { if (Http2Connection.this.pushedStream(i)) { Http2Connection.this.pushHeadersLater(i, list, z); return; } synchronized (Http2Connection.this) { try { Http2Stream stream = Http2Connection.this.getStream(i); if (stream == null) { if (Http2Connection.this.shutdown) { return; } Http2Connection http2Connection = Http2Connection.this; if (i <= http2Connection.lastGoodStreamId) { return; } if (i % 2 == http2Connection.nextStreamId % 2) { return; } final Http2Stream http2Stream = new Http2Stream(i, Http2Connection.this, false, z, Util.toHeaders(list)); Http2Connection http2Connection2 = Http2Connection.this; http2Connection2.lastGoodStreamId = i; http2Connection2.streams.put(Integer.valueOf(i), http2Stream); Http2Connection.listenerExecutor.execute(new NamedRunnable("OkHttp %s stream %d", new Object[]{Http2Connection.this.connectionName, Integer.valueOf(i)}) { // from class: okhttp3.internal.http2.Http2Connection.ReaderRunnable.1 @Override // okhttp3.internal.NamedRunnable public void execute() { try { Http2Connection.this.listener.onStream(http2Stream); } catch (IOException e) { Platform.get().log(4, "Http2Connection.Listener failure for " + Http2Connection.this.connectionName, e); try { http2Stream.close(ErrorCode.PROTOCOL_ERROR, e); } catch (IOException unused) { } } } }); return; } stream.receiveHeaders(Util.toHeaders(list), z); } catch (Throwable th) { throw th; } } } @Override // okhttp3.internal.http2.Http2Reader.Handler public void rstStream(int i, ErrorCode errorCode) { if (Http2Connection.this.pushedStream(i)) { Http2Connection.this.pushResetLater(i, errorCode); return; } Http2Stream removeStream = Http2Connection.this.removeStream(i); if (removeStream != null) { removeStream.receiveRstStream(errorCode); } } @Override // okhttp3.internal.http2.Http2Reader.Handler public void settings(final boolean z, final Settings settings) { try { Http2Connection.this.writerExecutor.execute(new NamedRunnable("OkHttp %s ACK Settings", new Object[]{Http2Connection.this.connectionName}) { // from class: okhttp3.internal.http2.Http2Connection.ReaderRunnable.2 @Override // okhttp3.internal.NamedRunnable public void execute() { ReaderRunnable.this.applyAndAckSettings(z, settings); } }); } catch (RejectedExecutionException unused) { } } public void applyAndAckSettings(boolean z, Settings settings) { Http2Stream[] http2StreamArr; long j; synchronized (Http2Connection.this.writer) { synchronized (Http2Connection.this) { try { int initialWindowSize = Http2Connection.this.peerSettings.getInitialWindowSize(); if (z) { Http2Connection.this.peerSettings.clear(); } Http2Connection.this.peerSettings.merge(settings); int initialWindowSize2 = Http2Connection.this.peerSettings.getInitialWindowSize(); http2StreamArr = null; if (initialWindowSize2 == -1 || initialWindowSize2 == initialWindowSize) { j = 0; } else { j = initialWindowSize2 - initialWindowSize; if (!Http2Connection.this.streams.isEmpty()) { http2StreamArr = (Http2Stream[]) Http2Connection.this.streams.values().toArray(new Http2Stream[Http2Connection.this.streams.size()]); } } } finally { } } try { Http2Connection http2Connection = Http2Connection.this; http2Connection.writer.applyAndAckSettings(http2Connection.peerSettings); } catch (IOException e) { Http2Connection.this.failConnection(e); } } if (http2StreamArr != null) { for (Http2Stream http2Stream : http2StreamArr) { synchronized (http2Stream) { http2Stream.addBytesToWriteWindow(j); } } } Http2Connection.listenerExecutor.execute(new NamedRunnable("OkHttp %s settings", Http2Connection.this.connectionName) { // from class: okhttp3.internal.http2.Http2Connection.ReaderRunnable.3 @Override // okhttp3.internal.NamedRunnable public void execute() { Http2Connection http2Connection2 = Http2Connection.this; http2Connection2.listener.onSettings(http2Connection2); } }); } @Override // okhttp3.internal.http2.Http2Reader.Handler public void ping(boolean z, int i, int i2) { if (!z) { try { Http2Connection.this.writerExecutor.execute(Http2Connection.this.new PingRunnable(true, i, i2)); return; } catch (RejectedExecutionException unused) { return; } } synchronized (Http2Connection.this) { try { if (i == 1) { Http2Connection.access$108(Http2Connection.this); } else if (i == 2) { Http2Connection.access$608(Http2Connection.this); } else if (i == 3) { Http2Connection.access$708(Http2Connection.this); Http2Connection.this.notifyAll(); } } finally { } } } @Override // okhttp3.internal.http2.Http2Reader.Handler public void goAway(int i, ErrorCode errorCode, ByteString byteString) { Http2Stream[] http2StreamArr; byteString.size(); synchronized (Http2Connection.this) { http2StreamArr = (Http2Stream[]) Http2Connection.this.streams.values().toArray(new Http2Stream[Http2Connection.this.streams.size()]); Http2Connection.this.shutdown = true; } for (Http2Stream http2Stream : http2StreamArr) { if (http2Stream.getId() > i && http2Stream.isLocallyInitiated()) { http2Stream.receiveRstStream(ErrorCode.REFUSED_STREAM); Http2Connection.this.removeStream(http2Stream.getId()); } } } @Override // okhttp3.internal.http2.Http2Reader.Handler public void windowUpdate(int i, long j) { if (i == 0) { synchronized (Http2Connection.this) { Http2Connection http2Connection = Http2Connection.this; http2Connection.bytesLeftInWriteWindow += j; http2Connection.notifyAll(); } return; } Http2Stream stream = Http2Connection.this.getStream(i); if (stream != null) { synchronized (stream) { stream.addBytesToWriteWindow(j); } } } @Override // okhttp3.internal.http2.Http2Reader.Handler public void pushPromise(int i, int i2, List list) { Http2Connection.this.pushRequestLater(i2, list); } } public void pushRequestLater(final int i, final List list) { synchronized (this) { try { if (this.currentPushRequests.contains(Integer.valueOf(i))) { writeSynResetLater(i, ErrorCode.PROTOCOL_ERROR); return; } this.currentPushRequests.add(Integer.valueOf(i)); try { pushExecutorExecute(new NamedRunnable("OkHttp %s Push Request[%s]", new Object[]{this.connectionName, Integer.valueOf(i)}) { // from class: okhttp3.internal.http2.Http2Connection.4 @Override // okhttp3.internal.NamedRunnable public void execute() { if (Http2Connection.this.pushObserver.onRequest(i, list)) { try { Http2Connection.this.writer.rstStream(i, ErrorCode.CANCEL); synchronized (Http2Connection.this) { Http2Connection.this.currentPushRequests.remove(Integer.valueOf(i)); } } catch (IOException unused) { } } } }); } catch (RejectedExecutionException unused) { } } catch (Throwable th) { throw th; } } } public void pushHeadersLater(final int i, final List list, final boolean z) { try { pushExecutorExecute(new NamedRunnable("OkHttp %s Push Headers[%s]", new Object[]{this.connectionName, Integer.valueOf(i)}) { // from class: okhttp3.internal.http2.Http2Connection.5 @Override // okhttp3.internal.NamedRunnable public void execute() { boolean onHeaders = Http2Connection.this.pushObserver.onHeaders(i, list, z); if (onHeaders) { try { Http2Connection.this.writer.rstStream(i, ErrorCode.CANCEL); } catch (IOException unused) { return; } } if (onHeaders || z) { synchronized (Http2Connection.this) { Http2Connection.this.currentPushRequests.remove(Integer.valueOf(i)); } } } }); } catch (RejectedExecutionException unused) { } } public void pushDataLater(final int i, BufferedSource bufferedSource, final int i2, final boolean z) { final Buffer buffer = new Buffer(); long j = i2; bufferedSource.require(j); bufferedSource.read(buffer, j); if (buffer.size() != j) { throw new IOException(buffer.size() + " != " + i2); } pushExecutorExecute(new NamedRunnable("OkHttp %s Push Data[%s]", new Object[]{this.connectionName, Integer.valueOf(i)}) { // from class: okhttp3.internal.http2.Http2Connection.6 @Override // okhttp3.internal.NamedRunnable public void execute() { try { boolean onData = Http2Connection.this.pushObserver.onData(i, buffer, i2, z); if (onData) { Http2Connection.this.writer.rstStream(i, ErrorCode.CANCEL); } if (onData || z) { synchronized (Http2Connection.this) { Http2Connection.this.currentPushRequests.remove(Integer.valueOf(i)); } } } catch (IOException unused) { } } }); } public void pushResetLater(final int i, final ErrorCode errorCode) { pushExecutorExecute(new NamedRunnable("OkHttp %s Push Reset[%s]", new Object[]{this.connectionName, Integer.valueOf(i)}) { // from class: okhttp3.internal.http2.Http2Connection.7 @Override // okhttp3.internal.NamedRunnable public void execute() { Http2Connection.this.pushObserver.onReset(i, errorCode); synchronized (Http2Connection.this) { Http2Connection.this.currentPushRequests.remove(Integer.valueOf(i)); } } }); } public final synchronized void pushExecutorExecute(NamedRunnable namedRunnable) { if (!this.shutdown) { this.pushExecutor.execute(namedRunnable); } } }