Java XmppModulesManager类代码示例

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
@Override
public XmppSessionLogic createSessionLogic(XmppModulesManager modulesManager, PacketWriter writer) {
	if (context.getSessionObject().getProperty(InBandRegistrationModule.IN_BAND_REGISTRATION_MODE_KEY) == Boolean.TRUE) {
		log.info("Using XEP-0077 mode!!!!");
		return new SocketInBandRegistrationXmppSessionLogic(this, modulesManager, context);
	} else
		return new SocketXmppSessionLogic(this, modulesManager, context);
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
public SocketInBandRegistrationXmppSessionLogic(SocketConnector connector, XmppModulesManager modulesManager,
		Context context) {
	this.connector = connector;
	this.modulesManager = modulesManager;
	this.context = context;

	this.streamFeaturesEventHandler = new StreamFeaturesReceivedHandler() {

		@Override
		public void onStreamFeaturesReceived(SessionObject sessionObject, Element featuresElement) throws JaxmppException {
			SocketInBandRegistrationXmppSessionLogic.this.processStreamFeatures(sessionObject, featuresElement);
		}
	};

	this.receivedErrorHandler = new ReceivedErrorHandler() {

		@Override
		public void onReceivedError(SessionObject sessionObject, IQ responseStanza, ErrorCondition errorCondition)
				throws JaxmppException {
			SocketInBandRegistrationXmppSessionLogic.this.connector.stop();
		}
	};
	this.receivedTimeoutHandler = new ReceivedTimeoutHandler() {

		@Override
		public void onReceivedTimeout(SessionObject sessionObject) throws JaxmppException {
			SocketInBandRegistrationXmppSessionLogic.this.connector.stop();
		}
	};
	this.notSupportedErrorHandler = new NotSupportedErrorHandler() {

		@Override
		public void onNotSupportedError(SessionObject sessionObject) throws JaxmppException {
			SocketInBandRegistrationXmppSessionLogic.this.connector.stop();
		}
	};

}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
@Override
public XmppSessionLogic createSessionLogic(XmppModulesManager modulesManager, PacketWriter writer) {
	if (sessionObject.getProperty(InBandRegistrationModule.IN_BAND_REGISTRATION_MODE_KEY) == Boolean.TRUE) {
		log.info("Using XEP-0077 mode!!!!");
		return new SocketInBandRegistrationXmppSessionLogic(this, modulesManager, sessionObject, writer);
	} else
		return new SocketXmppSessionLogic(this, modulesManager, sessionObject, writer);
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
public SocketInBandRegistrationXmppSessionLogic(SocketConnector connector, XmppModulesManager modulesManager,
		SessionObject sessionObject, PacketWriter writer) {
	this.connector = connector;
	this.modulesManager = modulesManager;
	this.sessionObject = sessionObject;

	this.streamFeaturesEventListener = new Listener<StreamFeaturesModule.StreamFeaturesReceivedEvent>() {

		@Override
		public void handleEvent(StreamFeaturesReceivedEvent be) throws JaxmppException {
			try {
				processStreamFeatures(be);
			} catch (JaxmppException e) {
				processException(e);
			}
		}
	};
	registrationListener = new Listener<BaseEvent>() {

		@Override
		public void handleEvent(BaseEvent be) throws JaxmppException {
			if (be.getType() == InBandRegistrationModule.ReceivedError) {
				SocketInBandRegistrationXmppSessionLogic.this.connector.stop();
			} else if (be.getType() == InBandRegistrationModule.ReceivedTimeout) {
				SocketInBandRegistrationXmppSessionLogic.this.connector.stop();
			} else if (be.getType() == InBandRegistrationModule.NotSupportedError) {
				SocketInBandRegistrationXmppSessionLogic.this.connector.stop();
			}
		}
	};
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
public PubSubModuleTest() {
	this.writer = new MockWriter(sessionObject);

	DefaultObservable observable = new DefaultObservable();
	XmppModulesManager xmppModulesManages = new XmppModulesManager(observable, writer);
	xmppModulesManages.register(new PingModule(sessionObject, writer));
	this.pubsub = new PubSubModule(null, sessionObject, this.writer);
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
public SocketXmppSessionLogic(SocketConnector connector, XmppModulesManager modulesManager, Context context) {
	super(connector, modulesManager, context);
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
protected AbstractSocketXmppSessionLogic(T connector, XmppModulesManager modulesManager, Context context) {
	this.connector = connector;
	this.modulesManager = modulesManager;
	this.context = context;

	this.connectorListener = new Connector.ErrorHandler() {

		@Override
		public void onError(SessionObject sessionObject, StreamError condition, Throwable caught) throws JaxmppException {
			AbstractSocketXmppSessionLogic.this.processConnectorErrors(condition, caught);
		}
	};

	this.streamFeaturesEventListener = new StreamFeaturesReceivedHandler() {

		@Override
		public void onStreamFeaturesReceived(SessionObject sessionObject, Element featuresElement) throws JaxmppException {
			AbstractSocketXmppSessionLogic.this.processStreamFeatures(featuresElement);
		}
	};

	this.authFailedHandler = new AuthFailedHandler() {

		@Override
		public void onAuthFailed(SessionObject sessionObject, SaslError error) throws JaxmppException {
			AbstractSocketXmppSessionLogic.this.processAuthFailed(error);
		}
	};
	this.authSuccessHandler = new AuthSuccessHandler() {

		@Override
		public void onAuthSuccess(SessionObject sessionObject) throws JaxmppException {
			AbstractSocketXmppSessionLogic.this.processAuthSuccess();
		}
	};
	this.resourceBindListener = new ResourceBindSuccessHandler() {

		@Override
		public void onResourceBindSuccess(SessionObject sessionObject, JID bindedJid) throws JaxmppException {
			AbstractSocketXmppSessionLogic.this.processResourceBindEvent(sessionObject, bindedJid);
		}
	};

	this.sessionEstablishmentErrorHandler = new SessionEstablishmentModule.SessionEstablishmentErrorHandler() {

		@Override
		public void onSessionEstablishmentError(SessionObject sessionObject, ErrorCondition error) throws JaxmppException {
			// FIXME
			sessionBindedAndEstablished(sessionObject);
		}
	};
	this.sessionEstablishmentSuccessHandler = new SessionEstablishmentModule.SessionEstablishmentSuccessHandler() {

		@Override
		public void onSessionEstablishmentSuccess(SessionObject sessionObject) throws JaxmppException {
			sessionBindedAndEstablished(sessionObject);
		}
	};

	this.smResumedListener = new StreamManagementModule.StreamResumedHandler() {

		@Override
		public void onStreamResumed(SessionObject sessionObject, Long h, String previd) throws JaxmppException {
			//sessionObject.clear(Scope.session);
			//resourceBinder.bind();
			AbstractSocketXmppSessionLogic.this.context.getEventBus().fire(new XmppSessionEstablishedHandler.XmppSessionEstablishedEvent(sessionObject));
		}
	};
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
public WebSocketXmppSessionLogic(AbstractWebSocketConnector connector, XmppModulesManager modulesManager, Context context) {
	super(connector, modulesManager, context);
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
@Override
public XmppSessionLogic createSessionLogic(XmppModulesManager modulesManager, PacketWriter writer) {
	return new BoshXmppSessionLogic(context, this, modulesManager);
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
@Override
public XmppSessionLogic createSessionLogic(XmppModulesManager modulesManager, PacketWriter writer) {
	return connector.createSessionLogic(modulesManager, writer);
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
@Override
public XmppSessionLogic createSessionLogic(XmppModulesManager modulesManager, PacketWriter writer) {
	return new WebSocketXmppSessionLogic(this, modulesManager, context);
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
public BoshXmppSessionLogic(Context context, Connector connector, XmppModulesManager modulesManager) {
	this.context = context;
	this.connector = connector;
	this.modulesManager = modulesManager;

	this.streamFeaturesReceivedHandler = new StreamFeaturesReceivedHandler() {

		@Override
		public void onStreamFeaturesReceived(SessionObject sessionObject, Element featuresElement) {
			try {
				BoshXmppSessionLogic.this.onStreamFeaturesReceived(sessionObject, featuresElement);
			} catch (JaxmppException e) {
				processException(e);
			}
		}
	};

	this.authSuccessHandler = new AuthSuccessHandler() {

		@Override
		public void onAuthSuccess(SessionObject sessionObject) {
			try {
				processAuthSucess(sessionObject);
			} catch (JaxmppException e) {
				processException(e);
			}
		}
	};
	this.authFailedHandler = new AuthFailedHandler() {

		@Override
		public void onAuthFailed(SessionObject sessionObject, SaslError error) {
			try {
				processAuthFail(sessionObject, error);
			} catch (JaxmppException e) {
				processException(e);
			}
		}
	};

	this.resourceBindErrorHandler = new ResourceBindErrorHandler() {

		@Override
		public void onResourceBindError(SessionObject sessionObject, ErrorCondition errorCondition) {
			BoshXmppSessionLogic.this.onResourceBindError(sessionObject, sessionObject);
		}
	};
	this.resourceBindSuccessHandler = new ResourceBindSuccessHandler() {

		@Override
		public void onResourceBindSuccess(SessionObject sessionObject, JID bindedJid) {
			try {
				BoshXmppSessionLogic.this.onResourceBindSuccess(sessionObject, bindedJid);
			} catch (JaxmppException e) {
				processException(e);
			}
		}
	};
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
@Override
public XmppModulesManager getModuleManager() {
    return this.jaxmpp.getModulesManager();
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
public SocketXmppSessionLogic(SocketConnector connector, XmppModulesManager modulesManager, SessionObject sessionObject,
		PacketWriter writer) {
	this.connector = connector;
	this.modulesManager = modulesManager;
	this.sessionObject = sessionObject;

	this.connectorListener = new Listener<Connector.ConnectorEvent>() {

		@Override
		public void handleEvent(Connector.ConnectorEvent be) throws JaxmppException {
			processConnectorEvents(be);
		}
	};

	this.streamFeaturesEventListener = new Listener<StreamFeaturesModule.StreamFeaturesReceivedEvent>() {

		@Override
		public void handleEvent(StreamFeaturesReceivedEvent be) throws JaxmppException {
			try {
				processStreamFeatures(be);
			} catch (JaxmppException e) {
				processException(e);
			}
		}
	};
	this.saslEventListener = new Listener<AuthModule.AuthEvent>() {

		@Override
		public void handleEvent(AuthModule.AuthEvent be) throws JaxmppException {
			try {
				if (be instanceof SaslEvent) {
					processSaslEvent((SaslEvent) be);
				} else if (be instanceof NonSaslAuthEvent) {
					processNonSaslEvent((NonSaslAuthEvent) be);
				}
			} catch (JaxmppException e) {
				processException(e);
			}
		}

	};
	this.resourceBindListener = new Listener<ResourceBindEvent>() {

		@Override
		public void handleEvent(ResourceBindEvent be) throws JaxmppException {
			try {
				processResourceBindEvent(be);
			} catch (JaxmppException e) {
				processException(e);
			}

		}
	};
	this.sessionEstablishmentListener = new Listener<SessionEstablishmentModule.SessionEstablishmentEvent>() {

		@Override
		public void handleEvent(SessionEstablishmentEvent be) throws JaxmppException {
			sessionBindedAndEstablished();
		}
	};
}
 

import tigase.jaxmpp.core.client.XmppModulesManager; //导入依赖的package包/类
@Override
public XmppSessionLogic createSessionLogic(XmppModulesManager modulesManager, PacketWriter writer) {
        return new BoshXmppSessionLogic(this, modulesManager, sessionObject, writer);
}