package io.grpc.internal;

import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.MoreExecutors;
import io.grpc.Attributes;
import io.grpc.CallOptions;
import io.grpc.ClientCall;
import io.grpc.Codec;
import io.grpc.Compressor;
import io.grpc.CompressorRegistry;
import io.grpc.Context;
import io.grpc.Contexts;
import io.grpc.Deadline;
import io.grpc.DecompressorRegistry;
import io.grpc.InternalConfigSelector;
import io.grpc.InternalDecompressorRegistry;
import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
import io.grpc.Status;
import io.grpc.internal.ClientStreamListener;
import io.grpc.internal.ManagedChannelServiceConfig;
import io.grpc.internal.StreamListener;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Locale;
import java.util.concurrent.CancellationException;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import o.C13115fRJ;
import o.C13116fRL;
import o.fRN;

/* JADX INFO: Access modifiers changed from: package-private */
/* loaded from: classes6.dex */
public final class ClientCallImpl<ReqT, RespT> extends ClientCall<ReqT, RespT> {
    private final Executor callExecutor;
    private final boolean callExecutorIsDirect;
    private CallOptions callOptions;
    private boolean cancelCalled;
    private volatile boolean cancelListenersShouldBeRemoved;
    private final CallTracer channelCallsTracer;
    private final ClientStreamProvider clientStreamProvider;
    private final Context context;
    private final ScheduledExecutorService deadlineCancellationExecutor;
    private volatile ScheduledFuture<?> deadlineCancellationFuture;
    private boolean fullStreamDecompression;
    private boolean halfCloseCalled;
    private final MethodDescriptor<ReqT, RespT> method;
    private ClientStream stream;
    private final fRN tag;
    private final boolean unaryRequest;
    private static final Logger log = Logger.getLogger(ClientCallImpl.class.getName());
    private static final byte[] FULL_STREAM_DECOMPRESSION_ENCODINGS = "gzip".getBytes(StandardCharsets.US_ASCII);
    private final ClientCallImpl<ReqT, RespT>.ContextCancellationListener cancellationListener = new ContextCancellationListener();
    private DecompressorRegistry decompressorRegistry = DecompressorRegistry.getDefaultInstance();
    private CompressorRegistry compressorRegistry = CompressorRegistry.getDefaultInstance();

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public interface ClientStreamProvider {
        ClientStream newStream(MethodDescriptor<?, ?> methodDescriptor, CallOptions callOptions, Metadata metadata, Context context);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public ClientCallImpl(MethodDescriptor<ReqT, RespT> methodDescriptor, Executor executor, CallOptions callOptions, ClientStreamProvider clientStreamProvider, ScheduledExecutorService scheduledExecutorService, CallTracer callTracer, InternalConfigSelector internalConfigSelector) {
        this.method = methodDescriptor;
        methodDescriptor.getFullMethodName();
        this.tag = C13115fRJ.a();
        if (executor == MoreExecutors.directExecutor()) {
            this.callExecutor = new SerializeReentrantCallsDirectExecutor();
            this.callExecutorIsDirect = true;
        } else {
            this.callExecutor = new SerializingExecutor(executor);
            this.callExecutorIsDirect = false;
        }
        this.channelCallsTracer = callTracer;
        this.context = Context.current();
        this.unaryRequest = methodDescriptor.getType() == MethodDescriptor.MethodType.UNARY || methodDescriptor.getType() == MethodDescriptor.MethodType.SERVER_STREAMING;
        this.callOptions = callOptions;
        this.clientStreamProvider = clientStreamProvider;
        this.deadlineCancellationExecutor = scheduledExecutorService;
        C13115fRJ.c();
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public final class ContextCancellationListener implements Context.CancellationListener {
        final ClientCallImpl this$0;

        private ContextCancellationListener(ClientCallImpl clientCallImpl) {
            this.this$0 = clientCallImpl;
        }

        @Override // io.grpc.Context.CancellationListener
        public final void cancelled(Context context) {
            this.this$0.stream.cancel(Contexts.statusFromCancelled(context));
        }
    }

    static void prepareHeaders(Metadata metadata, DecompressorRegistry decompressorRegistry, Compressor compressor, boolean z) {
        metadata.discardAll(GrpcUtil.CONTENT_LENGTH_KEY);
        metadata.discardAll(GrpcUtil.MESSAGE_ENCODING_KEY);
        if (compressor != Codec.Identity.NONE) {
            metadata.put(GrpcUtil.MESSAGE_ENCODING_KEY, compressor.getMessageEncoding());
        }
        metadata.discardAll(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY);
        byte[] rawAdvertisedMessageEncodings = InternalDecompressorRegistry.getRawAdvertisedMessageEncodings(decompressorRegistry);
        if (rawAdvertisedMessageEncodings.length != 0) {
            metadata.put(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY, rawAdvertisedMessageEncodings);
        }
        metadata.discardAll(GrpcUtil.CONTENT_ENCODING_KEY);
        metadata.discardAll(GrpcUtil.CONTENT_ACCEPT_ENCODING_KEY);
        if (z) {
            metadata.put(GrpcUtil.CONTENT_ACCEPT_ENCODING_KEY, FULL_STREAM_DECOMPRESSION_ENCODINGS);
        }
    }

    @Override // io.grpc.ClientCall
    public final void start(ClientCall.Listener<RespT> listener, Metadata metadata) {
        C13115fRJ.g();
        try {
            startInternal(listener, metadata);
        } finally {
            C13115fRJ.i();
        }
    }

    private void startInternal(ClientCall.Listener<RespT> listener, Metadata metadata) {
        Compressor compressor;
        Preconditions.checkState(this.stream == null, "Already started");
        Preconditions.checkState(!this.cancelCalled, "call was cancelled");
        Preconditions.checkNotNull(listener, "observer");
        Preconditions.checkNotNull(metadata, "headers");
        if (this.context.isCancelled()) {
            this.stream = NoopClientStream.INSTANCE;
            this.callExecutor.execute(new ContextRunnable(this, listener) { // from class: io.grpc.internal.ClientCallImpl.1ClosedByContext
                final ClientCallImpl this$0;
                final ClientCall.Listener val$finalObserver;

                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                {
                    super(this.context);
                    this.this$0 = this;
                    this.val$finalObserver = listener;
                }

                @Override // io.grpc.internal.ContextRunnable
                public void runInContext() {
                    ClientCallImpl clientCallImpl = this.this$0;
                    clientCallImpl.closeObserver(this.val$finalObserver, Contexts.statusFromCancelled(clientCallImpl.context), new Metadata());
                }
            });
            return;
        }
        applyMethodConfig();
        String compressor2 = this.callOptions.getCompressor();
        if (compressor2 != null) {
            compressor = this.compressorRegistry.lookupCompressor(compressor2);
            if (compressor == null) {
                this.stream = NoopClientStream.INSTANCE;
                this.callExecutor.execute(new ContextRunnable(this, listener, compressor2) { // from class: io.grpc.internal.ClientCallImpl.1ClosedByNotFoundCompressor
                    final ClientCallImpl this$0;
                    final String val$compressorName;
                    final ClientCall.Listener val$finalObserver;

                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                    {
                        super(this.context);
                        this.this$0 = this;
                        this.val$finalObserver = listener;
                        this.val$compressorName = compressor2;
                    }

                    @Override // io.grpc.internal.ContextRunnable
                    public void runInContext() {
                        this.this$0.closeObserver(this.val$finalObserver, Status.INTERNAL.withDescription(String.format("Unable to find compressor by name %s", this.val$compressorName)), new Metadata());
                    }
                });
                return;
            }
        } else {
            compressor = Codec.Identity.NONE;
        }
        prepareHeaders(metadata, this.decompressorRegistry, compressor, this.fullStreamDecompression);
        Deadline effectiveDeadline = effectiveDeadline();
        if (effectiveDeadline == null || !effectiveDeadline.isExpired()) {
            logIfContextNarrowedTimeout(effectiveDeadline, this.context.getDeadline(), this.callOptions.getDeadline());
            this.stream = this.clientStreamProvider.newStream(this.method, this.callOptions, metadata, this.context);
        } else {
            this.stream = new FailingClientStream(Status.DEADLINE_EXCEEDED.withDescription("ClientCall started after deadline exceeded: ".concat(String.valueOf(effectiveDeadline))), GrpcUtil.getClientStreamTracers(this.callOptions, metadata, 0, false));
        }
        if (this.callExecutorIsDirect) {
            this.stream.optimizeForDirectExecutor();
        }
        if (this.callOptions.getAuthority() != null) {
            this.stream.setAuthority(this.callOptions.getAuthority());
        }
        if (this.callOptions.getMaxInboundMessageSize() != null) {
            this.stream.setMaxInboundMessageSize(this.callOptions.getMaxInboundMessageSize().intValue());
        }
        if (this.callOptions.getMaxOutboundMessageSize() != null) {
            this.stream.setMaxOutboundMessageSize(this.callOptions.getMaxOutboundMessageSize().intValue());
        }
        if (effectiveDeadline != null) {
            this.stream.setDeadline(effectiveDeadline);
        }
        this.stream.setCompressor(compressor);
        boolean z = this.fullStreamDecompression;
        if (z) {
            this.stream.setFullStreamDecompression(z);
        }
        this.stream.setDecompressorRegistry(this.decompressorRegistry);
        this.channelCallsTracer.reportCallStarted();
        this.stream.start(new ClientStreamListenerImpl(this, listener));
        this.context.addListener(this.cancellationListener, MoreExecutors.directExecutor());
        if (effectiveDeadline != null && !effectiveDeadline.equals(this.context.getDeadline()) && this.deadlineCancellationExecutor != null) {
            this.deadlineCancellationFuture = startDeadlineTimer(effectiveDeadline);
        }
        if (this.cancelListenersShouldBeRemoved) {
            removeContextListenerAndCancelDeadlineFuture();
        }
    }

    private void applyMethodConfig() {
        ManagedChannelServiceConfig.MethodInfo methodInfo = (ManagedChannelServiceConfig.MethodInfo) this.callOptions.getOption(ManagedChannelServiceConfig.MethodInfo.KEY);
        if (methodInfo == null) {
            return;
        }
        if (methodInfo.timeoutNanos != null) {
            Deadline after = Deadline.after(methodInfo.timeoutNanos.longValue(), TimeUnit.NANOSECONDS);
            Deadline deadline = this.callOptions.getDeadline();
            if (deadline == null || after.compareTo(deadline) < 0) {
                this.callOptions = this.callOptions.withDeadline(after);
            }
        }
        if (methodInfo.waitForReady != null) {
            this.callOptions = methodInfo.waitForReady.booleanValue() ? this.callOptions.withWaitForReady() : this.callOptions.withoutWaitForReady();
        }
        if (methodInfo.maxInboundMessageSize != null) {
            Integer maxInboundMessageSize = this.callOptions.getMaxInboundMessageSize();
            if (maxInboundMessageSize != null) {
                this.callOptions = this.callOptions.withMaxInboundMessageSize(Math.min(maxInboundMessageSize.intValue(), methodInfo.maxInboundMessageSize.intValue()));
            } else {
                this.callOptions = this.callOptions.withMaxInboundMessageSize(methodInfo.maxInboundMessageSize.intValue());
            }
        }
        if (methodInfo.maxOutboundMessageSize != null) {
            Integer maxOutboundMessageSize = this.callOptions.getMaxOutboundMessageSize();
            if (maxOutboundMessageSize != null) {
                this.callOptions = this.callOptions.withMaxOutboundMessageSize(Math.min(maxOutboundMessageSize.intValue(), methodInfo.maxOutboundMessageSize.intValue()));
            } else {
                this.callOptions = this.callOptions.withMaxOutboundMessageSize(methodInfo.maxOutboundMessageSize.intValue());
            }
        }
    }

    private static void logIfContextNarrowedTimeout(Deadline deadline, Deadline deadline2, Deadline deadline3) {
        Logger logger = log;
        if (logger.isLoggable(Level.FINE) && deadline != null && deadline.equals(deadline2)) {
            StringBuilder sb = new StringBuilder(String.format("Call timeout set to '%d' ns, due to context deadline.", Long.valueOf(Math.max(0L, deadline.timeRemaining(TimeUnit.NANOSECONDS)))));
            if (deadline3 == null) {
                sb.append(" Explicit call timeout was not set.");
            } else {
                sb.append(String.format(" Explicit call timeout was '%d' ns.", Long.valueOf(deadline3.timeRemaining(TimeUnit.NANOSECONDS))));
            }
            logger.fine(sb.toString());
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void removeContextListenerAndCancelDeadlineFuture() {
        this.context.removeListener(this.cancellationListener);
        ScheduledFuture<?> scheduledFuture = this.deadlineCancellationFuture;
        if (scheduledFuture != null) {
            scheduledFuture.cancel(false);
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public class DeadlineTimer implements Runnable {
        private final long remainingNanos;
        final ClientCallImpl this$0;

        DeadlineTimer(ClientCallImpl clientCallImpl, long j) {
            this.this$0 = clientCallImpl;
            this.remainingNanos = j;
        }

        @Override // java.lang.Runnable
        public void run() {
            InsightBuilder insightBuilder = new InsightBuilder();
            this.this$0.stream.appendTimeoutInsight(insightBuilder);
            long abs = Math.abs(this.remainingNanos) / TimeUnit.SECONDS.toNanos(1L);
            long abs2 = Math.abs(this.remainingNanos);
            long nanos = TimeUnit.SECONDS.toNanos(1L);
            StringBuilder sb = new StringBuilder("deadline exceeded after ");
            if (this.remainingNanos < 0) {
                sb.append('-');
            }
            sb.append(abs);
            sb.append(String.format(Locale.US, ".%09d", Long.valueOf(abs2 % nanos)));
            sb.append("s. ");
            sb.append(insightBuilder);
            this.this$0.stream.cancel(Status.DEADLINE_EXCEEDED.augmentDescription(sb.toString()));
        }
    }

    private ScheduledFuture<?> startDeadlineTimer(Deadline deadline) {
        long timeRemaining = deadline.timeRemaining(TimeUnit.NANOSECONDS);
        return this.deadlineCancellationExecutor.schedule(new LogExceptionRunnable(new DeadlineTimer(this, timeRemaining)), timeRemaining, TimeUnit.NANOSECONDS);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public Deadline effectiveDeadline() {
        return min(this.callOptions.getDeadline(), this.context.getDeadline());
    }

    private static Deadline min(Deadline deadline, Deadline deadline2) {
        return deadline == null ? deadline2 : deadline2 == null ? deadline : deadline.minimum(deadline2);
    }

    @Override // io.grpc.ClientCall
    public final void request(int i) {
        C13115fRJ.g();
        try {
            boolean z = true;
            Preconditions.checkState(this.stream != null, "Not started");
            if (i < 0) {
                z = false;
            }
            Preconditions.checkArgument(z, "Number requested must be non-negative");
            this.stream.request(i);
        } finally {
            C13115fRJ.i();
        }
    }

    @Override // io.grpc.ClientCall
    public final void cancel(String str, Throwable th) {
        C13115fRJ.g();
        try {
            cancelInternal(str, th);
        } finally {
            C13115fRJ.i();
        }
    }

    private void cancelInternal(String str, Throwable th) {
        Status withDescription;
        if (str == null && th == null) {
            th = new CancellationException("Cancelled without a message or cause");
            log.log(Level.WARNING, "Cancelling without a message or cause is suboptimal", th);
        }
        if (this.cancelCalled) {
            return;
        }
        this.cancelCalled = true;
        try {
            if (this.stream != null) {
                Status status = Status.CANCELLED;
                if (str != null) {
                    withDescription = status.withDescription(str);
                } else {
                    withDescription = status.withDescription("Call cancelled without message");
                }
                if (th != null) {
                    withDescription = withDescription.withCause(th);
                }
                this.stream.cancel(withDescription);
            }
        } finally {
            removeContextListenerAndCancelDeadlineFuture();
        }
    }

    @Override // io.grpc.ClientCall
    public final void halfClose() {
        C13115fRJ.g();
        try {
            halfCloseInternal();
        } finally {
            C13115fRJ.i();
        }
    }

    private void halfCloseInternal() {
        Preconditions.checkState(this.stream != null, "Not started");
        Preconditions.checkState(!this.cancelCalled, "call was cancelled");
        Preconditions.checkState(!this.halfCloseCalled, "call already half-closed");
        this.halfCloseCalled = true;
        this.stream.halfClose();
    }

    @Override // io.grpc.ClientCall
    public final void sendMessage(ReqT reqt) {
        C13115fRJ.g();
        try {
            sendMessageInternal(reqt);
        } finally {
            C13115fRJ.i();
        }
    }

    private void sendMessageInternal(ReqT reqt) {
        Preconditions.checkState(this.stream != null, "Not started");
        Preconditions.checkState(!this.cancelCalled, "call was cancelled");
        Preconditions.checkState(!this.halfCloseCalled, "call was half-closed");
        try {
            ClientStream clientStream = this.stream;
            if (clientStream instanceof RetriableStream) {
                ((RetriableStream) clientStream).sendMessage(reqt);
            } else {
                clientStream.writeMessage(this.method.streamRequest(reqt));
            }
            if (this.unaryRequest) {
                return;
            }
            this.stream.flush();
        } catch (Error e) {
            this.stream.cancel(Status.CANCELLED.withDescription("Client sendMessage() failed with Error"));
            throw e;
        } catch (RuntimeException e2) {
            this.stream.cancel(Status.CANCELLED.withCause(e2).withDescription("Failed to stream message"));
        }
    }

    @Override // io.grpc.ClientCall
    public final void setMessageCompression(boolean z) {
        Preconditions.checkState(this.stream != null, "Not started");
        this.stream.setMessageCompression(z);
    }

    @Override // io.grpc.ClientCall
    public final boolean isReady() {
        if (this.halfCloseCalled) {
            return false;
        }
        return this.stream.isReady();
    }

    @Override // io.grpc.ClientCall
    public final Attributes getAttributes() {
        ClientStream clientStream = this.stream;
        if (clientStream != null) {
            return clientStream.getAttributes();
        }
        return Attributes.EMPTY;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void closeObserver(ClientCall.Listener<RespT> listener, Status status, Metadata metadata) {
        listener.onClose(status, metadata);
    }

    public final String toString() {
        return MoreObjects.toStringHelper(this).add("method", this.method).toString();
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public class ClientStreamListenerImpl implements ClientStreamListener {
        private Status exceptionStatus;
        private final ClientCall.Listener<RespT> observer;
        final ClientCallImpl this$0;

        public ClientStreamListenerImpl(ClientCallImpl clientCallImpl, ClientCall.Listener<RespT> listener) {
            this.this$0 = clientCallImpl;
            this.observer = (ClientCall.Listener) Preconditions.checkNotNull(listener, "observer");
        }

        /* JADX INFO: Access modifiers changed from: private */
        public void exceptionThrown(Status status) {
            this.exceptionStatus = status;
            this.this$0.stream.cancel(status);
        }

        @Override // io.grpc.internal.ClientStreamListener
        public void headersRead(Metadata metadata) {
            fRN unused = this.this$0.tag;
            C13115fRJ.g();
            try {
                this.this$0.callExecutor.execute(new ContextRunnable(this, C13115fRJ.h(), metadata) { // from class: io.grpc.internal.ClientCallImpl.ClientStreamListenerImpl.1HeadersRead
                    final ClientStreamListenerImpl this$1;
                    final Metadata val$headers;
                    final C13116fRL val$link;

                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                    {
                        super(this.this$0.context);
                        this.this$1 = this;
                        this.val$link = r2;
                        this.val$headers = metadata;
                    }

                    @Override // io.grpc.internal.ContextRunnable
                    public final void runInContext() {
                        fRN unused2 = this.this$1.this$0.tag;
                        C13115fRJ.g();
                        C13115fRJ.e();
                        try {
                            runInternal();
                        } finally {
                            fRN unused3 = this.this$1.this$0.tag;
                            C13115fRJ.i();
                        }
                    }

                    private void runInternal() {
                        if (this.this$1.exceptionStatus != null) {
                            return;
                        }
                        try {
                            this.this$1.observer.onHeaders(this.val$headers);
                        } catch (Throwable th) {
                            this.this$1.exceptionThrown(Status.CANCELLED.withCause(th).withDescription("Failed to read headers"));
                        }
                    }
                });
            } finally {
                fRN unused2 = this.this$0.tag;
                C13115fRJ.i();
            }
        }

        @Override // io.grpc.internal.StreamListener
        public void messagesAvailable(StreamListener.MessageProducer messageProducer) {
            fRN unused = this.this$0.tag;
            C13115fRJ.g();
            try {
                this.this$0.callExecutor.execute(new ContextRunnable(this, C13115fRJ.h(), messageProducer) { // from class: io.grpc.internal.ClientCallImpl.ClientStreamListenerImpl.1MessagesAvailable
                    final ClientStreamListenerImpl this$1;
                    final C13116fRL val$link;
                    final StreamListener.MessageProducer val$producer;

                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                    {
                        super(this.this$0.context);
                        this.this$1 = this;
                        this.val$link = r2;
                        this.val$producer = messageProducer;
                    }

                    @Override // io.grpc.internal.ContextRunnable
                    public final void runInContext() {
                        fRN unused2 = this.this$1.this$0.tag;
                        C13115fRJ.g();
                        C13115fRJ.e();
                        try {
                            runInternal();
                        } finally {
                            fRN unused3 = this.this$1.this$0.tag;
                            C13115fRJ.i();
                        }
                    }

                    private void runInternal() {
                        if (this.this$1.exceptionStatus != null) {
                            GrpcUtil.closeQuietly(this.val$producer);
                            return;
                        }
                        while (true) {
                            try {
                                InputStream next = this.val$producer.next();
                                if (next == null) {
                                    return;
                                }
                                try {
                                    this.this$1.observer.onMessage(this.this$1.this$0.method.parseResponse(next));
                                    next.close();
                                } catch (Throwable th) {
                                    GrpcUtil.closeQuietly(next);
                                    throw th;
                                }
                            } catch (Throwable th2) {
                                GrpcUtil.closeQuietly(this.val$producer);
                                this.this$1.exceptionThrown(Status.CANCELLED.withCause(th2).withDescription("Failed to read message."));
                                return;
                            }
                        }
                    }
                });
            } finally {
                fRN unused2 = this.this$0.tag;
                C13115fRJ.i();
            }
        }

        @Override // io.grpc.internal.ClientStreamListener
        public void closed(Status status, ClientStreamListener.RpcProgress rpcProgress, Metadata metadata) {
            fRN unused = this.this$0.tag;
            C13115fRJ.g();
            try {
                closedInternal(status, rpcProgress, metadata);
            } finally {
                fRN unused2 = this.this$0.tag;
                C13115fRJ.i();
            }
        }

        private void closedInternal(Status status, ClientStreamListener.RpcProgress rpcProgress, Metadata metadata) {
            Deadline effectiveDeadline = this.this$0.effectiveDeadline();
            if (status.getCode() == Status.Code.CANCELLED && effectiveDeadline != null && effectiveDeadline.isExpired()) {
                InsightBuilder insightBuilder = new InsightBuilder();
                this.this$0.stream.appendTimeoutInsight(insightBuilder);
                status = Status.DEADLINE_EXCEEDED.augmentDescription("ClientCall was cancelled at or after deadline. ".concat(String.valueOf(insightBuilder)));
                metadata = new Metadata();
            }
            this.this$0.callExecutor.execute(new ContextRunnable(this, C13115fRJ.h(), status, metadata) { // from class: io.grpc.internal.ClientCallImpl.ClientStreamListenerImpl.1StreamClosed
                final ClientStreamListenerImpl this$1;
                final C13116fRL val$link;
                final Status val$savedStatus;
                final Metadata val$savedTrailers;

                /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                {
                    super(this.this$0.context);
                    this.this$1 = this;
                    this.val$link = r2;
                    this.val$savedStatus = status;
                    this.val$savedTrailers = metadata;
                }

                @Override // io.grpc.internal.ContextRunnable
                public final void runInContext() {
                    fRN unused = this.this$1.this$0.tag;
                    C13115fRJ.g();
                    C13115fRJ.e();
                    try {
                        runInternal();
                    } finally {
                        fRN unused2 = this.this$1.this$0.tag;
                        C13115fRJ.i();
                    }
                }

                private void runInternal() {
                    Status status2 = this.val$savedStatus;
                    Metadata metadata2 = this.val$savedTrailers;
                    if (this.this$1.exceptionStatus != null) {
                        status2 = this.this$1.exceptionStatus;
                        metadata2 = new Metadata();
                    }
                    this.this$1.this$0.cancelListenersShouldBeRemoved = true;
                    try {
                        this.this$1.this$0.closeObserver(this.this$1.observer, status2, metadata2);
                    } finally {
                        this.this$1.this$0.removeContextListenerAndCancelDeadlineFuture();
                        this.this$1.this$0.channelCallsTracer.reportCallEnded(status2.isOk());
                    }
                }
            });
        }

        @Override // io.grpc.internal.StreamListener
        public void onReady() {
            if (this.this$0.method.getType().clientSendsOneMessage()) {
                return;
            }
            fRN unused = this.this$0.tag;
            C13115fRJ.g();
            try {
                this.this$0.callExecutor.execute(new ContextRunnable(this, C13115fRJ.h()) { // from class: io.grpc.internal.ClientCallImpl.ClientStreamListenerImpl.1StreamOnReady
                    final ClientStreamListenerImpl this$1;
                    final C13116fRL val$link;

                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                    {
                        super(this.this$0.context);
                        this.this$1 = this;
                        this.val$link = r2;
                    }

                    @Override // io.grpc.internal.ContextRunnable
                    public final void runInContext() {
                        fRN unused2 = this.this$1.this$0.tag;
                        C13115fRJ.g();
                        C13115fRJ.e();
                        try {
                            runInternal();
                        } finally {
                            fRN unused3 = this.this$1.this$0.tag;
                            C13115fRJ.i();
                        }
                    }

                    private void runInternal() {
                        if (this.this$1.exceptionStatus != null) {
                            return;
                        }
                        try {
                            this.this$1.observer.onReady();
                        } catch (Throwable th) {
                            this.this$1.exceptionThrown(Status.CANCELLED.withCause(th).withDescription("Failed to call onReady."));
                        }
                    }
                });
            } finally {
                fRN unused2 = this.this$0.tag;
                C13115fRJ.i();
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public final ClientCallImpl<ReqT, RespT> setFullStreamDecompression(boolean z) {
        this.fullStreamDecompression = z;
        return this;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public final ClientCallImpl<ReqT, RespT> setDecompressorRegistry(DecompressorRegistry decompressorRegistry) {
        this.decompressorRegistry = decompressorRegistry;
        return this;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public final ClientCallImpl<ReqT, RespT> setCompressorRegistry(CompressorRegistry compressorRegistry) {
        this.compressorRegistry = compressorRegistry;
        return this;
    }
}