JavaScript promise rejection: Loading CSS chunk katex failed. (error: https://free-git.org/assets/css/katex.fb6ef55c.css). Open browser console to see more details.
Go to file
openharmony_ci 1b61e9fddf
IT6传输模块分支覆盖率专项
Merge pull request  from 张再尧/master
2022-10-26 04:01:38 +00:00
adapter feat:characteristic separation 2022-10-21 17:25:40 +08:00
components 修改软总线gn冗余 2022-09-24 11:02:28 +08:00
core IT6传输模块分支覆盖率专项 2022-10-26 04:01:38 +00:00
figures Add dsoftbus-architecture picture. 2021-07-31 14:45:49 +08:00
interfaces update interfaces/kits/bus_center/softbus_bus_center.h. 2022-10-17 08:36:57 +00:00
sdk Branch override 2022-10-25 11:47:57 +08:00
tests IT6传输模块分支覆盖率专项 2022-10-26 04:01:38 +00:00
tools feat:sync database change status when online for distribute fwk 2022-10-10 16:18:58 +00:00
.clang-format Support muti protocol on manageSide 2022-03-26 05:03:37 +00:00
.gitattributes update OpenHarmony 2.0 Canary 2021-06-02 02:20:56 +08:00
.gitignore chore(build): add nested repos to .gitignore 2022-10-06 20:21:11 +08:00
BUILD.gn Fix:Modify some file permissions 2022-03-28 15:37:10 +08:00
bundle.json IT6传输模块分支覆盖率专项 2022-10-26 04:01:38 +00:00
check_sub_module.py chmod check_sub_module.py 2022-03-31 19:10:55 +08:00
config.py add config file for dsoftbus 2021-08-23 19:14:31 +08:00
dsoftbus.gni feat:characteristic separation 2022-10-25 10:19:02 +08:00
hisysevent.yaml HiSysEvent需求遗留问题 2022-09-22 06:24:08 +00:00
Kconfig Fix:Modify softbus component name 2022-06-01 17:26:07 +08:00
LICENSE update OpenHarmony 2.0 Canary 2021-06-02 02:20:56 +08:00
OAT.xml ota 2021-09-29 19:17:01 +08:00
README_zh.md doc: add language flag 2022-09-27 16:38:07 +08:00
README.md fix update README 2022-07-11 17:12:58 +08:00

communication_dsoftbus

Introduction

There are various communication modes such as Wi-Fi and Bluetooth, and the usage of different communication modes varies greatly and often leads to problems. In addition, the convergence, sharing, and conflict of communication links cannot be handled. DSoftBus manages unified distributed communications between near-field devices and provides APIs for device discovery, connection, networking, and data transmission, regardless of the link type. It mainly provides the following capabilities:

  • Device discovery and connection in various communication modes, such as WLAN and Bluetooth
  • Unified device networking and topology management, and device information provisioning for data transmission
  • Channel setup for transmitting messages and bytes

You can use the APIs provided by DSoftBus to implement fast communications between devices without caring about the communication details, thereby deploying and running services across platforms.

Architecture

Figure 1 DSoftBus architecture

Directory Structure

The main code directory structure of DSoftBus is as follows:

/foundation/communication/dsoftbus
├── interfaces            # APIs
├── adapter               # Adapter code
├── core                  # Core code
│   ├── common            # Common code
│   ├── authentication    # Authentication code
│   ├── bus_center        # Networking code
│   ├── connection        # Connection code
│   ├── discovery         # Discovery code
│   ├── transmission      # Transmission code
│   └── frame             # Framework code
├── sdk                   # Service process code
│   ├── bus_center        # Networking code
│   ├── discovery         # Discovery code
│   ├── transmission      # Transmission code
│   └── frame             # Framework code
└── components            # Dependent component code

Constraints

  • The devices between which you want to set up a connection must be in the same LAN.
  • Before setting up a connection between two devices, you must bind the devices. For details about the binding process, see relevant descriptions in the Security subsystem readme file.

Usage

Usage Guidelines

NOTICE: To use RPC across devices, you must have the ohos.permission.DISTRIBUTED_DATASYNC permission which is a dangerous one.

A device can proactively discover a smartphone only when the smartphone has the Visible to all nearby devices feature enabled. (This feature is available in Settings > Super Device > Visible to > All nearby devices.)

1. Discovery

  • Publishing process
  1. Publish a service of your application.

    // Callbacks for service publishing
    typedef struct {
        void (*OnPublishSuccess)(int publishId); // Called when the service is published successfully.
        void (*OnPublishFail)(int publishId, PublishFailReason reason);// Called when the service fails to be published.
    } IPublishCallback;
    
    // Publish the service.
    int PublishService(const char *pkgName, const PublishInfo *info, const IPublishCallback *cb);
    
  2. Unpublish a service of your application.

    // Unpublish a service.
    int UnPublishService(const char *pkgName, int publishId);
    
  • Discovery process
  1. Discovery a specified device.

    // Callbacks for device discovery
    typedef struct {
        void (*OnDeviceFound)(const DeviceInfo *device); // Called when a device is found.
        void (*OnDiscoverFailed)(int subscribeId, DiscoveryFailReason failReason); // Called when the discovery fails to start.
        void (*OnDiscoverySuccess)(int subscribeId); // Called when the discovery starts successfully.
    } IDiscoveryCallback;
    
    // Start a device discovery.
    int StartDiscovery(const char *pkgName, const SubscribeInfo *info, const IDiscoveryCallback *cb);
    
  2. The DSoftBus notifies you of the device information via the callback once a device is found.

  3. Stop the discovery as you need.

    // Stop the discovery.
    int StopDiscovery(const char *pkgName, int subscribeId);
    

2. Networking

  1. Initiate a connection request with the address of the target device and the connection callback.

    // Address to connect to
    typedef struct {
        ConnectionAddrType type;
        union {
            struct BrAddr {
                char brMac[BT_MAC_LEN];
            } br;
            struct BleAddr {
                char bleMac[BT_MAC_LEN];
                uint8_t udidHash[UDID_HASH_LEN];
            } ble;
            struct IpAddr {
                char ip[IP_STR_MAX_LEN];
                uint16_t port; 
            } ip;
        } info;
        char peerUid[MAX_ACCOUNT_HASH_LEN];
    } ConnectionAddr;
    
    // Address types
    typedef enum {
        CONNECTION_ADDR_WLAN = 0,
        CONNECTION_ADDR_BR,
        CONNECTION_ADDR_BLE,
        CONNECTION_ADDR_ETH,
        CONNECTION_ADDR_MAX
    } ConnectionAddrType;
    
    // Callback for the connection result
    typedef void (*OnJoinLNNResult)(ConnectionAddr *addr, const char *networkId, int32_t retCode);
    
    // Initiate a connection request.
    int32_t JoinLNN(const char *pkgName, ConnectionAddr *target, OnJoinLNNResult cb);
    
  2. Wait for the connection result. If JoinLNN() returns success, the DSoftBus accepts the connection request and notifies you of the connection result through the callback. The addr parameter in the callback matches the target parameter in JoinLNN(). If retCode in the callback is 0, the connection is successful. In this case, the value of networkId is valid and will be used in the data transmission and disconnection APIs. If the value of retCode is not 0, the connection fails, and the value of networkId is invalid.

  3. Transmit data using transmission APIs.

  4. Initiate a disconnection request with the networkId and the callback.

    // Callback for the disconnection result
    typedef void (*OnLeaveLNNResult)(const char *networkId, int32_t retCode);
    
    // Initiate a disconnection request.
    int32_t LeaveLNN(const char *pkgName, const char *networkId, OnLeaveLNNResult cb);
    
  5. Wait until the disconnection is complete. The networkId parameter in OnLeaveLNNResult() matches networkId in LeaveLNN(). If retCode in the callback is 0, the disconnection is successful; otherwise, the disconnection fails. If the disconnection is successful, networkId becomes invalid and can no longer be used.

  6. Register and unregister callbacks for device state changes.

    // Device state events
    #define EVENT_NODE_STATE_ONLINE 0x1
    #define EVENT_NODE_STATE_OFFLINE 0x02
    #define EVENT_NODE_STATE_INFO_CHANGED 0x04
    #define EVENT_NODE_STATE_MASK 0x07
    
    // Device information
    typedef struct {
        char networkId[NETWORK_ID_BUF_LEN];
        char deviceName[DEVICE_NAME_BUF_LEN];
        uint16_t deviceTypeId;
    } NodeBasicInfo;
    
    // Device state event callbacks
    typedef struct {
        uint32_t events; // Networking event mask
        void (*onNodeOnline)(NodeBasicInfo *info);   // Called when the device gets online.
        void (*onNodeOffline)(NodeBasicInfo *info);  // Called when the device gets offline.
        void (*onNodeBasicInfoChanged)(NodeBasicInfoType type, NodeBasicInfo *info); // Called when the device information changes.
    } INodeStateCb;
    
    // Register the callback for device state events.
    int32_t RegNodeDeviceStateCb(const char *pkgName, INodeStateCb *callback);
    
    // Unregister the callback for device state events.
    int32_t UnregNodeDeviceStateCb(INodeStateCb *callback);
    

3. Transmission

  1. Create a session server with a listener. You can use the listener to monitor events such as opening and closing a session, and receiving messages or bytes.

    // Callbacks for session management
    typedef struct {
        int (*OnSessionOpened)(int sessionId, int result);
        void (*OnSessionClosed)(int sessionId);
        void (*OnBytesReceived)(int sessionId, const void *data, unsigned int dataLen);
        void (*OnMessageReceived)(int sessionId, const void *data, unsigned int dataLen);
        void (*OnStreamReceived)(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param);
        void (*OnQosEvent)(int sessionId, int eventId, int tvCount, const QosTv *tvList);
    } ISessionListener;
    
    // Create a session server.
    int CreateSessionServer(const char *pkgName, const char *sessionName, const ISessionListener* listener);
    
  2. Open a session for sending and receiving data.

    // Open a session.
    int OpenSession(const char *mySessionName, const char *peerSessionName, const char *peerNetworkId, const char *groupId, const SessionAttribute* attr);
    
  3. Send data to the peer device based on the session ID.

    // Send bytes.
    int SendBytes(int sessionId, const void *data, unsigned int len);
    // Send messages.
    int SendMessage(int sessionId, const void *data, unsigned int len);
    
  4. Close a session with a specified ID.

    // Close a session.
    void CloseSession(int sessionId);
    
  5. Remove the session server.

    // Remove the session server.
    int RemoveSessionServer(const char *pkgName, const char *sessionName);
    

Repositories Involved

DSoftBus subsystem

communication_dsoftbus

communication_bluetooth

communication_ipc

communication_wifi