Java Type.DIRECT属性代码示例

private boolean shouldPipeline()
{
    if (!this.pipeline)
    {
        return false;
    }
    else
    {
        Proxy proxy = Minecraft.getMinecraft().getProxy();
        return proxy.type() != Type.DIRECT && proxy.type() != Type.SOCKS ? false : this.imageUrl.startsWith("http://");
    }
}
 

public void connectFailed(Route failedRoute, IOException failure) {
    if (!(failedRoute.getProxy().type() == Type.DIRECT || this.address.getProxySelector() ==
            null)) {
        this.address.getProxySelector().connectFailed(this.address.url().uri(), failedRoute
                .getProxy().address(), failure);
    }
    this.routeDatabase.failed(failedRoute);
}
 

private void resetNextInetSocketAddress(Proxy proxy) throws IOException {
    String socketHost;
    int socketPort;
    this.inetSocketAddresses = new ArrayList();
    if (proxy.type() == Type.DIRECT || proxy.type() == Type.SOCKS) {
        socketHost = this.address.getUriHost();
        socketPort = this.address.getUriPort();
    } else {
        SocketAddress proxyAddress = proxy.address();
        if (proxyAddress instanceof InetSocketAddress) {
            InetSocketAddress proxySocketAddress = (InetSocketAddress) proxyAddress;
            socketHost = getHostString(proxySocketAddress);
            socketPort = proxySocketAddress.getPort();
        } else {
            throw new IllegalArgumentException("Proxy.address() is not an InetSocketAddress: " +
                    "" + proxyAddress.getClass());
        }
    }
    if (socketPort < 1 || socketPort > 65535) {
        throw new SocketException("No route to " + socketHost + ":" + socketPort + "; port is" +
                " out of range");
    }
    if (proxy.type() == Type.SOCKS) {
        this.inetSocketAddresses.add(InetSocketAddress.createUnresolved(socketHost,
                socketPort));
    } else {
        List<InetAddress> addresses = this.address.getDns().lookup(socketHost);
        int size = addresses.size();
        for (int i = 0; i < size; i++) {
            this.inetSocketAddresses.add(new InetSocketAddress((InetAddress) addresses.get(i)
                    , socketPort));
        }
    }
    this.nextInetSocketAddressIndex = 0;
}
 

public final boolean usingProxy() {
    Proxy proxy;
    if (this.route != null) {
        proxy = this.route.getProxy();
    } else {
        proxy = this.client.getProxy();
    }
    return (proxy == null || proxy.type() == Type.DIRECT) ? false : true;
}
 

Type toType(){
    switch (this){
        case SOCKS: return Type.SOCKS;
        case HTTP: return Type.HTTP;
    }
    return  Type.DIRECT;
}
 

private InetAddress getConnectToInetAddress(Proxy proxy, HttpUrl url) throws IOException {
    if (proxy == null || proxy.type() == Type.DIRECT) {
        return InetAddress.getByName(url.host());
    }
    return ((InetSocketAddress) proxy.address()).getAddress();
}
 

public void connect(int connectTimeout, int readTimeout, int writeTimeout,
                    List<ConnectionSpec> connectionSpecs, boolean connectionRetryEnabled)
        throws RouteException {
    if (this.protocol != null) {
        throw new IllegalStateException("already connected");
    }
    RouteException routeException = null;
    ConnectionSpecSelector connectionSpecSelector = new ConnectionSpecSelector(connectionSpecs);
    Proxy proxy = this.route.getProxy();
    Address address = this.route.getAddress();
    if (this.route.getAddress().getSslSocketFactory() != null || connectionSpecs.contains
            (ConnectionSpec.CLEARTEXT)) {
        while (this.protocol == null) {
            try {
                Socket createSocket = (proxy.type() == Type.DIRECT || proxy.type() == Type
                        .HTTP) ? address.getSocketFactory().createSocket() : new Socket(proxy);
                this.rawSocket = createSocket;
                connectSocket(connectTimeout, readTimeout, writeTimeout,
                        connectionSpecSelector);
            } catch (IOException e) {
                Util.closeQuietly(this.socket);
                Util.closeQuietly(this.rawSocket);
                this.socket = null;
                this.rawSocket = null;
                this.source = null;
                this.sink = null;
                this.handshake = null;
                this.protocol = null;
                if (routeException == null) {
                    routeException = new RouteException(e);
                } else {
                    routeException.addConnectException(e);
                }
                if (!connectionRetryEnabled || !connectionSpecSelector.connectionFailed(e)) {
                    throw routeException;
                }
            }
        }
        return;
    }
    throw new RouteException(new UnknownServiceException("CLEARTEXT communication not " +
            "supported: " + connectionSpecs));
}