Java ConnectionListener类代码示例

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
/**
 * 工厂模式获取连接对象 还没有连接服务器
 * @param connectionTimeOut   连接超时的时间
 * @param reconnectionAllowed 是否准许重连接
 * @param isPresence          是否在线
 * @param debugEnable         是否调试
 * @param securityMode        安全模式
 * @param connectionListener  连接监听器
 * @return
 */
public static XMPPConnection createXMPPConnection(int connectionTimeOut, boolean reconnectionAllowed, boolean isPresence, boolean debugEnable,
                                                  ConnectionConfiguration.SecurityMode securityMode, ConnectionListener connectionListener) {
    //设置是否开启DEBUG模式
    XMPPConnection.DEBUG_ENABLED = debugEnable;
    //设置连接地址、端口
    ConnectionConfiguration configuration = new ConnectionConfiguration(SERVERADDRESS, PORT);
    //设置服务器名称
    configuration.setServiceName(SERVERNAME);
    //设置是否需要SAS验证
    configuration.setSASLAuthenticationEnabled(false);
    //设置安全类型
    configuration.setSecurityMode(securityMode);
    //设置用户状态
    configuration.setSendPresence(isPresence);
    //设置是否准许重连接
    configuration.setReconnectionAllowed(reconnectionAllowed);
    //实例化连接对象
    XMPPConnection xmppConnection = new XMPPConnection(configuration);
    //添加连接监听器
    if (connectionListener != null) {
        xmppConnection.addConnectionListener(connectionListener);
    }
    return xmppConnection;
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
public void disconnect(Presence unavailablePresence) {
    if (!connected) {
        return;
    }
    shutdown(unavailablePresence);

    // Reset the connection flags
    wasAuthenticated = false;
    isFirstInitialization = true;

    // Notify connection listeners of the connection closing if done hasn't already been set.
    for (ConnectionListener listener : getConnectionListeners()) {
        try {
            listener.connectionClosed();
        }
        catch (Exception e) {
            // Catch and print any exception so we can recover
            // from a faulty listener and finish the shutdown process
            e.printStackTrace();
        }
    }
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
/**
 * Sends out a notification that there was an error with the connection
 * and closes the connection.
 *
 * @param e the exception that causes the connection close event.
 */
protected void notifyConnectionError(Exception e) {
    // Closes the connection temporary. A reconnection is possible
    shutdown(new Presence(Presence.Type.unavailable));
    // Print the stack trace to help catch the problem
    e.printStackTrace();
    // Notify connection listeners of the error.
    for (ConnectionListener listener : getConnectionListeners()) {
        try {
            listener.connectionClosedOnError(e);
        }
        catch (Exception e2) {
            // Catch and print any exception so we can recover
            // from a faulty listener
            e2.printStackTrace();
        }
    }
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
/**
 * Sends out a notification that there was an error with the connection and
 * closes the connection.
 * 
 * @param e
 *            the exception that causes the connection close event.
 */
protected void notifyConnectionError(Exception e) {
	// Closes the connection temporary. A reconnection is possible
	shutdown(new Presence(Presence.Type.unavailable));
	// Print the stack trace to help catch the problem
	e.printStackTrace();
	// Notify connection listeners of the error.
	for (ConnectionListener listener : getConnectionListeners()) {
		try {
			listener.connectionClosedOnError(e);
		} catch (Exception e2) {
			// Catch and print any exception so we can recover
			// from a faulty listener
			e2.printStackTrace();
		}
	}
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
/**
 * Configure a session, setting some action listeners...
 * 
 * @param connection
 *            The connection to set up
 */
private void installConnectionListeners(final Connection connection) {
    if (connection != null) {
        connectionListener = new ConnectionListener() {
            public void connectionClosed() {
                unregisterInstanceFor(connection);
            }

            public void connectionClosedOnError(java.lang.Exception e) {
                unregisterInstanceFor(connection);
            }

            public void reconnectingIn(int i) {
            }

            public void reconnectionSuccessful() {
            }

            public void reconnectionFailed(Exception exception) {
            }
        };
        connection.addConnectionListener(connectionListener);
    }
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
public void disconnect(Presence unavailablePresence) {
	if (!connected) {
		return;
	}
	shutdown(unavailablePresence);

	// Cleanup
	if (roster != null) {
		roster.cleanup();
		roster = null;
	}
	sendListeners.clear();
	recvListeners.clear();
	collectors.clear();
	interceptors.clear();

	// Reset the connection flags
	wasAuthenticated = false;
	isFirstInitialization = true;

	// Notify connection listeners of the connection closing if done hasn't
	// already been set.
	for (ConnectionListener listener : getConnectionListeners()) {
		try {
			listener.connectionClosed();
		} catch (Exception e) {
			// Catch and print any exception so we can recover
			// from a faulty listener and finish the shutdown process
			e.printStackTrace();
		}
	}
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
protected ClientBase(String aHarmonyHubIP, int aXmppPort, HubClientSessionLoggedInListener hubClientSessionLoggedInListener,
        ConnectionListener connectionListenerDelegate) {
    harmonyHubIP = aHarmonyHubIP;
    xmppPort = aXmppPort;
    clientSessionLoggedInDelegate = hubClientSessionLoggedInListener;
    connectionDelegate = connectionListenerDelegate;
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
private void init() {
    connection.addConnectionListener(new ConnectionListener() {

        @Override
        public void connectionClosed() {
            stopPingServerTask();
            handleDisconnect(connection);
        }

        @Override
        public void connectionClosedOnError(Exception arg0) {
            stopPingServerTask();
            handleDisconnect(connection);
        }

        @Override
        public void reconnectionSuccessful() {
            handleConnect();
            schedulePingServerTask();
        }

        @Override
        public void reconnectingIn(int seconds) {
        }

        @Override
        public void reconnectionFailed(Exception e) {
        }
    });

    instances.put(connection, this);
    schedulePingServerTask();
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    connection = createMock(MyXMPPConnection.class);
    connectionListenerCapture = new Capture<ConnectionListener>();
    interceptorCapture = new Capture<PacketInterceptor>();
    listenerCapture = new Capture<PacketListener>();
    packetCapture = new Capture<Packet>(CaptureType.ALL);

    connection.addConnectionListener(capture(connectionListenerCapture));
    expectLastCall().anyTimes();
    connection.addPacketListener(capture(listenerCapture), anyObject(PacketFilter.class));
    expectLastCall().anyTimes();
    connection.addPacketInterceptor(capture(interceptorCapture), anyObject(PacketFilter.class));
    expectLastCall().anyTimes();
    connection.sendPacket(capture(packetCapture));
    expectLastCall().anyTimes();
    
    Roster roster = createNiceMock(Roster.class);
    expect(connection.getRoster()).andStubReturn(roster);
    
    replay(connection, roster);
    handler = new XmppStreamHandler(connection);
    // Set max queue size to 10 and acks at 10/2 = 5
    handler.setMaxOutgoingQueueSize(10);
    listener = listenerCapture.getValue();
    interceptor = interceptorCapture.getValue();
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
public void disconnect(Presence unavailablePresence) {
    if (!connected) {
        return;
    }
    shutdown(unavailablePresence);

    // Cleanup
    if (roster != null) {
        roster.cleanup();
        roster = null;
    }
    sendListeners.clear();
    recvListeners.clear();
    collectors.clear();
    interceptors.clear();

    // Reset the connection flags
    wasAuthenticated = false;
    isFirstInitialization = true;

    // Notify connection listeners of the connection closing if done hasn't already been set.
    for (ConnectionListener listener : getConnectionListeners()) {
        try {
            listener.connectionClosed();
        }
        catch (Exception e) {
            // Catch and print any exception so we can recover
            // from a faulty listener and finish the shutdown process
            e.printStackTrace();
        }
    }
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
public ConnectionListener getConnectionListener() {
    return connectionListener;
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
public ConnectionListener getConnectionListener() {
	return connectionListener;
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
private PingManager(final Connection connection) {
    this.connection = connection;
    instances.put(connection, this);

    ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(connection);
    sdm.addFeature(NAMESPACE);

    PacketFilter pingPacketFilter = new PacketTypeFilter(Ping.class);
    connection.addPacketListener(new PacketListener() {
        /**
         * Sends a Pong for every Ping
         */
        public void processPacket(Packet packet) {
            if (pingMinDelta > 0) {
                // Ping flood protection enabled
                long currentMillies = System.currentTimeMillis();
                long delta = currentMillies - lastPingStamp;
                lastPingStamp = currentMillies;
                if (delta < pingMinDelta) {
                    return;
                }
            }
            Pong pong = new Pong((Ping)packet);
            connection.sendPacket(pong);
        }
    }
    , pingPacketFilter);
    connection.addConnectionListener(new ConnectionListener() {

        @Override
        public void connectionClosed() {
            maybeStopPingServerTask();
        }

        @Override
        public void connectionClosedOnError(Exception arg0) {
            maybeStopPingServerTask();
        }

        @Override
        public void reconnectionSuccessful() {
            maybeSchedulePingServerTask();
        }

        @Override
        public void reconnectingIn(int seconds) {
        }

        @Override
        public void reconnectionFailed(Exception e) {
        }
    });
    maybeSchedulePingServerTask();
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
public Set<ConnectionListener> getConnectionListeners() {
	return connectionListeners;
}
 

import org.jivesoftware.smack.ConnectionListener; //导入依赖的package包/类
public void setConnectionListeners(Set<ConnectionListener> connectionListeners) {
	this.connectionListeners = connectionListeners;
}