import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/**
 * Handler for pending call result. Dispatches results to all pending call handlers.
 * 
 * @param conn
 *            Connection
 * @param invoke
 *            Pending call result event context
 */
protected void handlePendingCallResult(RTMPConnection conn, Invoke invoke) {
    final IServiceCall call = invoke.getCall();
    final IPendingServiceCall pendingCall = conn.retrievePendingCall(invoke.getTransactionId());
    if (pendingCall != null) {
        // The client sent a response to a previously made call.
        Object[] args = call.getArguments();
        if (args != null && args.length > 0) {
            // TODO: can a client return multiple results?
            pendingCall.setResult(args[0]);
        }
        Set<IPendingServiceCallback> callbacks = pendingCall.getCallbacks();
        if (!callbacks.isEmpty()) {
            HashSet<IPendingServiceCallback> tmp = new HashSet<>();
            tmp.addAll(callbacks);
            for (IPendingServiceCallback callback : tmp) {
                try {
                    callback.resultReceived(pendingCall);
                } catch (Exception e) {
                    log.error("Error while executing callback {}", callback, e);
                }
            }
        }
    }
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/**
 * Handler for pending call result. Dispatches results to all pending call
 * handlers.
 * 
 * @param conn
 *            Connection
 * @param invoke
 *            Pending call result event context
 */
protected void handlePendingCallResult(RTMPConnection conn, Notify invoke) {
	final IServiceCall call = invoke.getCall();
	final IPendingServiceCall pendingCall = conn.retrievePendingCall(invoke.getInvokeId());
	if (pendingCall != null) {
		// The client sent a response to a previously made call.
		Object[] args = call.getArguments();
		if (args != null && args.length > 0) {
			// TODO: can a client return multiple results?
			pendingCall.setResult(args[0]);
		}
		Set<IPendingServiceCallback> callbacks = pendingCall.getCallbacks();
		if (!callbacks.isEmpty()) {
			HashSet<IPendingServiceCallback> tmp = new HashSet<IPendingServiceCallback>();
			tmp.addAll(callbacks);
			for (IPendingServiceCallback callback : tmp) {
				try {
					callback.resultReceived(pendingCall);
				} catch (Exception e) {
					log.error("Error while executing callback {}", callback, e);
				}
			}
		}
	}
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
public MessageSender(IConnection current, IScope _scope, String method, Object msg, IPendingServiceCallback callback) {
	this.current = current;
	scope = _scope == null && current != null ? current.getScope() : _scope;
	this.method = method;
	this.msg = msg;
	this.callback = callback;
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/**
 * When the connection has been closed, notify any remaining pending service calls that they have failed because the connection is
 * broken. Implementors of IPendingServiceCallback may only deduce from this notification that it was not possible to read a result for
 * this service call. It is possible that (1) the service call was never written to the service, or (2) the service call was written to
 * the service and although the remote method was invoked, the connection failed before the result could be read, or (3) although the
 * remote method was invoked on the service, the service implementor detected the failure of the connection and performed only partial
 * processing. The caller only knows that it cannot be confirmed that the callee has invoked the service call and returned a result.
 */
public void sendPendingServiceCallsCloseError() {
    if (pendingCalls != null && !pendingCalls.isEmpty()) {
        if (log.isDebugEnabled()) {
            log.debug("Connection calls pending: {}", pendingCalls.size());
        }
        for (IPendingServiceCall call : pendingCalls.values()) {
            call.setStatus(Call.STATUS_NOT_CONNECTED);
            for (IPendingServiceCallback callback : call.getCallbacks()) {
                callback.resultReceived(call);
            }
        }
    }
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/** {@inheritDoc} */
public void invoke(String method, Object[] params, IPendingServiceCallback callback) {
    IPendingServiceCall call = new PendingCall(method, params);
    if (callback != null) {
        call.registerCallback(callback);
    }
    invoke(call);
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/**
 * Invoke a method on the server.
 * 
 * @param method
 *            Method name
 * @param callback
 *            Callback handler
 */
@Override
public void invoke(String method, IPendingServiceCallback callback) {
    log.debug("invoke method: {} params {} callback {}", new Object[] { method, callback });
    // get it from the conn manager
    if (conn != null) {
        conn.invoke(method, callback);
    } else {
        log.info("Connection was null");
        PendingCall result = new PendingCall(method);
        result.setStatus(Call.STATUS_NOT_CONNECTED);
        callback.resultReceived(result);
    }
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
public void sendToRelay(String functionName, Object[] params) {

        Object[] functionplusparams = new Object[params.length+1];
        functionplusparams[0]=functionName;
        for (int i=1; i<functionplusparams.length; i++) functionplusparams[i]=params[i-1];
        invoke("fromRelayClient", functionplusparams, new IPendingServiceCallback() {
            @Override
            public void resultReceived(IPendingServiceCall iPendingServiceCall) {

            }
        });
    }
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/**
 * When the connection has been closed, notify any remaining pending service calls that they have failed because
 * the connection is broken. Implementors of IPendingServiceCallback may only deduce from this notification that
 * it was not possible to read a result for this service call. It is possible that (1) the service call was never
 * written to the service, or (2) the service call was written to the service and although the remote method was
 * invoked, the connection failed before the result could be read, or (3) although the remote method was invoked
 * on the service, the service implementor detected the failure of the connection and performed only partial
 * processing. The caller only knows that it cannot be confirmed that the callee has invoked the service call
 * and returned a result.
 */
public void sendPendingServiceCallsCloseError() {
	if (pendingCalls != null && !pendingCalls.isEmpty()) {
		for (IPendingServiceCall call : pendingCalls.values()) {
			call.setStatus(Call.STATUS_NOT_CONNECTED);
			for (IPendingServiceCallback callback : call.getCallbacks()) {
				callback.resultReceived(call);
			}
		}
	}
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/** {@inheritDoc} */
public void invoke(String method, Object[] params, IPendingServiceCallback callback) {
	IPendingServiceCall call = new PendingCall(method, params);
	if (callback != null) {
		call.registerCallback(callback);
	}
	invoke(call);
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
@Override
public void invoke(String name, Object[] params, IPendingServiceCallback callback) {
	if ("echo".equals(name)) {
		echo(params);
	}		
	IPendingServiceCall call = new PendingCall(null, name, params);
	call.setResult(Boolean.TRUE);
	callback.resultReceived(call);
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/** {@inheritDoc} */
public void registerCallback(IPendingServiceCallback callback) {
    callbacks.add(callback);
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/** {@inheritDoc} */
public void unregisterCallback(IPendingServiceCallback callback) {
    callbacks.remove(callback);
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/** {@inheritDoc} */
public Set<IPendingServiceCallback> getCallbacks() {
    return callbacks;
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
public ClientInvokeEvent(String method, Object[] params, IPendingServiceCallback callback) {
    super(Type.CLIENT_INVOKE);
    this.method = method;
    this.params = params;
    this.callback = callback;
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
public final static ClientInvokeEvent build(String method, Object[] params, IPendingServiceCallback callback) {
    ClientInvokeEvent event = new ClientInvokeEvent(method, params, callback);
    return event;
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
/**
 * @return the callback
 */
public IPendingServiceCallback getCallback() {
    return callback;
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
@Override
public void createStream(IPendingServiceCallback callback) {
    log.debug("createStream - callback: {}", callback);
    IPendingServiceCallback wrapper = new CreateStreamCallBack(callback);
    invoke("createStream", null, wrapper);
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
public void releaseStream(IPendingServiceCallback callback, Object[] params) {
    log.debug("releaseStream - callback: {}", callback);
    IPendingServiceCallback wrapper = new ReleaseStreamCallBack(callback);
    invoke("releaseStream", params, wrapper);
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
public void deleteStream(IPendingServiceCallback callback) {
    log.debug("deleteStream - callback: {}", callback);
    IPendingServiceCallback wrapper = new DeleteStreamCallBack(callback);
    invoke("deleteStream", null, wrapper);
}
 

import org.red5.server.api.service.IPendingServiceCallback; //导入依赖的package包/类
public void subscribe(IPendingServiceCallback callback, Object[] params) {
    log.debug("subscribe - callback: {}", callback);
    IPendingServiceCallback wrapper = new SubscribeStreamCallBack(callback);
    invoke("FCSubscribe", params, wrapper);
}