package io.grpc.internal;

import com.google.common.base.MoreObjects;
import com.google.common.base.Preconditions;
import com.google.common.base.Stopwatch;
import com.google.common.base.Supplier;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import io.grpc.Attributes;
import io.grpc.CallCredentials;
import io.grpc.CallOptions;
import io.grpc.Channel;
import io.grpc.ChannelCredentials;
import io.grpc.ChannelLogger;
import io.grpc.ClientCall;
import io.grpc.ClientInterceptor;
import io.grpc.ClientInterceptors;
import io.grpc.ClientStreamTracer;
import io.grpc.CompressorRegistry;
import io.grpc.ConnectivityState;
import io.grpc.ConnectivityStateInfo;
import io.grpc.Context;
import io.grpc.DecompressorRegistry;
import io.grpc.EquivalentAddressGroup;
import io.grpc.ForwardingChannelBuilder;
import io.grpc.ForwardingClientCall;
import io.grpc.Grpc;
import io.grpc.InternalChannelz;
import io.grpc.InternalConfigSelector;
import io.grpc.InternalInstrumented;
import io.grpc.InternalLogId;
import io.grpc.LoadBalancer;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.Metadata;
import io.grpc.MethodDescriptor;
import io.grpc.NameResolver;
import io.grpc.NameResolverRegistry;
import io.grpc.ProxyDetector;
import io.grpc.Status;
import io.grpc.SynchronizationContext;
import io.grpc.internal.AutoConfiguredLoadBalancerFactory;
import io.grpc.internal.BackoffPolicy;
import io.grpc.internal.CallTracer;
import io.grpc.internal.ClientCallImpl;
import io.grpc.internal.ClientTransportFactory;
import io.grpc.internal.InternalSubchannel;
import io.grpc.internal.ManagedChannelImplBuilder;
import io.grpc.internal.ManagedChannelServiceConfig;
import io.grpc.internal.ManagedClientTransport;
import io.grpc.internal.RetriableStream;
import java.lang.Thread;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;

/* JADX INFO: Access modifiers changed from: package-private */
/* loaded from: classes6.dex */
public final class ManagedChannelImpl extends ManagedChannel implements InternalInstrumented<InternalChannelz.ChannelStats> {
    static final long IDLE_TIMEOUT_MILLIS_DISABLE = -1;
    static final long SUBCHANNEL_SHUTDOWN_DELAY_SECONDS = 5;
    private final String authorityOverride;
    private final BackoffPolicy.Provider backoffPolicyProvider;
    private final ExecutorHolder balancerRpcExecutorHolder;
    private final ObjectPool<? extends Executor> balancerRpcExecutorPool;
    private final CallTracer.Factory callTracerFactory;
    private final long channelBufferLimit;
    private final RetriableStream.ChannelBufferMeter channelBufferUsed;
    private final CallTracer channelCallTracer;
    private final ChannelLogger channelLogger;
    private final ConnectivityStateManager channelStateManager;
    private final ChannelTracer channelTracer;
    private final InternalChannelz channelz;
    private final CompressorRegistry compressorRegistry;
    private final DecompressorRegistry decompressorRegistry;
    private final ManagedChannelServiceConfig defaultServiceConfig;
    private final DelayedClientTransport delayedTransport;
    private final ManagedClientTransport.Listener delayedTransportListener;
    private final Executor executor;
    private final ObjectPool<? extends Executor> executorPool;
    private boolean fullStreamDecompression;
    private final long idleTimeoutMillis;
    private final Rescheduler idleTimer;
    final InUseStateAggregator<Object> inUseStateAggregator;
    private final Channel interceptorChannel;
    private ResolutionState lastResolutionState;
    private ManagedChannelServiceConfig lastServiceConfig;
    private LbHelperImpl lbHelper;
    private final AutoConfiguredLoadBalancerFactory loadBalancerFactory;
    private final InternalLogId logId;
    private final boolean lookUpServiceConfig;
    private final int maxTraceEvents;
    private NameResolver nameResolver;
    private final NameResolver.Args nameResolverArgs;
    private BackoffPolicy nameResolverBackoffPolicy;
    private final NameResolver.Factory nameResolverFactory;
    private final NameResolverRegistry nameResolverRegistry;
    private boolean nameResolverStarted;
    private final ExecutorHolder offloadExecutorHolder;
    private final Set<OobChannel> oobChannels;
    private final ClientTransportFactory oobTransportFactory;
    private final ChannelCredentials originalChannelCreds;
    private final ClientTransportFactory originalTransportFactory;
    private boolean panicMode;
    private Collection<RealChannel.PendingCall<?, ?>> pendingCalls;
    private final Object pendingCallsInUseObject;
    private final long perRpcBufferLimit;
    private final RealChannel realChannel;
    private final boolean retryEnabled;
    private final RestrictedScheduledExecutor scheduledExecutor;
    private SynchronizationContext.ScheduledHandle scheduledNameResolverRefresh;
    private boolean serviceConfigUpdated;
    private final AtomicBoolean shutdown;
    private boolean shutdownNowed;
    private final Supplier<Stopwatch> stopwatchSupplier;
    private volatile LoadBalancer.SubchannelPicker subchannelPicker;
    private final Set<InternalSubchannel> subchannels;
    final SynchronizationContext syncContext;
    private final String target;
    private volatile boolean terminated;
    private final CountDownLatch terminatedLatch;
    private boolean terminating;
    private final TimeProvider timeProvider;
    private final ClientTransportFactory transportFactory;
    private final ClientCallImpl.ClientStreamProvider transportProvider;
    private final UncommittedRetriableStreamsRegistry uncommittedRetriableStreamsRegistry;
    private final String userAgent;
    static final Logger logger = Logger.getLogger(ManagedChannelImpl.class.getName());
    static final Pattern URI_PATTERN = Pattern.compile("[a-zA-Z][a-zA-Z0-9+.-]*:/.*");
    static final Status SHUTDOWN_NOW_STATUS = Status.UNAVAILABLE.withDescription("Channel shutdownNow invoked");
    static final Status SHUTDOWN_STATUS = Status.UNAVAILABLE.withDescription("Channel shutdown invoked");
    static final Status SUBCHANNEL_SHUTDOWN_STATUS = Status.UNAVAILABLE.withDescription("Subchannel shutdown invoked");
    private static final ManagedChannelServiceConfig EMPTY_SERVICE_CONFIG = ManagedChannelServiceConfig.empty();
    private static final InternalConfigSelector INITIAL_PENDING_SELECTOR = new InternalConfigSelector() { // from class: io.grpc.internal.ManagedChannelImpl.1
        @Override // io.grpc.InternalConfigSelector
        public InternalConfigSelector.Result selectConfig(LoadBalancer.PickSubchannelArgs pickSubchannelArgs) {
            throw new IllegalStateException("Resolution is pending");
        }
    };
    private static final ClientCall<Object, Object> NOOP_CALL = new ClientCall<Object, Object>() { // from class: io.grpc.internal.ManagedChannelImpl.5
        @Override // io.grpc.ClientCall
        public void cancel(String str, Throwable th) {
        }

        @Override // io.grpc.ClientCall
        public void halfClose() {
        }

        @Override // io.grpc.ClientCall
        public boolean isReady() {
            return false;
        }

        @Override // io.grpc.ClientCall
        public void request(int i) {
        }

        @Override // io.grpc.ClientCall
        public void sendMessage(Object obj) {
        }

        @Override // io.grpc.ClientCall
        public void start(ClientCall.Listener<Object> listener, Metadata metadata) {
        }
    };

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public enum ResolutionState {
        NO_RESOLUTION,
        SUCCESS,
        ERROR
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void maybeShutdownNowSubchannels() {
        if (this.shutdownNowed) {
            Iterator<InternalSubchannel> it = this.subchannels.iterator();
            while (it.hasNext()) {
                it.next().shutdownNow(SHUTDOWN_NOW_STATUS);
            }
            Iterator<OobChannel> it2 = this.oobChannels.iterator();
            while (it2.hasNext()) {
                it2.next().getInternalSubchannel().shutdownNow(SHUTDOWN_NOW_STATUS);
            }
        }
    }

    @Override // io.grpc.InternalInstrumented
    public final ListenableFuture<InternalChannelz.ChannelStats> getStats() {
        SettableFuture create = SettableFuture.create();
        this.syncContext.execute(new Runnable(this, create) { // from class: io.grpc.internal.ManagedChannelImpl.1StatsFetcher
            final ManagedChannelImpl this$0;
            final SettableFuture val$ret;

            {
                this.this$0 = this;
                this.val$ret = create;
            }

            @Override // java.lang.Runnable
            public final void run() {
                InternalChannelz.ChannelStats.Builder builder = new InternalChannelz.ChannelStats.Builder();
                this.this$0.channelCallTracer.updateBuilder(builder);
                this.this$0.channelTracer.updateBuilder(builder);
                builder.setTarget(this.this$0.target).setState(this.this$0.channelStateManager.getState());
                ArrayList arrayList = new ArrayList();
                arrayList.addAll(this.this$0.subchannels);
                arrayList.addAll(this.this$0.oobChannels);
                builder.setSubchannels(arrayList);
                this.val$ret.set(builder.build());
            }
        });
        return create;
    }

    /* loaded from: classes6.dex */
    class IdleModeTimer implements Runnable {
        final ManagedChannelImpl this$0;

        private IdleModeTimer(ManagedChannelImpl managedChannelImpl) {
            this.this$0 = managedChannelImpl;
        }

        @Override // java.lang.Runnable
        public void run() {
            if (this.this$0.lbHelper == null) {
                return;
            }
            this.this$0.enterIdleMode();
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void shutdownNameResolverAndLoadBalancer(boolean z) {
        this.syncContext.throwIfNotInThisSynchronizationContext();
        if (z) {
            Preconditions.checkState(this.nameResolverStarted, "nameResolver is not started");
            Preconditions.checkState(this.lbHelper != null, "lbHelper is null");
        }
        if (this.nameResolver != null) {
            cancelNameResolverBackoff();
            this.nameResolver.shutdown();
            this.nameResolverStarted = false;
            if (z) {
                this.nameResolver = getNameResolver(this.target, this.authorityOverride, this.nameResolverFactory, this.nameResolverArgs);
            } else {
                this.nameResolver = null;
            }
        }
        LbHelperImpl lbHelperImpl = this.lbHelper;
        if (lbHelperImpl != null) {
            lbHelperImpl.lb.shutdown();
            this.lbHelper = null;
        }
        this.subchannelPicker = null;
    }

    final void exitIdleMode() {
        this.syncContext.throwIfNotInThisSynchronizationContext();
        if (this.shutdown.get() || this.panicMode) {
            return;
        }
        if (this.inUseStateAggregator.isInUse()) {
            cancelIdleTimer(false);
        } else {
            rescheduleIdleTimer();
        }
        if (this.lbHelper != null) {
            return;
        }
        this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Exiting idle mode");
        LbHelperImpl lbHelperImpl = new LbHelperImpl();
        lbHelperImpl.lb = this.loadBalancerFactory.newLoadBalancer(lbHelperImpl);
        this.lbHelper = lbHelperImpl;
        this.nameResolver.start((NameResolver.Listener2) new NameResolverListener(this, lbHelperImpl, this.nameResolver));
        this.nameResolverStarted = true;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void enterIdleMode() {
        shutdownNameResolverAndLoadBalancer(true);
        this.delayedTransport.reprocess(null);
        this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Entering IDLE state");
        this.channelStateManager.gotoState(ConnectivityState.IDLE);
        if (this.inUseStateAggregator.anyObjectInUse(this.pendingCallsInUseObject, this.delayedTransport)) {
            exitIdleMode();
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void cancelIdleTimer(boolean z) {
        this.idleTimer.cancel(z);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void rescheduleIdleTimer() {
        long j = this.idleTimeoutMillis;
        if (j == -1) {
            return;
        }
        this.idleTimer.reschedule(j, TimeUnit.MILLISECONDS);
    }

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

        DelayedNameResolverRefresh(ManagedChannelImpl managedChannelImpl) {
            this.this$0 = managedChannelImpl;
        }

        @Override // java.lang.Runnable
        public void run() {
            this.this$0.scheduledNameResolverRefresh = null;
            this.this$0.refreshNameResolution();
        }
    }

    private void cancelNameResolverBackoff() {
        this.syncContext.throwIfNotInThisSynchronizationContext();
        SynchronizationContext.ScheduledHandle scheduledHandle = this.scheduledNameResolverRefresh;
        if (scheduledHandle != null) {
            scheduledHandle.cancel();
            this.scheduledNameResolverRefresh = null;
            this.nameResolverBackoffPolicy = null;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void refreshAndResetNameResolution() {
        this.syncContext.throwIfNotInThisSynchronizationContext();
        cancelNameResolverBackoff();
        refreshNameResolution();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void refreshNameResolution() {
        this.syncContext.throwIfNotInThisSynchronizationContext();
        if (this.nameResolverStarted) {
            this.nameResolver.refresh();
        }
    }

    /* loaded from: classes6.dex */
    final class ChannelStreamProvider implements ClientCallImpl.ClientStreamProvider {
        final ManagedChannelImpl this$0;

        private ChannelStreamProvider(ManagedChannelImpl managedChannelImpl) {
            this.this$0 = managedChannelImpl;
        }

        /* JADX INFO: Access modifiers changed from: private */
        public ClientTransport getTransport(LoadBalancer.PickSubchannelArgs pickSubchannelArgs) {
            LoadBalancer.SubchannelPicker subchannelPicker = this.this$0.subchannelPicker;
            if (this.this$0.shutdown.get()) {
                return this.this$0.delayedTransport;
            }
            if (subchannelPicker == null) {
                this.this$0.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.ChannelStreamProvider.1ExitIdleModeForTransport
                    final ChannelStreamProvider this$1;

                    {
                        this.this$1 = this;
                    }

                    @Override // java.lang.Runnable
                    public final void run() {
                        this.this$1.this$0.exitIdleMode();
                    }
                });
                return this.this$0.delayedTransport;
            }
            ClientTransport transportFromPickResult = GrpcUtil.getTransportFromPickResult(subchannelPicker.pickSubchannel(pickSubchannelArgs), pickSubchannelArgs.getCallOptions().isWaitForReady());
            return transportFromPickResult != null ? transportFromPickResult : this.this$0.delayedTransport;
        }

        @Override // io.grpc.internal.ClientCallImpl.ClientStreamProvider
        public final ClientStream newStream(MethodDescriptor<?, ?> methodDescriptor, CallOptions callOptions, Metadata metadata, Context context) {
            if (this.this$0.retryEnabled) {
                RetriableStream.Throttle retryThrottling = this.this$0.lastServiceConfig.getRetryThrottling();
                ManagedChannelServiceConfig.MethodInfo methodInfo = (ManagedChannelServiceConfig.MethodInfo) callOptions.getOption(ManagedChannelServiceConfig.MethodInfo.KEY);
                return new RetriableStream<ReqT>(this, methodDescriptor, metadata, callOptions, methodInfo == null ? null : methodInfo.retryPolicy, methodInfo == null ? null : methodInfo.hedgingPolicy, retryThrottling, context) { // from class: io.grpc.internal.ManagedChannelImpl.ChannelStreamProvider.1RetryStream
                    final ChannelStreamProvider this$1;
                    final CallOptions val$callOptions;
                    final Context val$context;
                    final Metadata val$headers;
                    final HedgingPolicy val$hedgingPolicy;
                    final MethodDescriptor val$method;
                    final RetryPolicy val$retryPolicy;
                    final RetriableStream.Throttle val$throttle;

                    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
                    {
                        super(methodDescriptor, metadata, this.this$0.channelBufferUsed, this.this$0.perRpcBufferLimit, this.this$0.channelBufferLimit, this.this$0.getCallExecutor(callOptions), this.this$0.transportFactory.getScheduledExecutorService(), r20, r21, retryThrottling);
                        this.this$1 = this;
                        this.val$method = methodDescriptor;
                        this.val$headers = metadata;
                        this.val$callOptions = callOptions;
                        this.val$retryPolicy = r20;
                        this.val$hedgingPolicy = r21;
                        this.val$throttle = retryThrottling;
                        this.val$context = context;
                    }

                    @Override // io.grpc.internal.RetriableStream
                    final Status prestart() {
                        return this.this$1.this$0.uncommittedRetriableStreamsRegistry.add(this);
                    }

                    @Override // io.grpc.internal.RetriableStream
                    final void postCommit() {
                        this.this$1.this$0.uncommittedRetriableStreamsRegistry.remove(this);
                    }

                    @Override // io.grpc.internal.RetriableStream
                    final ClientStream newSubstream(Metadata metadata2, ClientStreamTracer.Factory factory, int i, boolean z) {
                        CallOptions withStreamTracerFactory = this.val$callOptions.withStreamTracerFactory(factory);
                        ClientStreamTracer[] clientStreamTracers = GrpcUtil.getClientStreamTracers(withStreamTracerFactory, metadata2, i, z);
                        ClientTransport transport = this.this$1.getTransport(new PickSubchannelArgsImpl(this.val$method, metadata2, withStreamTracerFactory));
                        Context attach = this.val$context.attach();
                        try {
                            return transport.newStream(this.val$method, metadata2, withStreamTracerFactory, clientStreamTracers);
                        } finally {
                            this.val$context.detach(attach);
                        }
                    }
                };
            }
            ClientTransport transport = getTransport(new PickSubchannelArgsImpl(methodDescriptor, metadata, callOptions));
            Context attach = context.attach();
            try {
                return transport.newStream(methodDescriptor, metadata, callOptions, GrpcUtil.getClientStreamTracers(callOptions, metadata, 0, false));
            } finally {
                context.detach(attach);
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* JADX WARN: Multi-variable type inference failed */
    /* JADX WARN: Type inference failed for: r6v17, types: [io.grpc.Channel] */
    public ManagedChannelImpl(ManagedChannelImplBuilder managedChannelImplBuilder, ClientTransportFactory clientTransportFactory, BackoffPolicy.Provider provider, ObjectPool<? extends Executor> objectPool, Supplier<Stopwatch> supplier, List<ClientInterceptor> list, TimeProvider timeProvider) {
        AnonymousClass1 anonymousClass1;
        SynchronizationContext synchronizationContext = new SynchronizationContext(new Thread.UncaughtExceptionHandler(this) { // from class: io.grpc.internal.ManagedChannelImpl.2
            final ManagedChannelImpl this$0;

            {
                this.this$0 = this;
            }

            @Override // java.lang.Thread.UncaughtExceptionHandler
            public void uncaughtException(Thread thread, Throwable th) {
                Logger logger2 = ManagedChannelImpl.logger;
                Level level = Level.SEVERE;
                StringBuilder sb = new StringBuilder("[");
                sb.append(this.this$0.getLogId());
                sb.append("] Uncaught exception in the SynchronizationContext. Panic!");
                logger2.log(level, sb.toString(), th);
                this.this$0.panic(th);
            }
        });
        this.syncContext = synchronizationContext;
        this.channelStateManager = new ConnectivityStateManager();
        this.subchannels = new HashSet(16, 0.75f);
        this.pendingCallsInUseObject = new Object();
        this.oobChannels = new HashSet(1, 0.75f);
        this.uncommittedRetriableStreamsRegistry = new UncommittedRetriableStreamsRegistry();
        this.shutdown = new AtomicBoolean(false);
        this.terminatedLatch = new CountDownLatch(1);
        this.lastResolutionState = ResolutionState.NO_RESOLUTION;
        this.lastServiceConfig = EMPTY_SERVICE_CONFIG;
        this.serviceConfigUpdated = false;
        this.channelBufferUsed = new RetriableStream.ChannelBufferMeter();
        DelayedTransportListener delayedTransportListener = new DelayedTransportListener();
        this.delayedTransportListener = delayedTransportListener;
        this.inUseStateAggregator = new IdleModeStateAggregator();
        this.transportProvider = new ChannelStreamProvider();
        String str = (String) Preconditions.checkNotNull(managedChannelImplBuilder.target, "target");
        this.target = str;
        InternalLogId allocate = InternalLogId.allocate("Channel", str);
        this.logId = allocate;
        this.timeProvider = (TimeProvider) Preconditions.checkNotNull(timeProvider, "timeProvider");
        ObjectPool<? extends Executor> objectPool2 = (ObjectPool) Preconditions.checkNotNull(managedChannelImplBuilder.executorPool, "executorPool");
        this.executorPool = objectPool2;
        Executor executor = (Executor) Preconditions.checkNotNull(objectPool2.getObject(), "executor");
        this.executor = executor;
        this.originalChannelCreds = managedChannelImplBuilder.channelCredentials;
        this.originalTransportFactory = clientTransportFactory;
        CallCredentialsApplyingTransportFactory callCredentialsApplyingTransportFactory = new CallCredentialsApplyingTransportFactory(clientTransportFactory, managedChannelImplBuilder.callCredentials, executor);
        this.transportFactory = callCredentialsApplyingTransportFactory;
        this.oobTransportFactory = new CallCredentialsApplyingTransportFactory(clientTransportFactory, null, executor);
        RestrictedScheduledExecutor restrictedScheduledExecutor = new RestrictedScheduledExecutor(callCredentialsApplyingTransportFactory.getScheduledExecutorService());
        this.scheduledExecutor = restrictedScheduledExecutor;
        this.maxTraceEvents = managedChannelImplBuilder.maxTraceEvents;
        int i = managedChannelImplBuilder.maxTraceEvents;
        long currentTimeNanos = timeProvider.currentTimeNanos();
        StringBuilder sb = new StringBuilder("Channel for '");
        sb.append(str);
        sb.append("'");
        ChannelTracer channelTracer = new ChannelTracer(allocate, i, currentTimeNanos, sb.toString());
        this.channelTracer = channelTracer;
        ChannelLoggerImpl channelLoggerImpl = new ChannelLoggerImpl(channelTracer, timeProvider);
        this.channelLogger = channelLoggerImpl;
        ProxyDetector proxyDetector = managedChannelImplBuilder.proxyDetector != null ? managedChannelImplBuilder.proxyDetector : GrpcUtil.DEFAULT_PROXY_DETECTOR;
        boolean z = managedChannelImplBuilder.retryEnabled;
        this.retryEnabled = z;
        AutoConfiguredLoadBalancerFactory autoConfiguredLoadBalancerFactory = new AutoConfiguredLoadBalancerFactory(managedChannelImplBuilder.defaultLbPolicy);
        this.loadBalancerFactory = autoConfiguredLoadBalancerFactory;
        this.offloadExecutorHolder = new ExecutorHolder((ObjectPool) Preconditions.checkNotNull(managedChannelImplBuilder.offloadExecutorPool, "offloadExecutorPool"));
        this.nameResolverRegistry = managedChannelImplBuilder.nameResolverRegistry;
        ScParser scParser = new ScParser(z, managedChannelImplBuilder.maxRetryAttempts, managedChannelImplBuilder.maxHedgedAttempts, autoConfiguredLoadBalancerFactory);
        NameResolver.Args build = NameResolver.Args.newBuilder().setDefaultPort(managedChannelImplBuilder.getDefaultPort()).setProxyDetector(proxyDetector).setSynchronizationContext(synchronizationContext).setScheduledExecutorService(restrictedScheduledExecutor).setServiceConfigParser(scParser).setChannelLogger(channelLoggerImpl).setOffloadExecutor(new Executor(this) { // from class: io.grpc.internal.ManagedChannelImpl.3
            final ManagedChannelImpl this$0;

            {
                this.this$0 = this;
            }

            @Override // java.util.concurrent.Executor
            public void execute(Runnable runnable) {
                this.this$0.offloadExecutorHolder.getExecutor().execute(runnable);
            }
        }).build();
        this.nameResolverArgs = build;
        String str2 = managedChannelImplBuilder.authorityOverride;
        this.authorityOverride = str2;
        NameResolver.Factory factory = managedChannelImplBuilder.nameResolverFactory;
        this.nameResolverFactory = factory;
        this.nameResolver = getNameResolver(str, str2, factory, build);
        this.balancerRpcExecutorPool = (ObjectPool) Preconditions.checkNotNull(objectPool, "balancerRpcExecutorPool");
        this.balancerRpcExecutorHolder = new ExecutorHolder(objectPool);
        DelayedClientTransport delayedClientTransport = new DelayedClientTransport(executor, synchronizationContext);
        this.delayedTransport = delayedClientTransport;
        delayedClientTransport.start(delayedTransportListener);
        this.backoffPolicyProvider = provider;
        if (managedChannelImplBuilder.defaultServiceConfig != null) {
            NameResolver.ConfigOrError parseServiceConfig = scParser.parseServiceConfig(managedChannelImplBuilder.defaultServiceConfig);
            Preconditions.checkState(parseServiceConfig.getError() == null, "Default config is invalid: %s", parseServiceConfig.getError());
            ManagedChannelServiceConfig managedChannelServiceConfig = (ManagedChannelServiceConfig) parseServiceConfig.getConfig();
            this.defaultServiceConfig = managedChannelServiceConfig;
            this.lastServiceConfig = managedChannelServiceConfig;
            anonymousClass1 = null;
        } else {
            anonymousClass1 = null;
            this.defaultServiceConfig = null;
        }
        boolean z2 = managedChannelImplBuilder.lookUpServiceConfig;
        this.lookUpServiceConfig = z2;
        RealChannel realChannel = new RealChannel(this.nameResolver.getServiceAuthority());
        this.realChannel = realChannel;
        this.interceptorChannel = ClientInterceptors.intercept(managedChannelImplBuilder.binlog != null ? managedChannelImplBuilder.binlog.wrapChannel(realChannel) : realChannel, list);
        this.stopwatchSupplier = (Supplier) Preconditions.checkNotNull(supplier, "stopwatchSupplier");
        if (managedChannelImplBuilder.idleTimeoutMillis == -1) {
            this.idleTimeoutMillis = managedChannelImplBuilder.idleTimeoutMillis;
        } else {
            Preconditions.checkArgument(managedChannelImplBuilder.idleTimeoutMillis >= ManagedChannelImplBuilder.IDLE_MODE_MIN_TIMEOUT_MILLIS, "invalid idleTimeoutMillis %s", managedChannelImplBuilder.idleTimeoutMillis);
            this.idleTimeoutMillis = managedChannelImplBuilder.idleTimeoutMillis;
        }
        this.idleTimer = new Rescheduler(new IdleModeTimer(), synchronizationContext, callCredentialsApplyingTransportFactory.getScheduledExecutorService(), supplier.get());
        this.fullStreamDecompression = managedChannelImplBuilder.fullStreamDecompression;
        this.decompressorRegistry = (DecompressorRegistry) Preconditions.checkNotNull(managedChannelImplBuilder.decompressorRegistry, "decompressorRegistry");
        this.compressorRegistry = (CompressorRegistry) Preconditions.checkNotNull(managedChannelImplBuilder.compressorRegistry, "compressorRegistry");
        this.userAgent = managedChannelImplBuilder.userAgent;
        this.channelBufferLimit = managedChannelImplBuilder.retryBufferSize;
        this.perRpcBufferLimit = managedChannelImplBuilder.perRpcBufferLimit;
        CallTracer.Factory factory2 = new CallTracer.Factory(this, timeProvider) { // from class: io.grpc.internal.ManagedChannelImpl.1ChannelCallTracerFactory
            final ManagedChannelImpl this$0;
            final TimeProvider val$timeProvider;

            {
                this.this$0 = this;
                this.val$timeProvider = timeProvider;
            }

            @Override // io.grpc.internal.CallTracer.Factory
            public final CallTracer create() {
                return new CallTracer(this.val$timeProvider);
            }
        };
        this.callTracerFactory = factory2;
        this.channelCallTracer = factory2.create();
        InternalChannelz internalChannelz = (InternalChannelz) Preconditions.checkNotNull(managedChannelImplBuilder.channelz);
        this.channelz = internalChannelz;
        internalChannelz.addRootChannel(this);
        if (z2) {
            return;
        }
        if (this.defaultServiceConfig != null) {
            channelLoggerImpl.log(ChannelLogger.ChannelLogLevel.INFO, "Service config look-up disabled, using default service config");
        }
        this.serviceConfigUpdated = true;
    }

    private static NameResolver getNameResolver(String str, NameResolver.Factory factory, NameResolver.Args args) {
        URI uri;
        NameResolver newNameResolver;
        StringBuilder sb = new StringBuilder();
        try {
            uri = new URI(str);
        } catch (URISyntaxException e) {
            sb.append(e.getMessage());
            uri = null;
        }
        if (uri != null && (newNameResolver = factory.newNameResolver(uri, args)) != null) {
            return newNameResolver;
        }
        String str2 = "";
        if (!URI_PATTERN.matcher(str).matches()) {
            try {
                String defaultScheme = factory.getDefaultScheme();
                StringBuilder sb2 = new StringBuilder("/");
                sb2.append(str);
                NameResolver newNameResolver2 = factory.newNameResolver(new URI(defaultScheme, "", sb2.toString(), null), args);
                if (newNameResolver2 != null) {
                    return newNameResolver2;
                }
            } catch (URISyntaxException e2) {
                throw new IllegalArgumentException(e2);
            }
        }
        Object[] objArr = new Object[2];
        objArr[0] = str;
        if (sb.length() > 0) {
            StringBuilder sb3 = new StringBuilder(" (");
            sb3.append((Object) sb);
            sb3.append(")");
            str2 = sb3.toString();
        }
        objArr[1] = str2;
        throw new IllegalArgumentException(String.format("cannot find a NameResolver for %s%s", objArr));
    }

    static NameResolver getNameResolver(String str, String str2, NameResolver.Factory factory, NameResolver.Args args) {
        NameResolver nameResolver = getNameResolver(str, factory, args);
        return str2 == null ? nameResolver : new ForwardingNameResolver(nameResolver, str2) { // from class: io.grpc.internal.ManagedChannelImpl.4
            final String val$overrideAuthority;

            {
                this.val$overrideAuthority = str2;
            }

            @Override // io.grpc.internal.ForwardingNameResolver, io.grpc.NameResolver
            public String getServiceAuthority() {
                return this.val$overrideAuthority;
            }
        };
    }

    final InternalConfigSelector getConfigSelector() {
        return (InternalConfigSelector) this.realChannel.configSelector.get();
    }

    @Override // io.grpc.ManagedChannel
    public final ManagedChannelImpl shutdown() {
        this.channelLogger.log(ChannelLogger.ChannelLogLevel.DEBUG, "shutdown() called");
        if (!this.shutdown.compareAndSet(false, true)) {
            return this;
        }
        this.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.1Shutdown
            final ManagedChannelImpl this$0;

            {
                this.this$0 = this;
            }

            @Override // java.lang.Runnable
            public final void run() {
                this.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Entering SHUTDOWN state");
                this.this$0.channelStateManager.gotoState(ConnectivityState.SHUTDOWN);
            }
        });
        this.realChannel.shutdown();
        this.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.1CancelIdleTimer
            final ManagedChannelImpl this$0;

            {
                this.this$0 = this;
            }

            @Override // java.lang.Runnable
            public final void run() {
                this.this$0.cancelIdleTimer(true);
            }
        });
        return this;
    }

    @Override // io.grpc.ManagedChannel
    public final ManagedChannelImpl shutdownNow() {
        this.channelLogger.log(ChannelLogger.ChannelLogLevel.DEBUG, "shutdownNow() called");
        shutdown();
        this.realChannel.shutdownNow();
        this.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.1ShutdownNow
            final ManagedChannelImpl this$0;

            {
                this.this$0 = this;
            }

            @Override // java.lang.Runnable
            public final void run() {
                if (this.this$0.shutdownNowed) {
                    return;
                }
                this.this$0.shutdownNowed = true;
                this.this$0.maybeShutdownNowSubchannels();
            }
        });
        return this;
    }

    final void panic(Throwable th) {
        if (this.panicMode) {
            return;
        }
        this.panicMode = true;
        cancelIdleTimer(true);
        shutdownNameResolverAndLoadBalancer(false);
        updateSubchannelPicker(new LoadBalancer.SubchannelPicker(this, th) { // from class: io.grpc.internal.ManagedChannelImpl.1PanicSubchannelPicker
            private final LoadBalancer.PickResult panicPickResult;
            final ManagedChannelImpl this$0;
            final Throwable val$t;

            {
                this.this$0 = this;
                this.val$t = th;
                this.panicPickResult = LoadBalancer.PickResult.withDrop(Status.INTERNAL.withDescription("Panic! This is a bug!").withCause(th));
            }

            public final String toString() {
                return MoreObjects.toStringHelper((Class<?>) C1PanicSubchannelPicker.class).add("panicPickResult", this.panicPickResult).toString();
            }

            @Override // io.grpc.LoadBalancer.SubchannelPicker
            public final LoadBalancer.PickResult pickSubchannel(LoadBalancer.PickSubchannelArgs pickSubchannelArgs) {
                return this.panicPickResult;
            }
        });
        this.channelLogger.log(ChannelLogger.ChannelLogLevel.ERROR, "PANIC! Entering TRANSIENT_FAILURE");
        this.channelStateManager.gotoState(ConnectivityState.TRANSIENT_FAILURE);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void updateSubchannelPicker(LoadBalancer.SubchannelPicker subchannelPicker) {
        this.subchannelPicker = subchannelPicker;
        this.delayedTransport.reprocess(subchannelPicker);
    }

    @Override // io.grpc.ManagedChannel
    public final boolean isShutdown() {
        return this.shutdown.get();
    }

    @Override // io.grpc.ManagedChannel
    public final boolean awaitTermination(long j, TimeUnit timeUnit) throws InterruptedException {
        return this.terminatedLatch.await(j, timeUnit);
    }

    @Override // io.grpc.Channel
    public final <ReqT, RespT> ClientCall<ReqT, RespT> newCall(MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions) {
        return this.interceptorChannel.newCall(methodDescriptor, callOptions);
    }

    @Override // io.grpc.Channel
    public final String authority() {
        return this.interceptorChannel.authority();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public Executor getCallExecutor(CallOptions callOptions) {
        Executor executor = callOptions.getExecutor();
        return executor == null ? this.executor : executor;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public class RealChannel extends Channel {
        private final String authority;
        private final Channel clientCallImplChannel;
        private final AtomicReference<InternalConfigSelector> configSelector;
        final ManagedChannelImpl this$0;

        private RealChannel(ManagedChannelImpl managedChannelImpl, String str) {
            this.this$0 = managedChannelImpl;
            this.configSelector = new AtomicReference<>(ManagedChannelImpl.INITIAL_PENDING_SELECTOR);
            this.clientCallImplChannel = new Channel(this) { // from class: io.grpc.internal.ManagedChannelImpl.RealChannel.1
                final RealChannel this$1;

                {
                    this.this$1 = this;
                }

                @Override // io.grpc.Channel
                public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
                    return new ClientCallImpl(methodDescriptor, this.this$1.this$0.getCallExecutor(callOptions), callOptions, this.this$1.this$0.transportProvider, this.this$1.this$0.terminated ? null : this.this$1.this$0.transportFactory.getScheduledExecutorService(), this.this$1.this$0.channelCallTracer, null).setFullStreamDecompression(this.this$1.this$0.fullStreamDecompression).setDecompressorRegistry(this.this$1.this$0.decompressorRegistry).setCompressorRegistry(this.this$1.this$0.compressorRegistry);
                }

                @Override // io.grpc.Channel
                public String authority() {
                    return this.this$1.authority;
                }
            };
            this.authority = (String) Preconditions.checkNotNull(str, "authority");
        }

        @Override // io.grpc.Channel
        public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions) {
            if (this.configSelector.get() != ManagedChannelImpl.INITIAL_PENDING_SELECTOR) {
                return newClientCall(methodDescriptor, callOptions);
            }
            this.this$0.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.RealChannel.2
                final RealChannel this$1;

                {
                    this.this$1 = this;
                }

                @Override // java.lang.Runnable
                public void run() {
                    this.this$1.this$0.exitIdleMode();
                }
            });
            if (this.configSelector.get() == ManagedChannelImpl.INITIAL_PENDING_SELECTOR) {
                if (this.this$0.shutdown.get()) {
                    return new ClientCall<ReqT, RespT>(this) { // from class: io.grpc.internal.ManagedChannelImpl.RealChannel.3
                        final RealChannel this$1;

                        @Override // io.grpc.ClientCall
                        public void cancel(String str, Throwable th) {
                        }

                        @Override // io.grpc.ClientCall
                        public void halfClose() {
                        }

                        @Override // io.grpc.ClientCall
                        public void request(int i) {
                        }

                        @Override // io.grpc.ClientCall
                        public void sendMessage(ReqT reqt) {
                        }

                        {
                            this.this$1 = this;
                        }

                        @Override // io.grpc.ClientCall
                        public void start(ClientCall.Listener<RespT> listener, Metadata metadata) {
                            listener.onClose(ManagedChannelImpl.SHUTDOWN_STATUS, new Metadata());
                        }
                    };
                }
                PendingCall pendingCall = new PendingCall(this, Context.current(), methodDescriptor, callOptions);
                this.this$0.syncContext.execute(new Runnable(this, pendingCall) { // from class: io.grpc.internal.ManagedChannelImpl.RealChannel.4
                    final RealChannel this$1;
                    final PendingCall val$pendingCall;

                    {
                        this.this$1 = this;
                        this.val$pendingCall = pendingCall;
                    }

                    @Override // java.lang.Runnable
                    public void run() {
                        if (this.this$1.configSelector.get() == ManagedChannelImpl.INITIAL_PENDING_SELECTOR) {
                            if (this.this$1.this$0.pendingCalls == null) {
                                this.this$1.this$0.pendingCalls = new LinkedHashSet();
                                this.this$1.this$0.inUseStateAggregator.updateObjectInUse(this.this$1.this$0.pendingCallsInUseObject, true);
                            }
                            this.this$1.this$0.pendingCalls.add(this.val$pendingCall);
                            return;
                        }
                        this.val$pendingCall.reprocess();
                    }
                });
                return pendingCall;
            }
            return newClientCall(methodDescriptor, callOptions);
        }

        void updateConfigSelector(InternalConfigSelector internalConfigSelector) {
            InternalConfigSelector internalConfigSelector2 = this.configSelector.get();
            this.configSelector.set(internalConfigSelector);
            if (internalConfigSelector2 != ManagedChannelImpl.INITIAL_PENDING_SELECTOR || this.this$0.pendingCalls == null) {
                return;
            }
            Iterator it = this.this$0.pendingCalls.iterator();
            while (it.hasNext()) {
                ((PendingCall) it.next()).reprocess();
            }
        }

        void onConfigError() {
            if (this.configSelector.get() == ManagedChannelImpl.INITIAL_PENDING_SELECTOR) {
                updateConfigSelector(null);
            }
        }

        void shutdown() {
            this.this$0.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.RealChannel.1RealChannelShutdown
                final RealChannel this$1;

                {
                    this.this$1 = this;
                }

                @Override // java.lang.Runnable
                public final void run() {
                    if (this.this$1.this$0.pendingCalls == null) {
                        if (this.this$1.configSelector.get() == ManagedChannelImpl.INITIAL_PENDING_SELECTOR) {
                            this.this$1.configSelector.set(null);
                        }
                        this.this$1.this$0.uncommittedRetriableStreamsRegistry.onShutdown(ManagedChannelImpl.SHUTDOWN_STATUS);
                    }
                }
            });
        }

        void shutdownNow() {
            this.this$0.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.RealChannel.1RealChannelShutdownNow
                final RealChannel this$1;

                {
                    this.this$1 = this;
                }

                @Override // java.lang.Runnable
                public final void run() {
                    if (this.this$1.configSelector.get() == ManagedChannelImpl.INITIAL_PENDING_SELECTOR) {
                        this.this$1.configSelector.set(null);
                    }
                    if (this.this$1.this$0.pendingCalls != null) {
                        Iterator it = this.this$1.this$0.pendingCalls.iterator();
                        while (it.hasNext()) {
                            ((PendingCall) it.next()).cancel("Channel is forcefully shutdown", (Throwable) null);
                        }
                    }
                    this.this$1.this$0.uncommittedRetriableStreamsRegistry.onShutdownNow(ManagedChannelImpl.SHUTDOWN_NOW_STATUS);
                }
            });
        }

        /* JADX INFO: Access modifiers changed from: package-private */
        /* loaded from: classes6.dex */
        public final class PendingCall<ReqT, RespT> extends DelayedClientCall<ReqT, RespT> {
            final CallOptions callOptions;
            final Context context;
            final MethodDescriptor<ReqT, RespT> method;
            final RealChannel this$1;

            /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
            PendingCall(RealChannel realChannel, Context context, MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions) {
                super(realChannel.this$0.getCallExecutor(callOptions), realChannel.this$0.scheduledExecutor, callOptions.getDeadline());
                this.this$1 = realChannel;
                this.context = context;
                this.method = methodDescriptor;
                this.callOptions = callOptions;
            }

            final void reprocess() {
                this.this$1.this$0.getCallExecutor(this.callOptions).execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.RealChannel.PendingCall.1
                    final PendingCall this$2;

                    {
                        this.this$2 = this;
                    }

                    @Override // java.lang.Runnable
                    public void run() {
                        Context attach = this.this$2.context.attach();
                        try {
                            ClientCall<ReqT, RespT> newClientCall = this.this$2.this$1.newClientCall(this.this$2.method, this.this$2.callOptions);
                            this.this$2.context.detach(attach);
                            this.this$2.setCall(newClientCall);
                            this.this$2.this$1.this$0.syncContext.execute(new PendingCallRemoval(this.this$2));
                        } catch (Throwable th) {
                            this.this$2.context.detach(attach);
                            throw th;
                        }
                    }
                });
            }

            /* JADX INFO: Access modifiers changed from: protected */
            @Override // io.grpc.internal.DelayedClientCall
            public final void callCancelled() {
                super.callCancelled();
                this.this$1.this$0.syncContext.execute(new PendingCallRemoval(this));
            }

            /* loaded from: classes6.dex */
            final class PendingCallRemoval implements Runnable {
                final PendingCall this$2;

                PendingCallRemoval(PendingCall pendingCall) {
                    this.this$2 = pendingCall;
                }

                @Override // java.lang.Runnable
                public final void run() {
                    if (this.this$2.this$1.this$0.pendingCalls != null) {
                        this.this$2.this$1.this$0.pendingCalls.remove(this.this$2);
                        if (this.this$2.this$1.this$0.pendingCalls.isEmpty()) {
                            this.this$2.this$1.this$0.inUseStateAggregator.updateObjectInUse(this.this$2.this$1.this$0.pendingCallsInUseObject, false);
                            this.this$2.this$1.this$0.pendingCalls = null;
                            if (this.this$2.this$1.this$0.shutdown.get()) {
                                this.this$2.this$1.this$0.uncommittedRetriableStreamsRegistry.onShutdown(ManagedChannelImpl.SHUTDOWN_STATUS);
                            }
                        }
                    }
                }
            }
        }

        /* JADX INFO: Access modifiers changed from: private */
        public <ReqT, RespT> ClientCall<ReqT, RespT> newClientCall(MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions) {
            InternalConfigSelector internalConfigSelector = this.configSelector.get();
            if (internalConfigSelector == null) {
                return this.clientCallImplChannel.newCall(methodDescriptor, callOptions);
            }
            if (internalConfigSelector instanceof ManagedChannelServiceConfig.ServiceConfigConvertedSelector) {
                ManagedChannelServiceConfig.MethodInfo methodConfig = ((ManagedChannelServiceConfig.ServiceConfigConvertedSelector) internalConfigSelector).config.getMethodConfig(methodDescriptor);
                if (methodConfig != null) {
                    callOptions = callOptions.withOption(ManagedChannelServiceConfig.MethodInfo.KEY, methodConfig);
                }
                return this.clientCallImplChannel.newCall(methodDescriptor, callOptions);
            }
            return new ConfigSelectingClientCall(internalConfigSelector, this.clientCallImplChannel, this.this$0.executor, methodDescriptor, callOptions);
        }

        @Override // io.grpc.Channel
        public String authority() {
            return this.authority;
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public static final class ConfigSelectingClientCall<ReqT, RespT> extends ForwardingClientCall<ReqT, RespT> {
        private final Executor callExecutor;
        private CallOptions callOptions;
        private final Channel channel;
        private final InternalConfigSelector configSelector;
        private final Context context;
        private ClientCall<ReqT, RespT> delegate;
        private final MethodDescriptor<ReqT, RespT> method;

        ConfigSelectingClientCall(InternalConfigSelector internalConfigSelector, Channel channel, Executor executor, MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions) {
            this.configSelector = internalConfigSelector;
            this.channel = channel;
            this.method = methodDescriptor;
            executor = callOptions.getExecutor() != null ? callOptions.getExecutor() : executor;
            this.callExecutor = executor;
            this.callOptions = callOptions.withExecutor(executor);
            this.context = Context.current();
        }

        @Override // io.grpc.ForwardingClientCall, io.grpc.ClientCall
        public final void start(ClientCall.Listener<RespT> listener, Metadata metadata) {
            InternalConfigSelector.Result selectConfig = this.configSelector.selectConfig(new PickSubchannelArgsImpl(this.method, metadata, this.callOptions));
            Status status = selectConfig.getStatus();
            if (!status.isOk()) {
                executeCloseObserverInContext(listener, status);
                this.delegate = ManagedChannelImpl.NOOP_CALL;
                return;
            }
            ClientInterceptor interceptor = selectConfig.getInterceptor();
            ManagedChannelServiceConfig.MethodInfo methodConfig = ((ManagedChannelServiceConfig) selectConfig.getConfig()).getMethodConfig(this.method);
            if (methodConfig != null) {
                this.callOptions = this.callOptions.withOption(ManagedChannelServiceConfig.MethodInfo.KEY, methodConfig);
            }
            if (interceptor != null) {
                this.delegate = interceptor.interceptCall(this.method, this.callOptions, this.channel);
            } else {
                this.delegate = this.channel.newCall(this.method, this.callOptions);
            }
            this.delegate.start(listener, metadata);
        }

        private void executeCloseObserverInContext(ClientCall.Listener<RespT> listener, Status status) {
            this.callExecutor.execute(new ContextRunnable(this, listener, status) { // from class: io.grpc.internal.ManagedChannelImpl.ConfigSelectingClientCall.1CloseInContext
                final ConfigSelectingClientCall this$0;
                final ClientCall.Listener val$observer;
                final Status val$status;

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

                @Override // io.grpc.internal.ContextRunnable
                public void runInContext() {
                    this.val$observer.onClose(this.val$status, new Metadata());
                }
            });
        }

        @Override // io.grpc.ForwardingClientCall, io.grpc.PartialForwardingClientCall, io.grpc.ClientCall
        public final void cancel(String str, Throwable th) {
            ClientCall<ReqT, RespT> clientCall = this.delegate;
            if (clientCall != null) {
                clientCall.cancel(str, th);
            }
        }

        @Override // io.grpc.ForwardingClientCall, io.grpc.PartialForwardingClientCall
        public final ClientCall<ReqT, RespT> delegate() {
            return this.delegate;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void maybeTerminateChannel() {
        if (!this.terminated && this.shutdown.get() && this.subchannels.isEmpty() && this.oobChannels.isEmpty()) {
            this.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Terminated");
            this.channelz.removeRootChannel(this);
            this.executorPool.returnObject(this.executor);
            this.balancerRpcExecutorHolder.release();
            this.offloadExecutorHolder.release();
            this.transportFactory.close();
            this.terminated = true;
            this.terminatedLatch.countDown();
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void handleInternalSubchannelState(ConnectivityStateInfo connectivityStateInfo) {
        if (connectivityStateInfo.getState() == ConnectivityState.TRANSIENT_FAILURE || connectivityStateInfo.getState() == ConnectivityState.IDLE) {
            refreshAndResetNameResolution();
        }
    }

    @Override // io.grpc.ManagedChannel
    public final ConnectivityState getState(boolean z) {
        ConnectivityState state = this.channelStateManager.getState();
        if (z && state == ConnectivityState.IDLE) {
            this.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.1RequestConnection
                final ManagedChannelImpl this$0;

                {
                    this.this$0 = this;
                }

                @Override // java.lang.Runnable
                public final void run() {
                    this.this$0.exitIdleMode();
                    if (this.this$0.subchannelPicker != null) {
                        this.this$0.subchannelPicker.requestConnection();
                    }
                    if (this.this$0.lbHelper != null) {
                        this.this$0.lbHelper.lb.requestConnection();
                    }
                }
            });
        }
        return state;
    }

    @Override // io.grpc.ManagedChannel
    public final void notifyWhenStateChanged(ConnectivityState connectivityState, Runnable runnable) {
        this.syncContext.execute(new Runnable(this, runnable, connectivityState) { // from class: io.grpc.internal.ManagedChannelImpl.1NotifyStateChanged
            final ManagedChannelImpl this$0;
            final Runnable val$callback;
            final ConnectivityState val$source;

            {
                this.this$0 = this;
                this.val$callback = runnable;
                this.val$source = connectivityState;
            }

            @Override // java.lang.Runnable
            public final void run() {
                this.this$0.channelStateManager.notifyWhenStateChanged(this.val$callback, this.this$0.executor, this.val$source);
            }
        });
    }

    @Override // io.grpc.ManagedChannel
    public final void resetConnectBackoff() {
        this.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.1ResetConnectBackoff
            final ManagedChannelImpl this$0;

            {
                this.this$0 = this;
            }

            @Override // java.lang.Runnable
            public final void run() {
                if (this.this$0.shutdown.get()) {
                    return;
                }
                if (this.this$0.scheduledNameResolverRefresh != null && this.this$0.scheduledNameResolverRefresh.isPending()) {
                    Preconditions.checkState(this.this$0.nameResolverStarted, "name resolver must be started");
                    this.this$0.refreshAndResetNameResolution();
                }
                Iterator it = this.this$0.subchannels.iterator();
                while (it.hasNext()) {
                    ((InternalSubchannel) it.next()).resetConnectBackoff();
                }
                Iterator it2 = this.this$0.oobChannels.iterator();
                while (it2.hasNext()) {
                    ((OobChannel) it2.next()).resetConnectBackoff();
                }
            }
        });
    }

    @Override // io.grpc.ManagedChannel
    public final void enterIdle() {
        this.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.1PrepareToLoseNetworkRunnable
            final ManagedChannelImpl this$0;

            {
                this.this$0 = this;
            }

            @Override // java.lang.Runnable
            public final void run() {
                if (this.this$0.shutdown.get() || this.this$0.lbHelper == null) {
                    return;
                }
                this.this$0.cancelIdleTimer(false);
                this.this$0.enterIdleMode();
            }
        });
    }

    /* loaded from: classes6.dex */
    final class UncommittedRetriableStreamsRegistry {
        final Object lock;
        Status shutdownStatus;
        final ManagedChannelImpl this$0;
        Collection<ClientStream> uncommittedRetriableStreams;

        private UncommittedRetriableStreamsRegistry(ManagedChannelImpl managedChannelImpl) {
            this.this$0 = managedChannelImpl;
            this.lock = new Object();
            this.uncommittedRetriableStreams = new HashSet();
        }

        final void onShutdown(Status status) {
            synchronized (this.lock) {
                if (this.shutdownStatus != null) {
                    return;
                }
                this.shutdownStatus = status;
                boolean isEmpty = this.uncommittedRetriableStreams.isEmpty();
                if (isEmpty) {
                    this.this$0.delayedTransport.shutdown(status);
                }
            }
        }

        final void onShutdownNow(Status status) {
            ArrayList arrayList;
            onShutdown(status);
            synchronized (this.lock) {
                arrayList = new ArrayList(this.uncommittedRetriableStreams);
            }
            Iterator it = arrayList.iterator();
            while (it.hasNext()) {
                ((ClientStream) it.next()).cancel(status);
            }
            this.this$0.delayedTransport.shutdownNow(status);
        }

        final Status add(RetriableStream<?> retriableStream) {
            synchronized (this.lock) {
                Status status = this.shutdownStatus;
                if (status != null) {
                    return status;
                }
                this.uncommittedRetriableStreams.add(retriableStream);
                return null;
            }
        }

        final void remove(RetriableStream<?> retriableStream) {
            Status status;
            synchronized (this.lock) {
                this.uncommittedRetriableStreams.remove(retriableStream);
                if (this.uncommittedRetriableStreams.isEmpty()) {
                    status = this.shutdownStatus;
                    this.uncommittedRetriableStreams = new HashSet();
                } else {
                    status = null;
                }
            }
            if (status != null) {
                this.this$0.delayedTransport.shutdown(status);
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public final class LbHelperImpl extends LoadBalancer.Helper {
        boolean ignoreRefreshNsCheck;
        AutoConfiguredLoadBalancerFactory.AutoConfiguredLoadBalancer lb;
        boolean nsRefreshedByLb;
        final ManagedChannelImpl this$0;

        private LbHelperImpl(ManagedChannelImpl managedChannelImpl) {
            this.this$0 = managedChannelImpl;
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final AbstractSubchannel createSubchannel(LoadBalancer.CreateSubchannelArgs createSubchannelArgs) {
            this.this$0.syncContext.throwIfNotInThisSynchronizationContext();
            Preconditions.checkState(!this.this$0.terminating, "Channel is being terminated");
            return new SubchannelImpl(this.this$0, createSubchannelArgs, this);
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final void updateBalancingState(ConnectivityState connectivityState, LoadBalancer.SubchannelPicker subchannelPicker) {
            this.this$0.syncContext.throwIfNotInThisSynchronizationContext();
            Preconditions.checkNotNull(connectivityState, "newState");
            Preconditions.checkNotNull(subchannelPicker, "newPicker");
            this.this$0.syncContext.execute(new Runnable(this, subchannelPicker, connectivityState) { // from class: io.grpc.internal.ManagedChannelImpl.LbHelperImpl.1UpdateBalancingState
                final LbHelperImpl this$1;
                final LoadBalancer.SubchannelPicker val$newPicker;
                final ConnectivityState val$newState;

                {
                    this.this$1 = this;
                    this.val$newPicker = subchannelPicker;
                    this.val$newState = connectivityState;
                }

                @Override // java.lang.Runnable
                public final void run() {
                    LbHelperImpl lbHelperImpl = this.this$1;
                    if (lbHelperImpl != lbHelperImpl.this$0.lbHelper) {
                        return;
                    }
                    this.this$1.this$0.updateSubchannelPicker(this.val$newPicker);
                    if (this.val$newState != ConnectivityState.SHUTDOWN) {
                        this.this$1.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Entering {0} state with picker: {1}", this.val$newState, this.val$newPicker);
                        this.this$1.this$0.channelStateManager.gotoState(this.val$newState);
                    }
                }
            });
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final void refreshNameResolution() {
            this.this$0.syncContext.throwIfNotInThisSynchronizationContext();
            this.nsRefreshedByLb = true;
            this.this$0.syncContext.execute(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.LbHelperImpl.1LoadBalancerRefreshNameResolution
                final LbHelperImpl this$1;

                {
                    this.this$1 = this;
                }

                @Override // java.lang.Runnable
                public final void run() {
                    this.this$1.this$0.refreshAndResetNameResolution();
                }
            });
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final ManagedChannel createOobChannel(EquivalentAddressGroup equivalentAddressGroup, String str) {
            return createOobChannel(Collections.singletonList(equivalentAddressGroup), str);
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final ManagedChannel createOobChannel(List<EquivalentAddressGroup> list, String str) {
            Preconditions.checkState(!this.this$0.terminated, "Channel is terminated");
            long currentTimeNanos = this.this$0.timeProvider.currentTimeNanos();
            InternalLogId allocate = InternalLogId.allocate("OobChannel", (String) null);
            InternalLogId allocate2 = InternalLogId.allocate("Subchannel-OOB", str);
            ChannelTracer channelTracer = new ChannelTracer(allocate, this.this$0.maxTraceEvents, currentTimeNanos, "OobChannel for ".concat(String.valueOf(list)));
            OobChannel oobChannel = new OobChannel(str, this.this$0.balancerRpcExecutorPool, this.this$0.oobTransportFactory.getScheduledExecutorService(), this.this$0.syncContext, this.this$0.callTracerFactory.create(), channelTracer, this.this$0.channelz, this.this$0.timeProvider);
            this.this$0.channelTracer.reportEvent(new InternalChannelz.ChannelTrace.Event.Builder().setDescription("Child OobChannel created").setSeverity(InternalChannelz.ChannelTrace.Event.Severity.CT_INFO).setTimestampNanos(currentTimeNanos).setChannelRef(oobChannel).build());
            ChannelTracer channelTracer2 = new ChannelTracer(allocate2, this.this$0.maxTraceEvents, currentTimeNanos, "Subchannel for ".concat(String.valueOf(list)));
            InternalSubchannel internalSubchannel = new InternalSubchannel(list, str, this.this$0.userAgent, this.this$0.backoffPolicyProvider, this.this$0.oobTransportFactory, this.this$0.oobTransportFactory.getScheduledExecutorService(), this.this$0.stopwatchSupplier, this.this$0.syncContext, new InternalSubchannel.Callback(this, oobChannel) { // from class: io.grpc.internal.ManagedChannelImpl.LbHelperImpl.1ManagedOobChannelCallback
                final LbHelperImpl this$1;
                final OobChannel val$oobChannel;

                {
                    this.this$1 = this;
                    this.val$oobChannel = oobChannel;
                }

                @Override // io.grpc.internal.InternalSubchannel.Callback
                final void onTerminated(InternalSubchannel internalSubchannel2) {
                    this.this$1.this$0.oobChannels.remove(this.val$oobChannel);
                    this.this$1.this$0.channelz.removeSubchannel(internalSubchannel2);
                    this.val$oobChannel.handleSubchannelTerminated();
                    this.this$1.this$0.maybeTerminateChannel();
                }

                @Override // io.grpc.internal.InternalSubchannel.Callback
                final void onStateChange(InternalSubchannel internalSubchannel2, ConnectivityStateInfo connectivityStateInfo) {
                    this.this$1.this$0.handleInternalSubchannelState(connectivityStateInfo);
                    this.val$oobChannel.handleSubchannelStateChange(connectivityStateInfo);
                }
            }, this.this$0.channelz, this.this$0.callTracerFactory.create(), channelTracer2, allocate2, new ChannelLoggerImpl(channelTracer2, this.this$0.timeProvider));
            channelTracer.reportEvent(new InternalChannelz.ChannelTrace.Event.Builder().setDescription("Child Subchannel created").setSeverity(InternalChannelz.ChannelTrace.Event.Severity.CT_INFO).setTimestampNanos(currentTimeNanos).setSubchannelRef(internalSubchannel).build());
            this.this$0.channelz.addSubchannel(oobChannel);
            this.this$0.channelz.addSubchannel(internalSubchannel);
            oobChannel.setSubchannel(internalSubchannel);
            this.this$0.syncContext.execute(new Runnable(this, oobChannel) { // from class: io.grpc.internal.ManagedChannelImpl.LbHelperImpl.1AddOobChannel
                final LbHelperImpl this$1;
                final OobChannel val$oobChannel;

                {
                    this.this$1 = this;
                    this.val$oobChannel = oobChannel;
                }

                @Override // java.lang.Runnable
                public final void run() {
                    if (this.this$1.this$0.terminating) {
                        this.val$oobChannel.shutdown();
                    }
                    if (this.this$1.this$0.terminated) {
                        return;
                    }
                    this.this$1.this$0.oobChannels.add(this.val$oobChannel);
                }
            });
            return oobChannel;
        }

        /* JADX WARN: Type inference failed for: r2v2, types: [io.grpc.ManagedChannelBuilder, io.grpc.ManagedChannelBuilder<?>] */
        @Override // io.grpc.LoadBalancer.Helper
        @Deprecated
        public final ManagedChannelBuilder<?> createResolvingOobChannelBuilder(String str) {
            return createResolvingOobChannelBuilder(str, new DefaultChannelCreds(this)).overrideAuthority(getAuthority());
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final ManagedChannelBuilder<?> createResolvingOobChannelBuilder(String str, ChannelCredentials channelCredentials) {
            Preconditions.checkNotNull(channelCredentials, "channelCreds");
            Preconditions.checkState(!this.this$0.terminated, "Channel is terminated");
            return new ForwardingChannelBuilder<C1ResolvingOobChannelBuilder>(this, channelCredentials, str) { // from class: io.grpc.internal.ManagedChannelImpl.LbHelperImpl.1ResolvingOobChannelBuilder
                final ManagedChannelBuilder<?> delegate;
                final LbHelperImpl this$1;
                final ChannelCredentials val$channelCreds;
                final String val$target;

                {
                    CallCredentials callCredentials;
                    ClientTransportFactory clientTransportFactory;
                    this.this$1 = this;
                    this.val$channelCreds = channelCredentials;
                    this.val$target = str;
                    if (channelCredentials instanceof DefaultChannelCreds) {
                        clientTransportFactory = this.this$0.originalTransportFactory;
                        callCredentials = null;
                    } else {
                        ClientTransportFactory.SwapChannelCredentialsResult swapChannelCredentials = this.this$0.originalTransportFactory.swapChannelCredentials(channelCredentials);
                        if (swapChannelCredentials == null) {
                            this.delegate = Grpc.newChannelBuilder(str, channelCredentials);
                            return;
                        } else {
                            ClientTransportFactory clientTransportFactory2 = swapChannelCredentials.transportFactory;
                            callCredentials = swapChannelCredentials.callCredentials;
                            clientTransportFactory = clientTransportFactory2;
                        }
                    }
                    this.delegate = new ManagedChannelImplBuilder(str, channelCredentials, callCredentials, new ManagedChannelImplBuilder.ClientTransportFactoryBuilder(this, this, clientTransportFactory) { // from class: io.grpc.internal.ManagedChannelImpl.LbHelperImpl.1ResolvingOobChannelBuilder.1
                        final C1ResolvingOobChannelBuilder this$2;
                        final LbHelperImpl val$this$1;
                        final ClientTransportFactory val$transportFactory;

                        {
                            this.this$2 = this;
                            this.val$this$1 = this;
                            this.val$transportFactory = clientTransportFactory;
                        }

                        @Override // io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder
                        public ClientTransportFactory buildClientTransportFactory() {
                            return this.val$transportFactory;
                        }
                    }, new ManagedChannelImplBuilder.FixedPortProvider(this.this$0.nameResolverArgs.getDefaultPort()));
                }

                @Override // io.grpc.ForwardingChannelBuilder
                public final ManagedChannelBuilder<?> delegate() {
                    return this.delegate;
                }
            }.nameResolverFactory(this.this$0.nameResolverFactory).executor(this.this$0.executor).offloadExecutor(this.this$0.offloadExecutorHolder.getExecutor()).maxTraceEvents(this.this$0.maxTraceEvents).proxyDetector(this.this$0.nameResolverArgs.getProxyDetector()).userAgent(this.this$0.userAgent);
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final ChannelCredentials getUnsafeChannelCredentials() {
            if (this.this$0.originalChannelCreds != null) {
                return this.this$0.originalChannelCreds;
            }
            return new DefaultChannelCreds(this);
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final void updateOobChannelAddresses(ManagedChannel managedChannel, EquivalentAddressGroup equivalentAddressGroup) {
            updateOobChannelAddresses(managedChannel, Collections.singletonList(equivalentAddressGroup));
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final void updateOobChannelAddresses(ManagedChannel managedChannel, List<EquivalentAddressGroup> list) {
            Preconditions.checkArgument(managedChannel instanceof OobChannel, "channel must have been returned from createOobChannel");
            ((OobChannel) managedChannel).updateAddresses(list);
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final String getAuthority() {
            return this.this$0.authority();
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final SynchronizationContext getSynchronizationContext() {
            return this.this$0.syncContext;
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final ScheduledExecutorService getScheduledExecutorService() {
            return this.this$0.scheduledExecutor;
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final ChannelLogger getChannelLogger() {
            return this.this$0.channelLogger;
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final NameResolver.Args getNameResolverArgs() {
            return this.this$0.nameResolverArgs;
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final NameResolverRegistry getNameResolverRegistry() {
            return this.this$0.nameResolverRegistry;
        }

        /* loaded from: classes6.dex */
        final class DefaultChannelCreds extends ChannelCredentials {
            final LbHelperImpl this$1;

            @Override // io.grpc.ChannelCredentials
            public final ChannelCredentials withoutBearerTokens() {
                return this;
            }

            DefaultChannelCreds(LbHelperImpl lbHelperImpl) {
                this.this$1 = lbHelperImpl;
            }
        }

        @Override // io.grpc.LoadBalancer.Helper
        public final void ignoreRefreshNameResolutionCheck() {
            this.ignoreRefreshNsCheck = true;
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public final class NameResolverListener extends NameResolver.Listener2 {
        final LbHelperImpl helper;
        final NameResolver resolver;
        final ManagedChannelImpl this$0;

        NameResolverListener(ManagedChannelImpl managedChannelImpl, LbHelperImpl lbHelperImpl, NameResolver nameResolver) {
            this.this$0 = managedChannelImpl;
            this.helper = (LbHelperImpl) Preconditions.checkNotNull(lbHelperImpl, "helperImpl");
            this.resolver = (NameResolver) Preconditions.checkNotNull(nameResolver, "resolver");
        }

        @Override // io.grpc.NameResolver.Listener2
        public final void onResult(NameResolver.ResolutionResult resolutionResult) {
            this.this$0.syncContext.execute(new Runnable(this, resolutionResult) { // from class: io.grpc.internal.ManagedChannelImpl.NameResolverListener.1NamesResolved
                final NameResolverListener this$1;
                final NameResolver.ResolutionResult val$resolutionResult;

                {
                    this.this$1 = this;
                    this.val$resolutionResult = resolutionResult;
                }

                @Override // java.lang.Runnable
                public final void run() {
                    ManagedChannelServiceConfig managedChannelServiceConfig;
                    List<EquivalentAddressGroup> addresses = this.val$resolutionResult.getAddresses();
                    this.this$1.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.DEBUG, "Resolved address: {0}, config={1}", addresses, this.val$resolutionResult.getAttributes());
                    if (this.this$1.this$0.lastResolutionState != ResolutionState.SUCCESS) {
                        this.this$1.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Address resolved: {0}", addresses);
                        this.this$1.this$0.lastResolutionState = ResolutionState.SUCCESS;
                    }
                    this.this$1.this$0.nameResolverBackoffPolicy = null;
                    NameResolver.ConfigOrError serviceConfig = this.val$resolutionResult.getServiceConfig();
                    InternalConfigSelector internalConfigSelector = (InternalConfigSelector) this.val$resolutionResult.getAttributes().get(InternalConfigSelector.KEY);
                    ManagedChannelServiceConfig managedChannelServiceConfig2 = (serviceConfig == null || serviceConfig.getConfig() == null) ? null : (ManagedChannelServiceConfig) serviceConfig.getConfig();
                    Status error = serviceConfig != null ? serviceConfig.getError() : null;
                    if (!this.this$1.this$0.lookUpServiceConfig) {
                        if (managedChannelServiceConfig2 != null) {
                            this.this$1.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Service config from name resolver discarded by channel settings");
                        }
                        if (this.this$1.this$0.defaultServiceConfig != null) {
                            managedChannelServiceConfig = this.this$1.this$0.defaultServiceConfig;
                        } else {
                            managedChannelServiceConfig = ManagedChannelImpl.EMPTY_SERVICE_CONFIG;
                        }
                        if (internalConfigSelector != null) {
                            this.this$1.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Config selector from name resolver discarded by channel settings");
                        }
                        this.this$1.this$0.realChannel.updateConfigSelector(managedChannelServiceConfig.getDefaultConfigSelector());
                    } else {
                        if (managedChannelServiceConfig2 != null) {
                            if (internalConfigSelector != null) {
                                this.this$1.this$0.realChannel.updateConfigSelector(internalConfigSelector);
                                if (managedChannelServiceConfig2.getDefaultConfigSelector() != null) {
                                    this.this$1.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.DEBUG, "Method configs in service config will be discarded due to presence ofconfig-selector");
                                }
                            } else {
                                this.this$1.this$0.realChannel.updateConfigSelector(managedChannelServiceConfig2.getDefaultConfigSelector());
                            }
                        } else if (this.this$1.this$0.defaultServiceConfig != null) {
                            managedChannelServiceConfig2 = this.this$1.this$0.defaultServiceConfig;
                            this.this$1.this$0.realChannel.updateConfigSelector(managedChannelServiceConfig2.getDefaultConfigSelector());
                            this.this$1.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Received no service config, using default service config");
                        } else if (error != null) {
                            if (!this.this$1.this$0.serviceConfigUpdated) {
                                this.this$1.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.INFO, "Fallback to error due to invalid first service config without default config");
                                this.this$1.onError(serviceConfig.getError());
                                return;
                            }
                            managedChannelServiceConfig2 = this.this$1.this$0.lastServiceConfig;
                        } else {
                            managedChannelServiceConfig2 = ManagedChannelImpl.EMPTY_SERVICE_CONFIG;
                            this.this$1.this$0.realChannel.updateConfigSelector(null);
                        }
                        if (!managedChannelServiceConfig2.equals(this.this$1.this$0.lastServiceConfig)) {
                            ChannelLogger channelLogger = this.this$1.this$0.channelLogger;
                            ChannelLogger.ChannelLogLevel channelLogLevel = ChannelLogger.ChannelLogLevel.INFO;
                            Object[] objArr = new Object[1];
                            objArr[0] = managedChannelServiceConfig2 == ManagedChannelImpl.EMPTY_SERVICE_CONFIG ? " to empty" : "";
                            channelLogger.log(channelLogLevel, "Service config changed{0}", objArr);
                            this.this$1.this$0.lastServiceConfig = managedChannelServiceConfig2;
                        }
                        try {
                            this.this$1.this$0.serviceConfigUpdated = true;
                        } catch (RuntimeException e) {
                            Logger logger = ManagedChannelImpl.logger;
                            Level level = Level.WARNING;
                            StringBuilder sb = new StringBuilder("[");
                            sb.append(this.this$1.this$0.getLogId());
                            sb.append("] Unexpected exception from parsing service config");
                            logger.log(level, sb.toString(), (Throwable) e);
                        }
                        managedChannelServiceConfig = managedChannelServiceConfig2;
                    }
                    Attributes attributes = this.val$resolutionResult.getAttributes();
                    if (this.this$1.helper == this.this$1.this$0.lbHelper) {
                        Attributes.Builder discard = attributes.toBuilder().discard(InternalConfigSelector.KEY);
                        Map<String, ?> healthCheckingConfig = managedChannelServiceConfig.getHealthCheckingConfig();
                        if (healthCheckingConfig != null) {
                            discard.set(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG, healthCheckingConfig).build();
                        }
                        Status tryHandleResolvedAddresses = this.this$1.helper.lb.tryHandleResolvedAddresses(LoadBalancer.ResolvedAddresses.newBuilder().setAddresses(addresses).setAttributes(discard.build()).setLoadBalancingPolicyConfig(managedChannelServiceConfig.getLoadBalancingConfig()).build());
                        if (tryHandleResolvedAddresses.isOk()) {
                            return;
                        }
                        NameResolverListener nameResolverListener = this.this$1;
                        StringBuilder sb2 = new StringBuilder();
                        sb2.append(this.this$1.resolver);
                        sb2.append(" was used");
                        nameResolverListener.handleErrorInSyncContext(tryHandleResolvedAddresses.augmentDescription(sb2.toString()));
                    }
                }
            });
        }

        @Override // io.grpc.NameResolver.Listener2, io.grpc.NameResolver.Listener
        public final void onError(Status status) {
            Preconditions.checkArgument(!status.isOk(), "the error status must not be OK");
            this.this$0.syncContext.execute(new Runnable(this, status) { // from class: io.grpc.internal.ManagedChannelImpl.NameResolverListener.1NameResolverErrorHandler
                final NameResolverListener this$1;
                final Status val$error;

                {
                    this.this$1 = this;
                    this.val$error = status;
                }

                @Override // java.lang.Runnable
                public final void run() {
                    this.this$1.handleErrorInSyncContext(this.val$error);
                }
            });
        }

        /* JADX INFO: Access modifiers changed from: private */
        public void handleErrorInSyncContext(Status status) {
            ManagedChannelImpl.logger.log(Level.WARNING, "[{0}] Failed to resolve name. status={1}", new Object[]{this.this$0.getLogId(), status});
            this.this$0.realChannel.onConfigError();
            if (this.this$0.lastResolutionState != ResolutionState.ERROR) {
                this.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.WARNING, "Failed to resolve name: {0}", status);
                this.this$0.lastResolutionState = ResolutionState.ERROR;
            }
            if (this.helper != this.this$0.lbHelper) {
                return;
            }
            this.helper.lb.handleNameResolutionError(status);
            scheduleExponentialBackOffInSyncContext();
        }

        private void scheduleExponentialBackOffInSyncContext() {
            if (this.this$0.scheduledNameResolverRefresh == null || !this.this$0.scheduledNameResolverRefresh.isPending()) {
                if (this.this$0.nameResolverBackoffPolicy == null) {
                    ManagedChannelImpl managedChannelImpl = this.this$0;
                    managedChannelImpl.nameResolverBackoffPolicy = managedChannelImpl.backoffPolicyProvider.get();
                }
                long nextBackoffNanos = this.this$0.nameResolverBackoffPolicy.nextBackoffNanos();
                this.this$0.channelLogger.log(ChannelLogger.ChannelLogLevel.DEBUG, "Scheduling DNS resolution backoff for {0} ns", Long.valueOf(nextBackoffNanos));
                ManagedChannelImpl managedChannelImpl2 = this.this$0;
                managedChannelImpl2.scheduledNameResolverRefresh = managedChannelImpl2.syncContext.schedule(new DelayedNameResolverRefresh(this.this$0), nextBackoffNanos, TimeUnit.NANOSECONDS, this.this$0.transportFactory.getScheduledExecutorService());
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public final class SubchannelImpl extends AbstractSubchannel {
        List<EquivalentAddressGroup> addressGroups;
        final LoadBalancer.CreateSubchannelArgs args;
        SynchronizationContext.ScheduledHandle delayedShutdownTask;
        final LbHelperImpl helper;
        boolean shutdown;
        boolean started;
        InternalSubchannel subchannel;
        final InternalLogId subchannelLogId;
        final ChannelLoggerImpl subchannelLogger;
        final ChannelTracer subchannelTracer;
        final ManagedChannelImpl this$0;

        SubchannelImpl(ManagedChannelImpl managedChannelImpl, LoadBalancer.CreateSubchannelArgs createSubchannelArgs, LbHelperImpl lbHelperImpl) {
            this.this$0 = managedChannelImpl;
            this.addressGroups = createSubchannelArgs.getAddresses();
            if (managedChannelImpl.authorityOverride != null) {
                createSubchannelArgs = createSubchannelArgs.toBuilder().setAddresses(stripOverrideAuthorityAttributes(createSubchannelArgs.getAddresses())).build();
            }
            this.args = (LoadBalancer.CreateSubchannelArgs) Preconditions.checkNotNull(createSubchannelArgs, "args");
            this.helper = (LbHelperImpl) Preconditions.checkNotNull(lbHelperImpl, "helper");
            InternalLogId allocate = InternalLogId.allocate("Subchannel", managedChannelImpl.authority());
            this.subchannelLogId = allocate;
            int i = managedChannelImpl.maxTraceEvents;
            long currentTimeNanos = managedChannelImpl.timeProvider.currentTimeNanos();
            StringBuilder sb = new StringBuilder("Subchannel for ");
            sb.append(createSubchannelArgs.getAddresses());
            ChannelTracer channelTracer = new ChannelTracer(allocate, i, currentTimeNanos, sb.toString());
            this.subchannelTracer = channelTracer;
            this.subchannelLogger = new ChannelLoggerImpl(channelTracer, managedChannelImpl.timeProvider);
        }

        @Override // io.grpc.LoadBalancer.Subchannel
        public final void start(LoadBalancer.SubchannelStateListener subchannelStateListener) {
            this.this$0.syncContext.throwIfNotInThisSynchronizationContext();
            Preconditions.checkState(!this.started, "already started");
            Preconditions.checkState(!this.shutdown, "already shutdown");
            Preconditions.checkState(!this.this$0.terminating, "Channel is being terminated");
            this.started = true;
            InternalSubchannel internalSubchannel = new InternalSubchannel(this.args.getAddresses(), this.this$0.authority(), this.this$0.userAgent, this.this$0.backoffPolicyProvider, this.this$0.transportFactory, this.this$0.transportFactory.getScheduledExecutorService(), this.this$0.stopwatchSupplier, this.this$0.syncContext, new InternalSubchannel.Callback(this, subchannelStateListener) { // from class: io.grpc.internal.ManagedChannelImpl.SubchannelImpl.1ManagedInternalSubchannelCallback
                final SubchannelImpl this$1;
                final LoadBalancer.SubchannelStateListener val$listener;

                {
                    this.this$1 = this;
                    this.val$listener = subchannelStateListener;
                }

                @Override // io.grpc.internal.InternalSubchannel.Callback
                final void onTerminated(InternalSubchannel internalSubchannel2) {
                    this.this$1.this$0.subchannels.remove(internalSubchannel2);
                    this.this$1.this$0.channelz.removeSubchannel(internalSubchannel2);
                    this.this$1.this$0.maybeTerminateChannel();
                }

                @Override // io.grpc.internal.InternalSubchannel.Callback
                final void onStateChange(InternalSubchannel internalSubchannel2, ConnectivityStateInfo connectivityStateInfo) {
                    Preconditions.checkState(this.val$listener != null, "listener is null");
                    this.val$listener.onSubchannelState(connectivityStateInfo);
                    if ((connectivityStateInfo.getState() != ConnectivityState.TRANSIENT_FAILURE && connectivityStateInfo.getState() != ConnectivityState.IDLE) || this.this$1.helper.ignoreRefreshNsCheck || this.this$1.helper.nsRefreshedByLb) {
                        return;
                    }
                    ManagedChannelImpl.logger.log(Level.WARNING, "LoadBalancer should call Helper.refreshNameResolution() to refresh name resolution if subchannel state becomes TRANSIENT_FAILURE or IDLE. This will no longer happen automatically in the future releases");
                    this.this$1.this$0.refreshAndResetNameResolution();
                    this.this$1.helper.nsRefreshedByLb = true;
                }

                @Override // io.grpc.internal.InternalSubchannel.Callback
                final void onInUse(InternalSubchannel internalSubchannel2) {
                    this.this$1.this$0.inUseStateAggregator.updateObjectInUse(internalSubchannel2, true);
                }

                @Override // io.grpc.internal.InternalSubchannel.Callback
                final void onNotInUse(InternalSubchannel internalSubchannel2) {
                    this.this$1.this$0.inUseStateAggregator.updateObjectInUse(internalSubchannel2, false);
                }
            }, this.this$0.channelz, this.this$0.callTracerFactory.create(), this.subchannelTracer, this.subchannelLogId, this.subchannelLogger);
            this.this$0.channelTracer.reportEvent(new InternalChannelz.ChannelTrace.Event.Builder().setDescription("Child Subchannel started").setSeverity(InternalChannelz.ChannelTrace.Event.Severity.CT_INFO).setTimestampNanos(this.this$0.timeProvider.currentTimeNanos()).setSubchannelRef(internalSubchannel).build());
            this.subchannel = internalSubchannel;
            this.this$0.channelz.addSubchannel(internalSubchannel);
            this.this$0.subchannels.add(internalSubchannel);
        }

        @Override // io.grpc.internal.AbstractSubchannel
        final InternalInstrumented<InternalChannelz.ChannelStats> getInstrumentedInternalSubchannel() {
            Preconditions.checkState(this.started, "not started");
            return this.subchannel;
        }

        @Override // io.grpc.LoadBalancer.Subchannel
        public final void shutdown() {
            SynchronizationContext.ScheduledHandle scheduledHandle;
            this.this$0.syncContext.throwIfNotInThisSynchronizationContext();
            if (this.subchannel == null) {
                this.shutdown = true;
                return;
            }
            if (!this.shutdown) {
                this.shutdown = true;
            } else {
                if (!this.this$0.terminating || (scheduledHandle = this.delayedShutdownTask) == null) {
                    return;
                }
                scheduledHandle.cancel();
                this.delayedShutdownTask = null;
            }
            if (!this.this$0.terminating) {
                this.delayedShutdownTask = this.this$0.syncContext.schedule(new LogExceptionRunnable(new Runnable(this) { // from class: io.grpc.internal.ManagedChannelImpl.SubchannelImpl.1ShutdownSubchannel
                    final SubchannelImpl this$1;

                    {
                        this.this$1 = this;
                    }

                    @Override // java.lang.Runnable
                    public final void run() {
                        this.this$1.subchannel.shutdown(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_STATUS);
                    }
                }), ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS, TimeUnit.SECONDS, this.this$0.transportFactory.getScheduledExecutorService());
            } else {
                this.subchannel.shutdown(ManagedChannelImpl.SHUTDOWN_STATUS);
            }
        }

        @Override // io.grpc.LoadBalancer.Subchannel
        public final void requestConnection() {
            this.this$0.syncContext.throwIfNotInThisSynchronizationContext();
            Preconditions.checkState(this.started, "not started");
            this.subchannel.obtainActiveTransport();
        }

        @Override // io.grpc.LoadBalancer.Subchannel
        public final List<EquivalentAddressGroup> getAllAddresses() {
            this.this$0.syncContext.throwIfNotInThisSynchronizationContext();
            Preconditions.checkState(this.started, "not started");
            return this.addressGroups;
        }

        @Override // io.grpc.LoadBalancer.Subchannel
        public final Attributes getAttributes() {
            return this.args.getAttributes();
        }

        public final String toString() {
            return this.subchannelLogId.toString();
        }

        @Override // io.grpc.LoadBalancer.Subchannel
        public final Channel asChannel() {
            Preconditions.checkState(this.started, "not started");
            return new SubchannelChannel(this.subchannel, this.this$0.balancerRpcExecutorHolder.getExecutor(), this.this$0.transportFactory.getScheduledExecutorService(), this.this$0.callTracerFactory.create(), new AtomicReference(null));
        }

        @Override // io.grpc.LoadBalancer.Subchannel
        public final Object getInternalSubchannel() {
            Preconditions.checkState(this.started, "Subchannel is not started");
            return this.subchannel;
        }

        @Override // io.grpc.LoadBalancer.Subchannel
        public final void updateAddresses(List<EquivalentAddressGroup> list) {
            this.this$0.syncContext.throwIfNotInThisSynchronizationContext();
            this.addressGroups = list;
            if (this.this$0.authorityOverride != null) {
                list = stripOverrideAuthorityAttributes(list);
            }
            this.subchannel.updateAddresses(list);
        }

        private List<EquivalentAddressGroup> stripOverrideAuthorityAttributes(List<EquivalentAddressGroup> list) {
            ArrayList arrayList = new ArrayList();
            for (EquivalentAddressGroup equivalentAddressGroup : list) {
                arrayList.add(new EquivalentAddressGroup(equivalentAddressGroup.getAddresses(), equivalentAddressGroup.getAttributes().toBuilder().discard(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE).build()));
            }
            return Collections.unmodifiableList(arrayList);
        }

        @Override // io.grpc.LoadBalancer.Subchannel
        public final ChannelLogger getChannelLogger() {
            return this.subchannelLogger;
        }
    }

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

    /* loaded from: classes6.dex */
    final class DelayedTransportListener implements ManagedClientTransport.Listener {
        final ManagedChannelImpl this$0;

        @Override // io.grpc.internal.ManagedClientTransport.Listener
        public final void transportReady() {
        }

        private DelayedTransportListener(ManagedChannelImpl managedChannelImpl) {
            this.this$0 = managedChannelImpl;
        }

        @Override // io.grpc.internal.ManagedClientTransport.Listener
        public final void transportShutdown(Status status) {
            Preconditions.checkState(this.this$0.shutdown.get(), "Channel must have been shut down");
        }

        @Override // io.grpc.internal.ManagedClientTransport.Listener
        public final void transportInUse(boolean z) {
            this.this$0.inUseStateAggregator.updateObjectInUse(this.this$0.delayedTransport, z);
        }

        @Override // io.grpc.internal.ManagedClientTransport.Listener
        public final void transportTerminated() {
            Preconditions.checkState(this.this$0.shutdown.get(), "Channel must have been shut down");
            this.this$0.terminating = true;
            this.this$0.shutdownNameResolverAndLoadBalancer(false);
            this.this$0.maybeShutdownNowSubchannels();
            this.this$0.maybeTerminateChannel();
        }
    }

    /* loaded from: classes6.dex */
    final class IdleModeStateAggregator extends InUseStateAggregator<Object> {
        final ManagedChannelImpl this$0;

        private IdleModeStateAggregator(ManagedChannelImpl managedChannelImpl) {
            this.this$0 = managedChannelImpl;
        }

        @Override // io.grpc.internal.InUseStateAggregator
        protected final void handleInUse() {
            this.this$0.exitIdleMode();
        }

        @Override // io.grpc.internal.InUseStateAggregator
        protected final void handleNotInUse() {
            if (this.this$0.shutdown.get()) {
                return;
            }
            this.this$0.rescheduleIdleTimer();
        }
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes6.dex */
    public static final class ExecutorHolder {
        private Executor executor;
        private final ObjectPool<? extends Executor> pool;

        ExecutorHolder(ObjectPool<? extends Executor> objectPool) {
            this.pool = (ObjectPool) Preconditions.checkNotNull(objectPool, "executorPool");
        }

        final Executor getExecutor() {
            Executor executor;
            synchronized (this) {
                if (this.executor == null) {
                    this.executor = (Executor) Preconditions.checkNotNull(this.pool.getObject(), "%s.getObject()", this.executor);
                }
                executor = this.executor;
            }
            return executor;
        }

        final void release() {
            synchronized (this) {
                Executor executor = this.executor;
                if (executor != null) {
                    this.executor = this.pool.returnObject(executor);
                }
            }
        }
    }

    /* loaded from: classes6.dex */
    static final class RestrictedScheduledExecutor implements ScheduledExecutorService {
        final ScheduledExecutorService delegate;

        private RestrictedScheduledExecutor(ScheduledExecutorService scheduledExecutorService) {
            this.delegate = (ScheduledExecutorService) Preconditions.checkNotNull(scheduledExecutorService, "delegate");
        }

        @Override // java.util.concurrent.ScheduledExecutorService
        public final <V> ScheduledFuture<V> schedule(Callable<V> callable, long j, TimeUnit timeUnit) {
            return this.delegate.schedule(callable, j, timeUnit);
        }

        @Override // java.util.concurrent.ScheduledExecutorService
        public final ScheduledFuture<?> schedule(Runnable runnable, long j, TimeUnit timeUnit) {
            return this.delegate.schedule(runnable, j, timeUnit);
        }

        @Override // java.util.concurrent.ScheduledExecutorService
        public final ScheduledFuture<?> scheduleAtFixedRate(Runnable runnable, long j, long j2, TimeUnit timeUnit) {
            return this.delegate.scheduleAtFixedRate(runnable, j, j2, timeUnit);
        }

        @Override // java.util.concurrent.ScheduledExecutorService
        public final ScheduledFuture<?> scheduleWithFixedDelay(Runnable runnable, long j, long j2, TimeUnit timeUnit) {
            return this.delegate.scheduleWithFixedDelay(runnable, j, j2, timeUnit);
        }

        @Override // java.util.concurrent.ExecutorService
        public final boolean awaitTermination(long j, TimeUnit timeUnit) throws InterruptedException {
            return this.delegate.awaitTermination(j, timeUnit);
        }

        @Override // java.util.concurrent.ExecutorService
        public final <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> collection) throws InterruptedException {
            return this.delegate.invokeAll(collection);
        }

        @Override // java.util.concurrent.ExecutorService
        public final <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> collection, long j, TimeUnit timeUnit) throws InterruptedException {
            return this.delegate.invokeAll(collection, j, timeUnit);
        }

        @Override // java.util.concurrent.ExecutorService
        public final <T> T invokeAny(Collection<? extends Callable<T>> collection) throws InterruptedException, ExecutionException {
            return (T) this.delegate.invokeAny(collection);
        }

        @Override // java.util.concurrent.ExecutorService
        public final <T> T invokeAny(Collection<? extends Callable<T>> collection, long j, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
            return (T) this.delegate.invokeAny(collection, j, timeUnit);
        }

        @Override // java.util.concurrent.ExecutorService
        public final boolean isShutdown() {
            return this.delegate.isShutdown();
        }

        @Override // java.util.concurrent.ExecutorService
        public final boolean isTerminated() {
            return this.delegate.isTerminated();
        }

        @Override // java.util.concurrent.ExecutorService
        public final void shutdown() {
            throw new UnsupportedOperationException("Restricted: shutdown() is not allowed");
        }

        @Override // java.util.concurrent.ExecutorService
        public final List<Runnable> shutdownNow() {
            throw new UnsupportedOperationException("Restricted: shutdownNow() is not allowed");
        }

        @Override // java.util.concurrent.ExecutorService
        public final <T> Future<T> submit(Callable<T> callable) {
            return this.delegate.submit(callable);
        }

        @Override // java.util.concurrent.ExecutorService
        public final Future<?> submit(Runnable runnable) {
            return this.delegate.submit(runnable);
        }

        @Override // java.util.concurrent.ExecutorService
        public final <T> Future<T> submit(Runnable runnable, T t) {
            return this.delegate.submit(runnable, t);
        }

        @Override // java.util.concurrent.Executor
        public final void execute(Runnable runnable) {
            this.delegate.execute(runnable);
        }
    }

    @Override // io.grpc.ManagedChannel
    public final boolean isTerminated() {
        return this.terminated;
    }

    final boolean isInPanicMode() {
        return this.panicMode;
    }

    @Override // io.grpc.InternalWithLogId
    public final InternalLogId getLogId() {
        return this.logId;
    }
}