中文简体    English

IvyIoT P2P SDK Programming Guide

1. Overview

  P2P SDK is a software development kit provided by IvyIoT for smart hardware devices and mobile phone apps of third-party manufacturers. Users can easily connect hardware devices and mobile phone apps to IvyIoT cloud services by embedding P2P SDK in device firmware and mobile phone apps Support the rapid establishment of P2P connection between APP and hardware devices, and finally realize the real-time audio and video data transmission between APP and hardware devices.

The P2P SDK is provided in the form of library files. The entire SDK folder structure is as follows:
Doc folder：stores documents related to the P2P SDK, such as interface description documents and demo program usage documents.
Include folder：stores the header files provided by the P2P SDK.
Lib folder：store the library files provided by P2P SDK. (Based on different hardware platforms and system environments)
Sample folder：store the demo program. (Based on different hardware platforms and system environments)

2. P2P SDK overall application architecture

  In order to embed P2P SDK into APP and device firmware, you first need to understand the overall application architecture of P2P SDK. As shown in the figure below, when the P2P SDK is running, there are two internal working modes: passive mode and active mode. For the firmware side of the hardware device, the P2P SDK should be run in passive mode. For the APP side, the P2P SDK should be run in active mode.

  When both ends are working normally, triggered by APP, a P2P transmission channel will be established between the P2P SDKs at both ends. At this time, the P2P SDK on the APP side will work in the local server mode, and the P2P SDK on the device side will work in the local client mode as shown in the figure below.

  In order to realize the data transmission between the APP and the hardware device, the device firmware must work as a server . After the P2P connection is successfully established, the device-side P2P_SDK connects to the firmware server through the socket in client mode. Similarly, the APP must work in client mode . After the P2P connection is successfully established, the APP connects to the local server in the local P2P SDK through the socket in client mode. In the end, P2P SDK realizes the P2P data transmission between APP and hardware devices in the form of a transmission agent.

3. The overall process of P2P SDK interface call

  As shown in the figure above, many of the calling interfaces of the P2P SDK involve network communication. In order to ensure execution efficiency and simplify the complexity of application layer software design, these interface functions are designed to be in non-blocking mode. The form of the function is notified to the upper application asynchronously. The type of these callback functions is defined in the header file of the P2P SDK. The specific implementation needs to be completed by the user application and registered in the P2P SDK through the relevant interface.
  The C2 function interface of the P2P SDK will be used as an example to explain the calling logic of the SDK interface. For the Andriod platform, the SDK interface is packaged in JNI format. For the specific interface description, please refer to the P2PClient.class file in the IvyP2PDemo program and the last part of this article.

4. Key data types of P2P SDK

5. Detailed description of the device-side function interface

5.1 SDK initialization

5.2 Query free P2P servers

5.3 P2P server query result callback function

5.4 Release dispatcher object

5.5 Connect to P2P server

5.6 P2P server connection result callback function

5.7 P2P server connection interruption callback function

5.8 Actively disconnect from P2P server

5.9 Callback function for receiving remote P2P connection request

5.10 SDK deinitialization

6. Detailed description of APP function interface

6.1 SDK initialization （as same as device side）

6.2 Query the P2P server to which the target device belongs

6.3 P2P server query result callback function （as same as device side）

6.4 Release the dispatcher object（as same as device side）

6.5 Connect to P2P server（as same as device side）

6.6 P2P server connection result callback function（as same as device side）

6.7 P2P server connection interruption callback function（as same as device side）

6.8 Actively disconnect from the P2P server（as same as device side）

6.9 Initiate a P2P connection request to the device

6.10 P2P connection result callback function

6.11 P2P connection interrupt callback function

6.12 Actively disconnect the specified P2P connection

6.13 Create a local proxy service

6.14 Destroy the local proxy service

6.15 SDK deinitialization（as same as device side）

7 Detailed description of the Andriod platform interface

For the Andriod platform, the P2P SDK uses JNI to encapsulate into a java interface class. The specific interfaces are as follows:

public class P2PClient {
    public P2PClient() {
    }

    public static native int init(); // SDK initialization
    public static native void uninit(); // SDK deinitialization

    // Connect P2P server
    private static native P2PResult p2p_transport_create(
                        String server, // P2P server address
                        int port, // P2P server port
                        String user, // device UID
                        String password, // device KEY
                        int terminal_type, // APP:1
                                            // device:0
                        int user_data, // default is 0
                        int use_tcp_connect_srv, //default is 0
                        String proxy_addr, // default is 0
                        Object cb); // callback object

    // Connect P2P server
    public static P2PResult p2p_transport_create(p2p_transport_cfg cfg) {
            return p2p_transport_create(cfg.server, cfg.port, cfg.user,
                            cfg.password, cfg.terminal_type, cfg.user_data,
                            cfg.use_tcp_connect_srv, cfg.proxy_addr, cfg.cb);
    }

    // actively disconnect from P2P server
    public static native void p2p_transport_destroy(int transport);

    //  initiate a P2P connection request to the device side
    public static native P2PResult p2p_transport_connect(
                                    int transport, 
                                    String user, 
                                    int user_data); 

    // actively disconnect the specified P2P connection
    public static native void p2p_transport_disconnect(int transport, int conn_id);

    // create a local proxy service
    public static native P2PResult p2p_create_tcp_proxy(int transport, 
                                        int conn_id, int remote_listen_port);

    // destroy the local proxy service
    public static native void p2p_destroy_tcp_proxy(int transport, 
                                        int conn_id, int local_proxy_port);

    //  query free P2P Server
    public static native int p2p_request_dispatch_server(
                                                    String user,
                                                    String password,
                                                    String ds_addr,
                                                    int user_data,
                            P2PClient.P2PClientDispatchCallBack cb);

    //  Query the P2P server to which the target device belongs。
    public static native int p2p_query_dispatch_server(
                                                String dest_user,
                                                String ds_addr,
                                                int user_data,
                            P2PClient.P2PClientDispatchCallBack cb);

    public static native int p2p_conn_set_buf_size(int transport, int conn_id, int opt, int size);

    // callback object
    public interface P2PClientCallBack {
        void on_create_complete(int transport, int status, int user_data);

void on_connect_complete(int transport,
                                int connection_id,
                                int status,
                                int transport_user_data,
                                int connect_user_data);

        void on_connection_disconnect(int transport,
                                    int connection_id,
                                    int transport_user_data,
                                    int connect_user_data);

        void on_accept_remote_connection(int transport,
                                        int connection_id,
                                        int transport_user_data);
    }

    public interface P2PClientDispatchCallBack {
        void on_dispatch_result(int status,
                                int user_data,
                                String server,
                                int port,
                                int server_id);
    }
}