## net.i2p.client.streaming
Class ConnectionManager

    java.lang.Object
      net.i2p.client.streaming.ConnectionManager

public class ConnectionManager
extends java.lang.Object

Coordinate all of the connections for a single local destination.

Nested Class Summary
`(package private) static interface` `ConnectionManager.PingNotifier`

Constructor Summary
`ConnectionManager(I2PAppContext context, I2PSession session, int maxConcurrent, ConnectionOptions defaultOptions)`

Method Summary
`Connection` `connect(Destination peer, ConnectionOptions opts)` Build a new connection to the given peer.
`void` `disconnectAllHard()` Something b0rked hard, so kill all of our connections without mercy.
`boolean` `getAllowIncomingConnections()` should we acceot connections, or just reject everyone?
`(package private) Connection` `getConnectionByInboundId(long id)`
`(package private) Connection` `getConnectionByOutboundId(long id)` not guaranteed to be unique, but in case we receive more than one packet on an inbound connection that we havent ack'ed yet...
`ConnectionHandler` `getConnectionHandler()`
`MessageHandler` `getMessageHandler()`
`PacketHandler` `getPacketHandler()`
`PacketQueue` `getPacketQueue()`
`I2PSession` `getSession()`
`java.util.Set` `listConnections()` return a set of Connection objects
`boolean` `ping(Destination peer, long timeoutMs)`
`boolean` `ping(Destination peer, long timeoutMs, boolean blocking)`
`boolean` `ping(Destination peer, long timeoutMs, boolean blocking, SessionKey keyToUse, java.util.Set tagsToSend, ConnectionManager.PingNotifier notifier)`
`Connection` `receiveConnection(Packet synPacket)` Create a new connection based on the SYN packet we received.
`(package private) void` `receivePong(long pingId)`
`void` `removeConnection(Connection con)` Drop the (already closed) connection on the floor.
`void` `setAllowIncomingConnections(boolean allow)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ConnectionManager

    public ConnectionManager(I2PAppContext context,
                             I2PSession session,
                             int maxConcurrent,
                             ConnectionOptions defaultOptions)

Method Detail

### getConnectionByInboundId

    Connection getConnectionByInboundId(long id)

### getConnectionByOutboundId

    Connection getConnectionByOutboundId(long id)

  not guaranteed to be unique, but in case we receive more than one packet on an inbound connection that we havent ack'ed yet...

### setAllowIncomingConnections

    public void setAllowIncomingConnections(boolean allow)

### getAllowIncomingConnections

    public boolean getAllowIncomingConnections()

  should we acceot connections, or just reject everyone?

### receiveConnection

    public Connection receiveConnection(Packet synPacket)

  Create a new connection based on the SYN packet we received.

  Returns:
    created Connection with the packet's data already delivered to it, or null if the syn's streamId was already taken

### connect

    public Connection connect(Destination peer,
                              ConnectionOptions opts)

  Build a new connection to the given peer. This blocks if there is no connection delay, otherwise it returns immediately.

  Returns:
    new connection, or null if we have exceeded our limit

### getMessageHandler

    public MessageHandler getMessageHandler()

### getPacketHandler

    public PacketHandler getPacketHandler()

### getConnectionHandler

    public ConnectionHandler getConnectionHandler()

### getSession

    public I2PSession getSession()

### getPacketQueue

    public PacketQueue getPacketQueue()

### disconnectAllHard

    public void disconnectAllHard()

  Something b0rked hard, so kill all of our connections without mercy. Don't bother sending close packets.

### removeConnection

    public void removeConnection(Connection con)

  Drop the (already closed) connection on the floor.

### listConnections

    public java.util.Set listConnections()

  return a set of Connection objects

### ping

    public boolean ping(Destination peer,
                        long timeoutMs)

### ping

    public boolean ping(Destination peer,
                        long timeoutMs,
                        boolean blocking)

### ping

    public boolean ping(Destination peer,
                        long timeoutMs,
                        boolean blocking,
                        SessionKey keyToUse,
                        java.util.Set tagsToSend,
                        ConnectionManager.PingNotifier notifier)

### receivePong

    void receivePong(long pingId)