net.i2p.client.streaming

## Class I2PSocketManagerFull

- java.lang.Object
- - net.i2p.client.streaming.I2PSocketManagerFull

- All Implemented Interfaces:
    I2PSocketManager

      public class I2PSocketManagerFull
      extends Object
      implements I2PSocketManager

  Centralize the coordination and multiplexing of the local client's streaming. There should be one I2PSocketManager for each I2PSession, and if an application is sending and receiving data through the streaming library using an I2PSocketManager, it should not attempt to call I2PSession's setSessionListener or receive any messages with its .receiveMessage This is what I2PSocketManagerFactory.createManager() returns. Direct instantiation by others is deprecated.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface net.i2p.client.streaming.I2PSocketManager

      `I2PSocketManager.DisconnectListener`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static String` | `PROP_MAX_STREAMS` how many streams will we allow at once?

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `I2PSocketManagerFull()`
    `I2PSocketManagerFull(I2PAppContext context, I2PSession session, Properties opts, String name)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addDisconnectListener(I2PSocketManager.DisconnectListener lsnr)`
    `I2PSocketOptions` | `buildOptions()`
    `I2PSocketOptions` | `buildOptions(Properties opts)`
    `I2PSocket` | `connect(Destination peer)` Create a new connected socket.
    `I2PSocket` | `connect(Destination peer, I2PSocketOptions options)` Create a new connected socket.
    `Socket` | `connectToSocket(Destination peer)` Like connect() but returns a real Socket, and throws only IOE, for easier porting of apps.
    `Socket` | `connectToSocket(Destination peer, int timeout)` Like connect() but returns a real Socket, and throws only IOE, for easier porting of apps.
    `void` | `destroySocketManager()` Destroy the socket manager, freeing all the associated resources.
    `long` | `getAcceptTimeout()`
    `ConnectionManager` | `getConnectionManager()`
    `I2PSocketOptions` | `getDefaultOptions()`
    `String` | `getName()`
    `I2PServerSocket` | `getServerSocket()`
    `I2PSession` | `getSession()`
    `ServerSocket` | `getStandardServerSocket()` Like getServerSocket but returns a real ServerSocket for easier porting of apps.
    `void` | `init(I2PAppContext context, I2PSession session, Properties opts, String name)`
    `Set<I2PSocket>` | `listSockets()` Retrieve a set of currently connected I2PSockets, either initiated locally or remotely.
    `boolean` | `ping(Destination peer, long timeoutMs)` Ping the specified peer, returning true if they replied to the ping within the timeout specified, false otherwise.
    `I2PSocket` | `receiveSocket()`
    `void` | `removeDisconnectListener(I2PSocketManager.DisconnectListener lsnr)`
    `void` | `setAcceptTimeout(long ms)` How long should we wait for the client to .accept() a socket before sending back a NACK/Close?
    `void` | `setDefaultOptions(I2PSocketOptions options)`
    `void` | `setName(String name)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### PROP_MAX_STREAMS

          public static final String PROP_MAX_STREAMS

      how many streams will we allow at once?
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### I2PSocketManagerFull

          public I2PSocketManagerFull()

    - #### I2PSocketManagerFull

          public I2PSocketManagerFull(I2PAppContext context,
                              I2PSession session,
                              Properties opts,
                              String name)

      Parameters:
        `context` -
        `session` -
        `opts` -
        `name` -

  - ### Method Detail

    - #### init

          public void init(I2PAppContext context,
                  I2PSession session,
                  Properties opts,
                  String name)

      Specified by:
        `init` in interface `I2PSocketManager`
      Parameters:
        `context` -
        `session` -
        `opts` -
        `name` -

    - #### buildOptions

          public I2PSocketOptions buildOptions()

      Specified by:
        `buildOptions` in interface `I2PSocketManager`

    - #### buildOptions

          public I2PSocketOptions buildOptions(Properties opts)

      Specified by:
        `buildOptions` in interface `I2PSocketManager`

    - #### getSession

          public I2PSession getSession()

      Specified by:
        `getSession` in interface `I2PSocketManager`

    - #### getConnectionManager

          public ConnectionManager getConnectionManager()

    - #### receiveSocket

          public I2PSocket receiveSocket()
                                  throws I2PException,
                                         SocketTimeoutException

      Returns:
        connected I2PSocket OR NULL
      Throws:
        `I2PException`
        `SocketTimeoutException`

    - #### ping

          public boolean ping(Destination peer,
                     long timeoutMs)

      Ping the specified peer, returning true if they replied to the ping within the timeout specified, false otherwise. This call blocks.
      Specified by:
        `ping` in interface `I2PSocketManager`
      Parameters:
        `peer` -
        `timeoutMs` -
      Returns:
        true on success, false on failure

    - #### setAcceptTimeout

          public void setAcceptTimeout(long ms)

      How long should we wait for the client to .accept() a socket before sending back a NACK/Close?
      Specified by:
        `setAcceptTimeout` in interface `I2PSocketManager`
      Parameters:
        `ms` - milliseconds to wait, maximum

    - #### getAcceptTimeout

          public long getAcceptTimeout()

      Specified by:
        `getAcceptTimeout` in interface `I2PSocketManager`

    - #### setDefaultOptions

          public void setDefaultOptions(I2PSocketOptions options)

      Specified by:
        `setDefaultOptions` in interface `I2PSocketManager`

    - #### getDefaultOptions

          public I2PSocketOptions getDefaultOptions()

      Specified by:
        `getDefaultOptions` in interface `I2PSocketManager`

    - #### getServerSocket

          public I2PServerSocket getServerSocket()

      Specified by:
        `getServerSocket` in interface `I2PSocketManager`

    - #### getStandardServerSocket

          public ServerSocket getStandardServerSocket()
                                               throws IOException

      Like getServerSocket but returns a real ServerSocket for easier porting of apps.
      Specified by:
        `getStandardServerSocket` in interface `I2PSocketManager`
      Throws:
        `IOException`
      Since:
        0.8.4

    - #### connect

          public I2PSocket connect(Destination peer,
                          I2PSocketOptions options)
                            throws I2PException,
                                   NoRouteToHostException

      Create a new connected socket. Blocks until the socket is created, unless the connectDelay option (i2p.streaming.connectDelay) is set and greater than zero. If so this will return immediately, and the client may quickly write initial data to the socket and this data will be bundled in the SYN packet.
      Specified by:
        `connect` in interface `I2PSocketManager`
      Parameters:
        `peer` - Destination to connect to
        `options` - I2P socket options to be used for connecting, may be null
      Returns:
        I2PSocket if successful
      Throws:
        `NoRouteToHostException` - if the peer is not found or not reachable
        `I2PException` - if there is some other I2P-related problem

    - #### connect

          public I2PSocket connect(Destination peer)
                            throws I2PException,
                                   NoRouteToHostException

      Create a new connected socket. Blocks until the socket is created, unless the connectDelay option (i2p.streaming.connectDelay) is set and greater than zero in the default options. If so this will return immediately, and the client may quickly write initial data to the socket and this data will be bundled in the SYN packet.
      Specified by:
        `connect` in interface `I2PSocketManager`
      Parameters:
        `peer` - Destination to connect to
      Returns:
        I2PSocket if successful
      Throws:
        `NoRouteToHostException` - if the peer is not found or not reachable
        `I2PException` - if there is some other I2P-related problem

    - #### connectToSocket

          public Socket connectToSocket(Destination peer)
                                 throws IOException

      Like connect() but returns a real Socket, and throws only IOE, for easier porting of apps.
      Specified by:
        `connectToSocket` in interface `I2PSocketManager`
      Throws:
        `IOException`
      Since:
        0.8.4

    - #### connectToSocket

          public Socket connectToSocket(Destination peer,
                               int timeout)
                                 throws IOException

      Like connect() but returns a real Socket, and throws only IOE, for easier porting of apps.
      Specified by:
        `connectToSocket` in interface `I2PSocketManager`
      Parameters:
        `timeout` - ms if > 0, forces blocking (disables connectDelay)
      Throws:
        `IOException`
      Since:
        0.8.4

    - #### destroySocketManager

          public void destroySocketManager()

      Destroy the socket manager, freeing all the associated resources. This method will block untill all the managed sockets are closed.
      Specified by:
        `destroySocketManager` in interface `I2PSocketManager`

    - #### listSockets

          public Set<I2PSocket> listSockets()

      Retrieve a set of currently connected I2PSockets, either initiated locally or remotely.
      Specified by:
        `listSockets` in interface `I2PSocketManager`
      Returns:
        set of currently connected I2PSockets

    - #### getName

          public String getName()

      Specified by:
        `getName` in interface `I2PSocketManager`

    - #### setName

          public void setName(String name)

      Specified by:
        `setName` in interface `I2PSocketManager`

    - #### addDisconnectListener

          public void addDisconnectListener(I2PSocketManager.DisconnectListener lsnr)

      Specified by:
        `addDisconnectListener` in interface `I2PSocketManager`

    - #### removeDisconnectListener

          public void removeDisconnectListener(I2PSocketManager.DisconnectListener lsnr)

      Specified by:
        `removeDisconnectListener` in interface `I2PSocketManager`