Java CompletedCallback类代码示例

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
@Override
public void onAccepted(AsyncSocket socket) {
    // this example service shows only a single server <-> client communication
    if (asyncClient != null) {
        asyncClient.close();
    }
    asyncClient = (AsyncNetworkSocket) socket;
    asyncClient.setDataCallback(new DataCallback() {
        @Override
        public void onDataAvailable(DataEmitter emitter, ByteBufferList bb) {
            Timber.i("Data received: %s", bb.readString());
        }
    });
    asyncClient.setClosedCallback(new CompletedCallback() {
        @Override
        public void onCompleted(Exception ex) {
            asyncClient = null;
            Timber.i("Client socket closed");
        }
    });
    Timber.i("Client socket connected");
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
public static void handshake(AsyncSocket socket,
                             String host, int port,
                             SSLEngine sslEngine,
                             TrustManager[] trustManagers, HostnameVerifier verifier, boolean clientMode,
                             final HandshakeCallback callback) {
    AsyncSSLSocketWrapper wrapper = new AsyncSSLSocketWrapper(socket, host, port, sslEngine, trustManagers, verifier, clientMode);
    wrapper.handshakeCallback = callback;
    socket.setClosedCallback(new CompletedCallback() {
        @Override
        public void onCompleted(Exception ex) {
            if (ex != null)
                callback.onHandshakeCompleted(ex, null);
            else
                callback.onHandshakeCompleted(new SSLException("socket closed during handshake"), null);
        }
    });
    try {
        wrapper.engine.beginHandshake();
        wrapper.handleHandshakeStatus(wrapper.engine.getHandshakeStatus());
    } catch (SSLException e) {
        wrapper.report(e);
    }
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
private void recycleSocket(final AsyncSocket socket, AsyncHttpRequest request) {
    if (socket == null)
        return;
    Uri uri = request.getUri();
    int port = getSchemePort(uri);
    final String lookup = computeLookup(uri, port, request.getProxyHost(), request.getProxyPort());
    final ArrayDeque<IdleSocketHolder> sockets;
    final IdleSocketHolder idleSocketHolder = new IdleSocketHolder(socket);
    synchronized (AsyncSocketMiddleware.this) {
        ConnectionInfo info = getOrCreateConnectionInfo(lookup);
        sockets = info.sockets;
        sockets.push(idleSocketHolder);
    }
    socket.setClosedCallback(new CompletedCallback() {
        @Override
        public void onCompleted(Exception ex) {
            synchronized (AsyncSocketMiddleware.this) {
                sockets.remove(idleSocketHolder);
                maybeCleanupConnectionInfo(lookup);
            }
        }
    });
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
private void report(Exception e) {
    final HandshakeCallback hs = handshakeCallback;
    if (hs != null) {
        handshakeCallback = null;
        mSocket.setDataCallback(new DataCallback.NullDataCallback());
        mSocket.end();
        // handshake sets this callback. unset it.
        mSocket.setClosedCallback(null);
        mSocket.close();
        hs.onHandshakeCompleted(e, null);
        return;
    }

    CompletedCallback cb = getEndCallback();
    if (cb != null)
        cb.onCompleted(e);
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
    super.setUp();

    httpServer = new AsyncHttpServer();
    httpServer.setErrorCallback(new CompletedCallback() {
        @Override
        public void onCompleted(Exception ex) {
            fail();
        }
    });
    httpServer.listen(AsyncServer.getDefault(), 5000);
    

    httpServer.websocket("/ws", new WebSocketRequestCallback() {
        @Override
        public void onConnected(final WebSocket webSocket, AsyncHttpServerRequest request) {
            webSocket.setStringCallback(new StringCallback() {
                @Override
                public void onStringAvailable(String s) {
                    webSocket.send(s);
                }
            });
        }
    });
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
@Override
public void proxy(final AsyncHttpResponse remoteResponse) {
    code(remoteResponse.code());
    remoteResponse.headers().removeAll("Transfer-Encoding");
    remoteResponse.headers().removeAll("Content-Encoding");
    remoteResponse.headers().removeAll("Connection");
    getHeaders().addAll(remoteResponse.headers());
    // TODO: remove?
    remoteResponse.headers().set("Connection", "close");
    Util.pump(remoteResponse, this, new CompletedCallback() {
        @Override
        public void onCompleted(Exception ex) {
            remoteResponse.setEndCallback(new NullCompletedCallback());
            remoteResponse.setDataCallback(new DataCallback.NullDataCallback());
            end();
        }
    });
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
private CompletedCallback wrap() {
    return new CompletedCallback() {
        boolean mThisCompleted;
        @Override
        public void onCompleted(Exception ex) {
            // onCompleted may be called more than once... buggy code.
            // only accept the first (timeouts, etc)
            if (mThisCompleted)
                return;
            mThisCompleted = true;
            assert waiting;
            waiting = false;
            if (ex == null) {
                next();
                return;
            }
            reportCompleted(ex);
        }
    };
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
public void testContinuationFail() throws Exception {
    final Semaphore semaphore = new Semaphore(0);
    final Continuation c = new Continuation(new CompletedCallback() {
        @Override
        public void onCompleted(Exception ex) {
            assertNotNull(ex);
            semaphore.release();
        }
    });
    
    c.add(new ContinuationCallback() {
        @Override
        public void onContinue(Continuation continuation, CompletedCallback next) throws Exception {
            throw new Exception("fail");
        }
    });
    
    new Thread() {
        public void run() {
            c.start();
        };
    }.start();
    
    assertTrue(semaphore.tryAcquire(3000, TimeUnit.MILLISECONDS));
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
private void idleSocket(final AsyncSocket socket) {
    // must listen for socket close, otherwise log will get spammed.
    socket.setEndCallback(new CompletedCallback() {
        @Override
        public void onCompleted(Exception ex) {
            socket.setClosedCallback(null);
            socket.close();
        }
    });
    socket.setWriteableCallback(null);
    // should not get any data after this point...
    // if so, eat it and disconnect.
    socket.setDataCallback(new DataCallback.NullDataCallback() {
        @Override
        public void onDataAvailable(DataEmitter emitter, ByteBufferList bb) {
            super.onDataAvailable(emitter, bb);
            bb.recycle();
            socket.setClosedCallback(null);
            socket.close();
        }
    });
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
public static AsyncHttpRequestBody getBody(DataEmitter emitter, CompletedCallback reporter, Headers headers) {
    String contentType = headers.get("Content-Type");
    if (contentType != null) {
        String[] values = contentType.split(";");
        for (int i = 0; i < values.length; i++) {
            values[i] = values[i].trim();
        }
        for (String ct: values) {
            if (UrlEncodedFormBody.CONTENT_TYPE.equals(ct)) {
                return new UrlEncodedFormBody();
            }
            if (JSONObjectBody.CONTENT_TYPE.equals(ct)) {
                return new JSONObjectBody();
            }
            if (StringBody.CONTENT_TYPE.equals(ct)) {
                return new StringBody();
            }
            if (MultipartFormDataBody.CONTENT_TYPE.equals(ct)) {
                return new MultipartFormDataBody(values);
            }
        }
    }

    return null;
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
public void testContinuationArray() throws Exception {
    final ArrayList<Integer> results = new ArrayList<Integer>();
    final Semaphore semaphore = new Semaphore(0);
    final Continuation c = new Continuation(new CompletedCallback() {
        @Override
        public void onCompleted(Exception ex) {
            semaphore.release();
        }
    });
    
    for (int i = 0; i < 10; i++) {
        final int j = i;
        c.add(new ContinuationCallback() {
            @Override
            public void onContinue(Continuation continuation, CompletedCallback next) throws Exception {
                results.add(j);
                next.onCompleted(null);
            }
        });
    }
    
    new Thread() {
        public void run() {
            c.start();
        };
    }.start();
    
    assertTrue(semaphore.tryAcquire(3000, TimeUnit.MILLISECONDS));
    
    assertEquals(10, results.size());
    for (int i = 0; i < 10; i++) {
        assertEquals((int)results.get(i), i);
    }
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
public Continuation add(final DependentFuture future) {
    future.setParent(this);
    add(new ContinuationCallback() {
        @Override
        public void onContinue(Continuation continuation, CompletedCallback next) throws Exception {
            future.get();
            next.onCompleted(null);
        }
    });
    return this;
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
public static void writeAll(final DataSink sink, final ByteBufferList bb, final CompletedCallback callback) {
    WritableCallback wc;
    sink.setWriteableCallback(wc = new WritableCallback() {
        @Override
        public void onWriteable() {
            sink.write(bb);
            if (bb.remaining() == 0 && callback != null) {
                sink.setWriteableCallback(null);
                callback.onCompleted(null);
            }
        }
    });
    wc.onWriteable();
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
@Override
public void setClosedCallback(CompletedCallback handler) {
    if (mSink != null)
        mSink.setClosedCallback(handler);
    else
        closedCallback = handler;
}
 

import com.koushikdutta.async.callback.CompletedCallback; //导入依赖的package包/类
@Override
public void parse(DataEmitter emitter, final CompletedCallback completed) {
    new StringParser().parse(emitter).setCallback(new FutureCallback<String>() {
        @Override
        public void onCompleted(Exception e, String result) {
            string = result;
            completed.onCompleted(e);
        }
    });
}