Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/org/apache/http/impl/conn/AbstractClientConnAdapter.java

@@ -0,0 +1,158 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.io.InterruptedIOException;
+import java.net.InetAddress;
+import java.util.concurrent.TimeUnit;
+import javax.net.ssl.SSLSession;
+import org.apache.http.HttpConnectionMetrics;
+import org.apache.http.HttpEntityEnclosingRequest;
+import org.apache.http.HttpException;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.ManagedClientConnection;
+import org.apache.http.conn.OperatedClientConnection;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractClientConnAdapter implements ManagedClientConnection {
+    public AbstractClientConnAdapter(ClientConnectionManager clientConnectionManager, OperatedClientConnection operatedClientConnection) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void detach() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public OperatedClientConnection getWrappedConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ClientConnectionManager getManager() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void assertNotAborted() throws InterruptedIOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void assertValid(OperatedClientConnection operatedClientConnection) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public boolean isOpen() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public boolean isStale() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void setSocketTimeout(int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public int getSocketTimeout() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public HttpConnectionMetrics getMetrics() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void flush() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public boolean isResponseAvailable(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void receiveResponseEntity(HttpResponse httpResponse) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public HttpResponse receiveResponseHeader() throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void sendRequestEntity(HttpEntityEnclosingRequest httpEntityEnclosingRequest) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpClientConnection
+    public void sendRequestHeader(HttpRequest httpRequest) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public InetAddress getLocalAddress() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public int getLocalPort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public InetAddress getRemoteAddress() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpInetConnection
+    public int getRemotePort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public boolean isSecure() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public SSLSession getSSLSession() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void markReusable() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void unmarkReusable() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public boolean isMarkedReusable() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void setIdleDuration(long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ConnectionReleaseTrigger
+    public void releaseConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ConnectionReleaseTrigger
+    public void abortConnection() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/AbstractPoolEntry.java

@@ -0,0 +1,52 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.HttpHost;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.routing.RouteTracker;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractPoolEntry {
+    protected final ClientConnectionOperator connOperator;
+    protected final OperatedClientConnection connection;
+    protected volatile HttpRoute route;
+    protected volatile Object state;
+    protected volatile RouteTracker tracker;
+
+    public AbstractPoolEntry(ClientConnectionOperator clientConnectionOperator, HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Object getState() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setState(Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void open(HttpRoute httpRoute, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void tunnelTarget(boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void tunnelProxy(HttpHost httpHost, boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void layerProtocol(HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void shutdownEntry() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/AbstractPooledConnAdapter.java

@@ -0,0 +1,73 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.HttpHost;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractPooledConnAdapter extends AbstractClientConnAdapter {
+    protected volatile AbstractPoolEntry poolEntry;
+
+    public AbstractPooledConnAdapter(ClientConnectionManager clientConnectionManager, AbstractPoolEntry abstractPoolEntry) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void assertAttached() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.AbstractClientConnAdapter
+    public void detach() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public HttpRoute getRoute() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void open(HttpRoute httpRoute, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void tunnelTarget(boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void tunnelProxy(HttpHost httpHost, boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void layerProtocol(HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void close() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.HttpConnection
+    public void shutdown() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public Object getState() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ManagedClientConnection
+    public void setState(Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/DefaultClientConnection.java

@@ -0,0 +1,88 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.net.Socket;
+import org.apache.http.HttpException;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.HttpResponse;
+import org.apache.http.HttpResponseFactory;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.impl.SocketHttpClientConnection;
+import org.apache.http.io.HttpMessageParser;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.io.SessionOutputBuffer;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultClientConnection extends SocketHttpClientConnection implements OperatedClientConnection {
+    public DefaultClientConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public final HttpHost getTargetHost() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public final boolean isSecure() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection, org.apache.http.conn.OperatedClientConnection
+    public final Socket getSocket() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public void opening(Socket socket, HttpHost httpHost) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public void openCompleted(boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection, org.apache.http.HttpConnection
+    public void shutdown() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection, org.apache.http.HttpConnection
+    public void close() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection
+    public SessionInputBuffer createSessionInputBuffer(Socket socket, int i, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.SocketHttpClientConnection
+    public SessionOutputBuffer createSessionOutputBuffer(Socket socket, int i, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.AbstractHttpClientConnection
+    public HttpMessageParser createResponseParser(SessionInputBuffer sessionInputBuffer, HttpResponseFactory httpResponseFactory, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.OperatedClientConnection
+    public void update(Socket socket, HttpHost httpHost, boolean z, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.AbstractHttpClientConnection, org.apache.http.HttpClientConnection
+    public HttpResponse receiveResponseHeader() throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.AbstractHttpClientConnection, org.apache.http.HttpClientConnection
+    public void sendRequestHeader(HttpRequest httpRequest) throws HttpException, IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/DefaultClientConnectionOperator.java

@@ -0,0 +1,40 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import org.apache.http.HttpHost;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.params.HttpParams;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultClientConnectionOperator implements ClientConnectionOperator {
+    protected SchemeRegistry schemeRegistry;
+
+    public DefaultClientConnectionOperator(SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionOperator
+    public OperatedClientConnection createConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionOperator
+    public void openConnection(OperatedClientConnection operatedClientConnection, HttpHost httpHost, InetAddress inetAddress, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionOperator
+    public void updateSecureConnection(OperatedClientConnection operatedClientConnection, HttpHost httpHost, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void prepareSocket(Socket socket, HttpContext httpContext, HttpParams httpParams) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/DefaultHttpRoutePlanner.java

@@ -0,0 +1,24 @@
+package org.apache.http.impl.conn;
+
+import org.apache.http.HttpException;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.routing.HttpRoutePlanner;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultHttpRoutePlanner implements HttpRoutePlanner {
+    protected SchemeRegistry schemeRegistry;
+
+    public DefaultHttpRoutePlanner(SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.routing.HttpRoutePlanner
+    public HttpRoute determineRoute(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) throws HttpException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/DefaultResponseParser.java

@@ -0,0 +1,24 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.HttpException;
+import org.apache.http.HttpMessage;
+import org.apache.http.HttpResponseFactory;
+import org.apache.http.impl.io.AbstractMessageParser;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.message.LineParser;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class DefaultResponseParser extends AbstractMessageParser {
+    public DefaultResponseParser(SessionInputBuffer sessionInputBuffer, LineParser lineParser, HttpResponseFactory httpResponseFactory, HttpParams httpParams) {
+        super(null, null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.io.AbstractMessageParser
+    public HttpMessage parseHead(SessionInputBuffer sessionInputBuffer) throws IOException, HttpException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/IdleConnectionHandler.java

@@ -0,0 +1,32 @@
+package org.apache.http.impl.conn;
+
+import java.util.concurrent.TimeUnit;
+import org.apache.http.HttpConnection;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class IdleConnectionHandler {
+    public IdleConnectionHandler() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void add(HttpConnection httpConnection, long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean remove(HttpConnection httpConnection) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void removeAll() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeIdleConnections(long j) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeExpiredConnections() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/LoggingSessionInputBuffer.java

@@ -0,0 +1,49 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.io.HttpTransportMetrics;
+import org.apache.http.io.SessionInputBuffer;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class LoggingSessionInputBuffer implements SessionInputBuffer {
+    public LoggingSessionInputBuffer(SessionInputBuffer sessionInputBuffer, Wire wire) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public boolean isDataAvailable(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public int read(byte[] bArr, int i, int i2) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public int read() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public int read(byte[] bArr) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public String readLine() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public int readLine(CharArrayBuffer charArrayBuffer) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionInputBuffer
+    public HttpTransportMetrics getMetrics() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/LoggingSessionOutputBuffer.java

@@ -0,0 +1,49 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import org.apache.http.io.HttpTransportMetrics;
+import org.apache.http.io.SessionOutputBuffer;
+import org.apache.http.util.CharArrayBuffer;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class LoggingSessionOutputBuffer implements SessionOutputBuffer {
+    public LoggingSessionOutputBuffer(SessionOutputBuffer sessionOutputBuffer, Wire wire) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void write(byte[] bArr, int i, int i2) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void write(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void write(byte[] bArr) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void flush() throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void writeLine(CharArrayBuffer charArrayBuffer) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public void writeLine(String str) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.io.SessionOutputBuffer
+    public HttpTransportMetrics getMetrics() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/ProxySelectorRoutePlanner.java

@@ -0,0 +1,49 @@
+package org.apache.http.impl.conn;
+
+import java.net.InetSocketAddress;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.util.List;
+import org.apache.http.HttpException;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.routing.HttpRoutePlanner;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.protocol.HttpContext;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class ProxySelectorRoutePlanner implements HttpRoutePlanner {
+    protected ProxySelector proxySelector;
+    protected SchemeRegistry schemeRegistry;
+
+    public ProxySelectorRoutePlanner(SchemeRegistry schemeRegistry, ProxySelector proxySelector) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ProxySelector getProxySelector() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setProxySelector(ProxySelector proxySelector) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.routing.HttpRoutePlanner
+    public HttpRoute determineRoute(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) throws HttpException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public HttpHost determineProxy(HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) throws HttpException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public String getHost(InetSocketAddress inetSocketAddress) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Proxy chooseProxy(List<Proxy> list, HttpHost httpHost, HttpRequest httpRequest, HttpContext httpContext) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/SingleClientConnManager.java

@@ -0,0 +1,101 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.ClientConnectionRequest;
+import org.apache.http.conn.ManagedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class SingleClientConnManager implements ClientConnectionManager {
+    public static final String MISUSE_MESSAGE = "Invalid use of SingleClientConnManager: connection still allocated.\nMake sure to release the connection before allocating another one.";
+    protected boolean alwaysShutDown;
+    protected ClientConnectionOperator connOperator;
+    protected long connectionExpiresTime;
+    protected volatile boolean isShutDown;
+    protected long lastReleaseTime;
+    protected ConnAdapter managedConn;
+    protected SchemeRegistry schemeRegistry;
+    protected PoolEntry uniquePoolEntry;
+
+    public class PoolEntry extends AbstractPoolEntry {
+        public PoolEntry() {
+            super(null, null);
+            throw new RuntimeException("Stub!");
+        }
+
+        public void close() throws IOException {
+            throw new RuntimeException("Stub!");
+        }
+
+        public void shutdown() throws IOException {
+            throw new RuntimeException("Stub!");
+        }
+    }
+
+    public class ConnAdapter extends AbstractPooledConnAdapter {
+        public ConnAdapter(PoolEntry poolEntry, HttpRoute httpRoute) {
+            super(null, null);
+            throw new RuntimeException("Stub!");
+        }
+    }
+
+    public SingleClientConnManager(HttpParams httpParams, SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void finalize() throws Throwable {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public SchemeRegistry getSchemeRegistry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ClientConnectionOperator createConnectionOperator(SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final void assertStillUp() throws IllegalStateException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public final ClientConnectionRequest requestConnection(HttpRoute httpRoute, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ManagedClientConnection getConnection(HttpRoute httpRoute, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void releaseConnection(ManagedClientConnection managedClientConnection, long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void closeExpiredConnections() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void closeIdleConnections(long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void revokeConnection() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/Wire.java

@@ -0,0 +1,57 @@
+package org.apache.http.impl.conn;
+
+import java.io.IOException;
+import java.io.InputStream;
+import org.apache.commons.logging.Log;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class Wire {
+    public Wire(Log log) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean enabled() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(InputStream inputStream) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(InputStream inputStream) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(byte[] bArr, int i, int i2) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(byte[] bArr, int i, int i2) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(byte[] bArr) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(byte[] bArr) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(int i) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void output(String str) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void input(String str) throws IOException {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/AbstractConnPool.java

@@ -0,0 +1,63 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
+import org.apache.http.conn.ConnectionPoolTimeoutException;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.impl.conn.IdleConnectionHandler;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public abstract class AbstractConnPool implements RefQueueHandler {
+    protected IdleConnectionHandler idleConnHandler;
+    protected volatile boolean isShutDown;
+    protected Set<BasicPoolEntryRef> issuedConnections;
+    protected int numConnections;
+    protected final Lock poolLock;
+    protected ReferenceQueue<Object> refQueue;
+
+    public abstract void deleteClosedConnections();
+
+    public abstract void freeEntry(BasicPoolEntry basicPoolEntry, boolean z, long j, TimeUnit timeUnit);
+
+    public abstract void handleLostEntry(HttpRoute httpRoute);
+
+    public abstract PoolEntryRequest requestPoolEntry(HttpRoute httpRoute, Object obj);
+
+    public AbstractConnPool() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void enableConnectionGC() throws IllegalStateException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final BasicPoolEntry getEntry(HttpRoute httpRoute, Object obj, long j, TimeUnit timeUnit) throws ConnectionPoolTimeoutException, InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.RefQueueHandler
+    public void handleReference(Reference reference) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeIdleConnections(long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeExpiredConnections() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void closeConnection(OperatedClientConnection operatedClientConnection) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/BasicPoolEntry.java

@@ -0,0 +1,28 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.ReferenceQueue;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.OperatedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.impl.conn.AbstractPoolEntry;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicPoolEntry extends AbstractPoolEntry {
+    public BasicPoolEntry(ClientConnectionOperator clientConnectionOperator, HttpRoute httpRoute, ReferenceQueue<Object> referenceQueue) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    public final OperatedClientConnection getConnection() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpRoute getPlannedRoute() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final BasicPoolEntryRef getWeakRef() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/BasicPoolEntryRef.java

@@ -0,0 +1,18 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import org.apache.http.conn.routing.HttpRoute;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicPoolEntryRef extends WeakReference<BasicPoolEntry> {
+    public BasicPoolEntryRef(BasicPoolEntry basicPoolEntry, ReferenceQueue<Object> referenceQueue) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpRoute getRoute() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/BasicPooledConnAdapter.java

@@ -0,0 +1,28 @@
+package org.apache.http.impl.conn.tsccm;
+
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.impl.conn.AbstractPoolEntry;
+import org.apache.http.impl.conn.AbstractPooledConnAdapter;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class BasicPooledConnAdapter extends AbstractPooledConnAdapter {
+    public BasicPooledConnAdapter(ThreadSafeClientConnManager threadSafeClientConnManager, AbstractPoolEntry abstractPoolEntry) {
+        super(null, null);
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.AbstractClientConnAdapter
+    public ClientConnectionManager getManager() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public AbstractPoolEntry getPoolEntry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.AbstractPooledConnAdapter, org.apache.http.impl.conn.AbstractClientConnAdapter
+    public void detach() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/ConnPoolByRoute.java

@@ -0,0 +1,101 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.ConnectionPoolTimeoutException;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class ConnPoolByRoute extends AbstractConnPool {
+    protected Queue<BasicPoolEntry> freeConnections;
+    protected final int maxTotalConnections;
+    protected final ClientConnectionOperator operator;
+    protected final Map<HttpRoute, RouteSpecificPool> routeToPool;
+    protected Queue<WaitingThread> waitingThreads;
+
+    public ConnPoolByRoute(ClientConnectionOperator clientConnectionOperator, HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Queue<BasicPoolEntry> createFreeConnQueue() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Queue<WaitingThread> createWaitingThreadQueue() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public Map<HttpRoute, RouteSpecificPool> createRouteToPoolMap() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public RouteSpecificPool newRouteSpecificPool(HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public WaitingThread newWaitingThread(Condition condition, RouteSpecificPool routeSpecificPool) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public RouteSpecificPool getRoutePool(HttpRoute httpRoute, boolean z) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getConnectionsInPool(HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public PoolEntryRequest requestPoolEntry(HttpRoute httpRoute, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BasicPoolEntry getEntryBlocking(HttpRoute httpRoute, Object obj, long j, TimeUnit timeUnit, WaitingThreadAborter waitingThreadAborter) throws ConnectionPoolTimeoutException, InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public void freeEntry(BasicPoolEntry basicPoolEntry, boolean z, long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BasicPoolEntry getFreeEntry(RouteSpecificPool routeSpecificPool, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BasicPoolEntry createEntry(RouteSpecificPool routeSpecificPool, ClientConnectionOperator clientConnectionOperator) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void deleteEntry(BasicPoolEntry basicPoolEntry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void deleteLeastUsedEntry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public void handleLostEntry(HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void notifyWaitingThread(RouteSpecificPool routeSpecificPool) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public void deleteClosedConnections() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.impl.conn.tsccm.AbstractConnPool
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/PoolEntryRequest.java

@@ -0,0 +1,12 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.concurrent.TimeUnit;
+import org.apache.http.conn.ConnectionPoolTimeoutException;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public interface PoolEntryRequest {
+    void abortRequest();
+
+    BasicPoolEntry getPoolEntry(long j, TimeUnit timeUnit) throws InterruptedException, ConnectionPoolTimeoutException;
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/RefQueueHandler.java

@@ -0,0 +1,9 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.Reference;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public interface RefQueueHandler {
+    void handleReference(Reference<?> reference);
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/RefQueueWorker.java

@@ -0,0 +1,28 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.lang.ref.ReferenceQueue;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RefQueueWorker implements Runnable {
+    protected final RefQueueHandler refHandler;
+    protected final ReferenceQueue<?> refQueue;
+    protected volatile Thread workerThread;
+
+    public RefQueueWorker(ReferenceQueue<?> referenceQueue, RefQueueHandler refQueueHandler) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // java.lang.Runnable
+    public void run() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public String toString() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/RouteSpecificPool.java

@@ -0,0 +1,75 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.LinkedList;
+import java.util.Queue;
+import org.apache.http.conn.routing.HttpRoute;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class RouteSpecificPool {
+    protected final LinkedList<BasicPoolEntry> freeEntries;
+    protected final int maxEntries;
+    protected int numEntries;
+    protected final HttpRoute route;
+    protected final Queue<WaitingThread> waitingThreads;
+
+    public RouteSpecificPool(HttpRoute httpRoute, int i) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final HttpRoute getRoute() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final int getMaxEntries() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean isUnused() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getCapacity() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final int getEntryCount() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public BasicPoolEntry allocEntry(Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void freeEntry(BasicPoolEntry basicPoolEntry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void createdEntry(BasicPoolEntry basicPoolEntry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean deleteEntry(BasicPoolEntry basicPoolEntry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void dropEntry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void queueThread(WaitingThread waitingThread) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean hasThread() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public WaitingThread nextThread() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void removeThread(WaitingThread waitingThread) {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/ThreadSafeClientConnManager.java

@@ -0,0 +1,72 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.concurrent.TimeUnit;
+import org.apache.http.conn.ClientConnectionManager;
+import org.apache.http.conn.ClientConnectionOperator;
+import org.apache.http.conn.ClientConnectionRequest;
+import org.apache.http.conn.ManagedClientConnection;
+import org.apache.http.conn.routing.HttpRoute;
+import org.apache.http.conn.scheme.SchemeRegistry;
+import org.apache.http.params.HttpParams;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class ThreadSafeClientConnManager implements ClientConnectionManager {
+    protected ClientConnectionOperator connOperator;
+    protected final AbstractConnPool connectionPool;
+    protected SchemeRegistry schemeRegistry;
+
+    public ThreadSafeClientConnManager(HttpParams httpParams, SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void finalize() throws Throwable {
+        throw new RuntimeException("Stub!");
+    }
+
+    public AbstractConnPool createConnectionPool(HttpParams httpParams) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public ClientConnectionOperator createConnectionOperator(SchemeRegistry schemeRegistry) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public SchemeRegistry getSchemeRegistry() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public ClientConnectionRequest requestConnection(HttpRoute httpRoute, Object obj) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void releaseConnection(ManagedClientConnection managedClientConnection, long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void shutdown() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getConnectionsInPool(HttpRoute httpRoute) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public int getConnectionsInPool() {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void closeIdleConnections(long j, TimeUnit timeUnit) {
+        throw new RuntimeException("Stub!");
+    }
+
+    @Override // org.apache.http.conn.ClientConnectionManager
+    public void closeExpiredConnections() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/WaitingThread.java

@@ -0,0 +1,36 @@
+package org.apache.http.impl.conn.tsccm;
+
+import java.util.Date;
+import java.util.concurrent.locks.Condition;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class WaitingThread {
+    public WaitingThread(Condition condition, RouteSpecificPool routeSpecificPool) {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final Condition getCondition() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final RouteSpecificPool getPool() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public final Thread getThread() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public boolean await(Date date) throws InterruptedException {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void wakeup() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void interrupt() {
+        throw new RuntimeException("Stub!");
+    }
+}

decompiled/sources/org/apache/http/impl/conn/tsccm/WaitingThreadAborter.java

@@ -0,0 +1,17 @@
+package org.apache.http.impl.conn.tsccm;
+
+@Deprecated
+/* loaded from: classes5.dex */
+public class WaitingThreadAborter {
+    public WaitingThreadAborter() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void abort() {
+        throw new RuntimeException("Stub!");
+    }
+
+    public void setWaitingThread(WaitingThread waitingThread) {
+        throw new RuntimeException("Stub!");
+    }
+}