OpenHarmony 分散ソフトバスプロセス分析 v1.0丨1。発見終了、リリースサービス

[[408690]]

詳細については、以下をご覧ください。

51CTOとHuaweiが共同で構築したHongmengテクノロジーコミュニティ

https://harmonyos..com

ソースコードディレクトリ:

ホームディレクトリ\foundation\communication\softbus_lite

 ├── authmanager【デバイス認証メカニズムとデバイス知識ベース管理を提供】
 ├── discovery【coapプロトコルに基づくデバイス検出メカニズムを提供する】
 ├── インターフェース
├── os_adapter【オペレーティングシステム適応層】
 ├── trans_service【認証とデータ転送チャネルを提供】
 └──ビルド.gn
 BUILD.gn の分析により、softbus_lite ディレクトリ全体のすべてのソース コード ファイルが動的ライブラリにコンパイルされることがわかります。
ソフト バスに依存する他のモジュールは、コンパイル時にこの動的ライブラリの依存関係を追加するだけです。
たとえば、分散スケジューリング サブシステムが配置されている bin ファイル基盤のコンパイルは、この動的ライブラリに依存します。

authmanager [デバイス認証メカニズムとデバイス知識ベース管理を提供する]

要求が見つかると、ProcessDataEvent 関数が呼び出され、パケットを受信し、パケット ヘッダーをチェックし、データ パケットの種類に基づいてさまざまな処理方法を決定します。主なタイプは3つあります。
 MODULE_AUTH_SDK 暗号化されたデータ タイプ
MODULE_TRUST_ENGINE 信頼型、直接データ転送
MODULE_CONNECTIONはIPとデバイスの認証を実行します
 
 ├──ビルド.gn
 ├── 含む
│ ├── auth_conn.h
 │ ├── auth_interface.h
 │ ├── bus_manager.h
 │ ├── msg_get_deviceid.h
 │ └── wifi_auth_manager.h
 └── 出典
    ├── auth_conn.c [送信、受信、認証、鍵取得機能を提供]
    ├── auth_interface.c [各セッションノード、各リンクノード、各キーノードを管理し、追加、削除、変更、照会などの機能を提供する]
    ├── bus_manager.c [主に、システム上にあるデバイスと新しいデバイス ノードの作成を監視するために使用される、deviceIp を介して 2 つの異なるリスナーを作成します。 OnConnectEventとOnDataEventの2つのコールバック関数があり、それぞれデバイスノードの基本操作とノードデータの処理に使用されます。
    ├── msg_get_deviceid.c [デバイスID、リンク情報、デバイス名、デバイスタイプなど、各デバイスに関する情報をcJSON形式で提供します。]
    └── wifi_auth_manager.c【主に接続管理とデータ受信機能を実装しています。接続管理には、接続の確立、切断、接続の検索が含まれます。データ受信には、データ取得、パケット ヘッダーおよびパケット長の検証が含まれており、パケット ヘッダー データの読み取りを簡素化するために、 int型と long 型のデータの受信関数が別々に実装されています。

検出 [coap プロトコルに基づくデバイス検出メカニズムを提供する]

 ├──ビルド.gn
 ├── coap [このディレクトリは主にCOAPプロトコルを担当しています]
 │ ├── 含む
│ │ ├── coap_adapter.h
 │ │ ├── coap_def.h
 │ │ ├── coap_discover.h
 │ │ ├── coap_socket.h
 │ │ ├── json_payload.h
 │ │ ├── nstackx_common.h
 │ │ ├── nstackx_database.h
 │ │ ├── nstackx_device.h
 │ │ ├── nstackx_error.h
 │ │ └── nstackx.h
 │ └── ソース
│ ├── coap_adapter.c
 │ ├── coap_discover.c【COAPベースのデバイス検出機能を実装】
 │ ├── coap_socket.c
 │ ├── json_payload.c
 │ ├── nstackx_common.c
 │ └── nstackx_device.c
 └── discovery_service【coapプロトコルをベースに軽量デバイス上でサービスを公開する機能を実現】
    ├── 含む
    │ ├── coap_service.h
    │ ├── common_info_manager.h
    │ └── 検出エラー.h
    └── 出典
        ├── coap_service.c
        ├── common_info_manager.c
        └── discovery_service.c 
         
検出を実装するための前提は、検出デバイスと受信デバイスが同じ LAN にあり、お互いのメッセージを受信できることを保証することです。一般的なプロセスは次のとおりです。 
 
エンド デバイスを検出し、coap プロトコルを使用してローカル エリア ネットワークでブロードキャストを送信します。
受信デバイスは、PublishService インターフェースを使用してサービスを公開します。ブロードキャストを受信した後、受信側は検出側に coap プロトコル ユニキャストを送信します。
検出エンドデバイスは、メッセージを受信した後、デバイス情報を更新します。

os_adapter [オペレーティング システム適応層]

 ├── 含む
│ └── os_adapter.h
 └── 出典
    ├── L0
    │ └── os_adapter.c
    └── L1
        └── os_adapter.c

trans_service [認証とデータ転送チャネルを提供する]

主にソケット、cJSON、スレッドロックインターフェースをカプセル化し、ユーザーの作成、監視、セッション管理、デバイス、コマンド、データなどの情報の取得を実現し、最終的に暗号化された伝送と復号化された伝送の 2 つの伝送チャネルを提供します。
 ├──ビルド.gn
 ├── 含む
│ ├── libdistbus
 │ │ ├── auth_conn_manager.h
 │ │ └── tcp_session_manager.h
 │ └── ユーティリティ
│ ├── aes_gcm.h
 │ ├── comm_defs.h
 │ ├── data_bus_error.h
 │ ├── メッセージ.h
 │ └── tcp_socket.h
 └── 出典
    ├── libdistbus
    │ ├── auth_conn_manager.c 【ユーザー作成、監視、接続、その他サービス管理】
    │ ├── tcp_session.c 【セッション管理】
    │ ├── tcp_session.h
    │ ├── tcp_session_manager.c
    │ ├── trans_lock.c [ミューテックスの初期化とミューテックスリソースの取得と解放]
    │ └── trans_lock.h
    └──ユーティリティ
        ├── aes_gcm.c [暗号化送信と復号化送信のインターフェースを提供]
        ├── message.c [cJSON形式で管理されているデバイス（デバイス名、デバイスタイプ、デバイスIDなどを含む）、命令、データ、セッション（ユーザーポート、セッションポートなどを含む）などの情報を取得するために使用されます]
        └── tcp_socket.c [ポート番号管理とデータ転送管理]

1. ソフトバスの初期化方法

ソフト バス モジュールの呼び出しは複雑ではありません。ドラゴンを召喚するには、略して StartBus() と呼ばれる 2 つの構造体を準備するだけで済みます。以下では、Hi3861 を例に簡単な例を記述します。

静的void InitSoftbus(void)
 {printf( ">>>>>%s:%d:%s()\n" ,__FILE__,__LINE__,__FUNCTION__);
静的パブリッシュ情報 g_publishInfo = {
        .capabilityData = (符号なしchar *) "1" ,
        .capability = "ddmpCapability" 、
        .データ長 = 1,
        .publishId = 1、
        .mode = DISCOVER_MODE_ACTIVE、
        .medium = COAP、
        .freq = 中、
    };
静的IPublishCallback g_publishCallback = {
        .onPublishSuccess = 成功時、
        .onPublishFail = 失敗時、
    }; 
 
 int ret = PublishService(g_demoModuleName、&g_publishInfo、&g_publishCallback);
    戻り値が 0 の場合
        printf( "PublishServiceエラー\n" );
    }
    睡眠(5);
    ret = CreateSessionServer(g_demoModuleName、g_demoSessionName、&g_sessionCallback);
    戻り値が 0 の場合
        printf( "CreateSessionServerエラー\n" );
    }
    printf( "InitSoftbus ok\n" );
 }

1. 発見者になってサービスを公開します。 【発見ディレクトリ】

分散ソフト バス サブシステムでは、デバイスは検出端と検出端に分割されます。ここでは、携帯電話を検出側として使用し、Hi3861 開発ボードを検出側としてサービスを公開します。

サービスの公開は主に PublishService() 関数を通じて行われます。関連するコードは、メイン ディレクトリ\foundation\communication\softbus_lite\discovery_service フォルダーにあります。

デバイスがソフト バス サービスを公開する場合は、次の関数を呼び出す必要があります。

 //moduleName: 呼び出しモジュール名
//info: PublishInfo 構造体
//cb: 公開の成功または失敗のコールバック関数
int PublishService(const char *moduleName、const struct PublishInfo *info、const struct IPublishCallback *cb)
 {printf( "[>>>>%s:%d:%s()[ソフトバス初期化開始]\n" ,__FILE__,__LINE__,__FUNCTION__);
    //権限チェック。まず公開権限があるかどうかを確認します。ここで、os_adapter [オペレーティング システム適応層] の関連部分が呼び出されます。
    if (SoftBusCheckPermission(SOFTBUS_PERMISSION) != 0 || info == NULL || cb == NULL ) {
        SOFTBUS_PRINT( "[DISCOVERY] PublishService のパラメータ(info または cb)が無効です\n" );
 ERROR_INVALID を返します。
    } 
 
    //パラメータの有効性チェック: 公開されたいくつかのパラメータの有効性をチェックし、公開プロトコルが COAP であるかどうかを確認します。
    if (moduleName == NULL || strlen(moduleName) >= MAX_PACKAGE_NAME || info->publishId <= 0 ||
        info->dataLen > MAX_CAPABILITY_DATA_LEN) {
        SOFTBUS_PRINT( "[DISCOVERY] PublishService パラメータが無効です\n" );
        PublishCallback(info->publishId、PUBLISH_FAIL_REASON_PARAMETER_INVALID、 NULL 、cb);
 ERROR_INVALID を返します。
    }//パラメータチェックが失敗した場合は、PublishCallback() を呼び出して、cb 内の失敗コールバック関数をコールバックします。
    if (info->medium != COAP) {
        PublishCallback(info->publishId、PUBLISH_FAIL_REASON_NOT_SUPPORT_MEDIUM、 NULL 、cb);
 ERROR_INVALID を返します。
    } 
 
    //複数のデバイスがサービスを公開することで発生する競合を防ぐために g_discoveryMutex を使用する
    g_discoveryMutex == NULLの場合{
        g_discoveryMutex = MutexInit();
        g_discoveryMutex == NULLの場合{
            PublishCallback(info->publishId、PUBLISH_FAIL_REASON_UNKNOWN、 NULL 、cb);
 ERROR_FAIL を返します。
        }
    }
    ミューテックスロック(g_discoveryMutex); //ミューテックスロックを解除する
     
    //InitService() この関数はより重要です。 1. InitService() を初期化してサービスを発見するを参照してください。
    (InitService() != ERROR_SUCCESS) の場合 {
        SOFTBUS_PRINT( "[DISCOVERY] PublishService InitService が失敗しました\n" );
        PublishCallback(info->publishId、PUBLISH_FAIL_REASON_UNKNOWN、 NULL 、cb);
        Mutex のロックを解除します。
 ERROR_FAIL を返します。
    } 
 
    //AddPublishModule() 関数、2. g_publishModule にモジュールを追加するを参照してください
    PublishModule *findModule = AddPublishModule(モジュール名、情報);
    (findModule == NULL )の場合{
        SOFTBUS_PRINT( "[DISCOVERY] PublishService AddPublishModule が失敗しました\n" );
        PublishCallback(info->publishId、PUBLISH_FAIL_REASON_UNKNOWN、 NULL 、cb);
        Mutex のロックを解除します。
 ERROR_FAIL を返します。
    } 
 
    //COAP サービスを登録します。3.CoapRegisterDefualtService() を参照してください。
戻り値: ERROR_SUCCESS;
    if (info->capability == NULL || info->capabilityData == NULL ) {
        (void)CoapRegisterDefaultService();
    }それ以外{
        ret = DoRegistService(info->medium);
    } 
     
    Mutex のロックを解除します。 
 
    //この PublishCallback() は非常にシンプルです。上に何度も出てきます。初期化が成功または失敗した場合のコールバック関数です。
    戻り値 != ERROR_SUCCESS の場合 {
        PublishCallback(info->publishId、PUBLISH_FAIL_REASON_UNKNOWN、findModule、cb);
 ERROR_FAIL を返します。
    }それ以外{
        PublishCallback(info->publishId、ERROR_SUCCESS、findModule、cb);
 ERROR_SUCCESS を返します。
    }
 }

1. InitService() を初期化してサービスを検出する

Z:\harmony110\foundation\communication\softbus_lite\discovery\discovery_service\source\discovery_service.c
 int InitService(void)
 {
    if (g_isServiceInit != 0) { //グローバル変数 g_isServiceInit: サービスが開始されているかどうかを確認します。他のモジュールが開始されている場合は、成功が直接返されます。
 ERROR_SUCCESS を返します。
    } 
 
    //g_deviceInfo 構造体を初期化します。 1.1を参照してください。 g_deviceInfo構造体、関連ファイル[common_info_manager.c]を初期化します。
    (InitCommonManager() != 0) の場合 {
        DeinitService();
 ERROR_FAIL を返します。
    } 
     
    // メモリを割り当てます。1.2 を参照してください。グローバル g_publishModule と g_capabilityData を初期化します
    g_publishModule = calloc(1, sizeof(PublishModule) * MAX_MODULE_COUNT);
    g_publishModule == NULL の場合{
        DeinitService();
 ERROR_NOMEMORYを返します。
    }
    g_capabilityData = calloc(1, MAX_SERVICE_DATA_LEN);
    g_capabilityData == NULLの場合{
        DeinitService();
 ERROR_NOMEMORYを返します。
    }
    //ソフトバスは、ネットワークが接続されたときにトリガーされる最初の監視関数WifiEventTrigger()を登録します。  
    //Wifi コールバックを登録し、WifiEventTrigger()↓関数をグローバル変数 g_wifiCallback に割り当て、b.COAP を参照して Wifi イベントを初期化します。
    Wifiコールバックを登録します(Wifiイベントトリガー)。 
     
    //COAP の初期化。 1.3を参照してください。 COAP プロトコル サービスを初期化します (関連ファイル [coap_service.c])
 int ret = CoapInit();
    戻り値 != ERROR_SUCCESS の場合 {
        SOFTBUS_PRINT( "[DISCOVERY] InitService CoapInit 失敗\n" );
        DeinitService();
 retを返します。
    }printf( ">>>>>%s:%d[WifiEventTring() を登録]\n" ,__FILE__,__LINE__);// 印刷デバッグを追加
     
    //COAP はメッセージ キューに書き込み、上記のメッセージ コールバック関数 WifiEventTrigger() をトリガーします。この機能はより重要です、TODO 1.4。
    CoapWriteMsgQueue(UPDATE_IP_EVENT); 
     
    //COAP登録デバイス情報
    ret = CoapRegisterDeviceInfo();
    戻り値 != ERROR_SUCCESS の場合 {
        SOFTBUS_PRINT( "[DISCOVERY] InitService CoapRegisterDeviceInfo 失敗\n" );
        DeinitService();
 retを返します。
    } 
     
    g_isServiceInit = 1;
    SOFTBUS_PRINT( "[DISCOVERY] InitService ok\n" );
 ERROR_SUCCESS を返します。
 }

1.1. g_deviceInfo構造体を初期化する

Z:\harmony110\foundation\communication\softbus_lite\discovery\discovery_service\source\common_info_manager.c 
     
 int InitCommonManager(void)
 {
    if (InitLocalDeviceInfo() != 0) { //ローカルデバイス情報を初期化する
        SOFTBUS_PRINT( "[DISCOVERY] InitCommonManager が失敗しました\n" );
 ERROR_FAIL を返します。
    }
 ERROR_SUCCESS を返します。
 }
 ===================================================================================
 int InitLocalDeviceInfo(void) //ローカルデバイス情報を初期化する
{
 charデバイスID[DEVICEID_MAX_NUM] = {0}; 
 
    if (g_deviceInfo != NULL ) { //g_deviceInfo 構造体を初期化します。ローカルデバイスに関するさまざまな情報が含まれます。
        memset_s(g_deviceInfo, サイズ(デバイス情報)、0、サイズ(デバイス情報));
    }それ以外{
        g_deviceInfo = (デバイス情報 *)calloc(1, サイズ(デバイス情報));
        g_deviceInfo == NULLの場合{
 ERROR_FAIL を返します。
        }
    } 
 
    g_deviceInfo->デバイスポート = -1; //デフォルト、g_deviceInfo.Device ポート -1
    g_deviceInfo->isAccountTrusted = 1; //デフォルトでは、g_deviceInfo.account が信頼されます
 
    符号なし整数ret;
    //ファイルからデバイス ID を取得します。この機能には複数のレイヤーがあるため、これ以上詳しく説明しません。基本的には、DEVICE_ID_FILE ファイルから読み取られます。
    //# DEVICE_ID_FILE を"/storage/data/softbus/deviceid"と定義します 
    ret = GetDeviceIdFromFile(デバイスID、MAX_VALUE_SIZE);
    戻り値 != ERROR_SUCCESS の場合 {
        SOFTBUS_PRINT( "[DISCOVERY] デバイスの取得に失敗しました\n" );
 ERROR_FAIL を返します。
    } 
 
 # 定義されている場合(__LITEOS_M__) || __LITEOS_RISCV__ が定義されています //g_deviceInfo。デバイスタイプ、現在はL0とL1に分かれています
    g_deviceInfo->デバイスタイプ = L0;
    ret = (unsigned int )strcpy_s(g_deviceInfo->deviceName, sizeof(g_deviceInfo->deviceName), L0_DEVICE_NAME);
 ＃それ以外 
    g_deviceInfo->デバイスタイプ = L1;
    ret = (符号なし整数)strcpy_s(g_deviceInfo->deviceName, sizeof(g_deviceInfo->deviceName), L1_DEVICE_NAME);
 #終了
 
    ret |= (unsigned int )strcpy_s(g_deviceInfo->deviceId, sizeof(g_deviceInfo->deviceId), deviceId);//g_deviceInfo.deviceid
    ret |= (unsigned int )strcpy_s(g_deviceInfo->version, sizeof(g_deviceInfo->version), "1.0.0" );//g_deviceInfo.version番号
    戻り値が 0 の場合
ERROR_FAIL を返します。
    } 
 
    SOFTBUS_PRINT( "[DISCOVERY] InitLocalDeviceInfo ok\n" );
 ERROR_SUCCESS を返します。
 }

1.2.グローバル g_publishModule と g_capabilityData を初期化します

Z:\harmony110\foundation\communication\softbus_lite\discovery\discovery_service\source\discovery_service.c
 //まず、これらの 2 つのグローバル変数は discovery_service.c の先頭で定義されます。 
 
 PublishModule *g_publishModule = NULL ; //公開されたモジュールを保存する
char *g_capabilityData = NULL ; //機能説明データ
 
 typedef構造体{
 charパッケージ[MAX_PACKAGE_NAME];
公開IDをintで指定します。
    符号なしショート媒体;
    符号なしショート機能ビットマップ;
 char *機能データ;
    符号なしショートデータ長;
    unsigned short が使用されます。
 } モジュールを公開します。 //モジュール構造を公開する
 
 //InitService() を初期化してサービスを検出すると、モジュールはグローバル変数 g_publishModule に登録され、サービスは g_capabilityData に登録されます。

1.3. COAPプロトコルサービスを初期化する

Z:\harmony110\foundation\communication\softbus_lite\discovery\discovery_service\source\coap_service.c
 int CoapInit(void)
 {
 int ret = NSTACKX_Init();
    戻り値が 0 の場合
        SOFTBUS_PRINT( "[DISCOVERY] CoapInit NSTACKX_Init 失敗\n" );
 ERROR_FAIL を返します。
    }
 ERROR_SUCCESS を返します。
 }
 ===================================================================================
 Z:\harmony110\foundation\communication\softbus_lite\discovery\coap\source\nstackx_common.c
整数NSTACKX_Init()
 {
整数戻り値;
    g_nstackInitState != NSTACKX_INIT_STATE_START の場合 {
 NSTACKX_EOKを返します。
    } 
 
    g_nstackInitState = NSTACKX_INIT_STATE_ONGOING;
    cJSON_InitHooks( NULL ); 
 
    ret = CoapInitDiscovery(); //COAPポート監視を開始する
    （NSTACKX_EOK が返されない場合）{
 L_ERR_INITに移動します。
    }
    g_nstackInitState = NSTACKX_INIT_STATE_DONE;
 NSTACKX_EOKを返します。 
 
例外:
    ret = NSTACKX_Deinit();
    （NSTACKX_EOK が返されない場合）{
        SOFTBUS_PRINT( "[DISCOVERY] deinit 失敗\n" );
    }
 NSTACKX_EFAILED を返します。
 }
 ===================================================================================
 Z:\harmony110\foundation\communication\softbus_lite\discovery\coap\source\coap_discover.c
 int CoapInitDiscovery(void)
 {
 CoapInitSocket を呼び出します。 //a.COAP を参照 ソケットの初期化 //リスニングポートを開始
    （NSTACKX_EOK が返されない場合）{
        SOFTBUS_PRINT( "[DISCOVERY] ソケットの初期化に失敗しました\n" );
 retを返します。
    } 
 
    ret = CoapInitWifiEvent(); //b.COAP初期化wifiイベントを参照
    （NSTACKX_EOK が返されない場合）{
        SOFTBUS_PRINT( "[DISCOVERY] Wi-Fi初期化イベント失敗\n" );
 retを返します。
    }
 #定義されている場合(__LITEOS_A__)
    ret = CreateQueryIpThread();
    （NSTACKX_EOK が返されない場合）{
        SOFTBUS_PRINT( "[DISCOVERY] 初期クエリIP失敗\n" );
 retを返します。
    }
 #終了
    (CreateMsgQueThread() != NSTACKX_EOK) の場合 {
 NSTACKX_EFAILED を返します。
    } 
     
 CreateCoapListenThread() を返します。 //c を参照してください。 COAPリスニングスレッドを作成する
}
 ===================================================================================

a.COAPソケットの初期化

//この関数はcoapにジャンプします[ディレクトリは主にCOAPプロトコルを担当します]
 Z:\harmony110\foundation\communication\softbus_lite\discovery\coap\source\coap_socket.c
 int CoapInitSocket(void)
 {
    g_serverFd >= 0 の場合
NSTACKX_EOKを返します。
    }
    構造体 sockaddr_in sockAddr;
    (void)memset_s(&sockAddr, sizeof(sockAddr), 0, sizeof(sockAddr));
    sockAddr.sin_port = htons(COAP_DEFAULT_PORT);
    g_serverFd = CoapCreateUdpServer(&sockAddr); //udpサーバーを作成し、このソケットをg_serverFdに割り当てます
    g_serverFd < 0 の場合
NSTACKX_OVERFLOW を返します。
    }
    COAP_SoftBusInitMsgId();
 NSTACKX_EOKを返します。
 }
 ===================================================================================
 int CoapCreateUdpServer(const struct sockaddr_in *sockAddr) //udpサーバーを作成する
{
    （sockAddr == NULL ）の場合{
 NSTACKX_EINVALを返します。
    } 
 
    構造体 sockaddr_in ローカルアドレス;
    socklen_t len ​​= sizeof(localAddr);
 int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    （sockfd < 0）の場合{
 NSTACKX_OVERFLOW を返します。
    } 
 
    (void)memset_s(&localAddr, sizeof(localAddr), 0, sizeof(localAddr));
    localAddr.sin_family = AF_INET; //構造 sockaddr_in.sin_family = 2
    localAddr.sin_port = sockAddr->sin_port; //構造体 sockaddr_in.sin_port = 5684、coap_socket.h で定義
    (sockAddr->sin_addr.s_addr != 0) の場合 {
        ローカルアドレス.sin_addr.s_addr = sockAddr->sin_addr.s_addr; //テストでは、ここでの実行はelseであることが分かりました 
    }それ以外{
        ローカルアドレス.sin_addr.s_addr = htonl(INADDR_ANY); //構造 sockaddr_in.sin_addr.s_addr = 0 印刷テストの結果は0です
    } 
 
    if (bind(sockfd, (struct sockaddr *)&localAddr, len) == -1) { //ソケットを作成し、bind() を使用して指定された IP+PORT にバインドします。
        ソケットを閉じます(&sockfd);
 NSTACKX_EFAILED を返します。
    } 
 
    if (getsockname(sockfd, (struct sockaddr *)&localAddr, &len) == -1) { //ソケット名を取得する
        ソケットを閉じます(&sockfd);
 NSTACKX_EFAILED を返します。
    }
 sockfdを返します。
 }

b.COAPはWiFiイベントを初期化します

//基本的な原則は、wifi_liteのようなイベントコールバック関数を登録することです
//最後にWifiEventTrigger()関数を呼び出します
Z:\harmony110\foundation\communication\softbus_lite\discovery\coap\source\coap_discover.c
 int CoapInitWifiEvent(void)
 {
    SOFTBUS_PRINT( "[DISCOVERY] CoapInitWifiEvent\n" );
    符号なし整数ret;
    g_wifiQueueId == -1の場合{
        ret = CreateMsgQue( "/wifiQue" , ​​//メッセージキューを作成する
            WIFI_QUEUE_SIZE、(符号なし整数*)&g_wifiQueueId、
            0、サイズ(AddressEventHandler));
        戻り値が 0 の場合
            SOFTBUS_PRINT( "[DISCOVERY]CreateMsgQue 失敗\n" );
            (void)CoapDeinitWifiEvent();
 retを返します。
        } 
 
 # 定義されている場合(__LITEOS_M__) ||定義済み(__LITEOS_RISCV__)
        g_coapEventHandler.OnWifiConnectionChanged = CoapConnectionChangedHandler; //以下の分析を参照
        WifiErrorCode エラー = RegisterWifiEvent(&g_coapEventHandler); //wifiイベントを登録、グローバル変数g_coapEventHandler
        if (エラー != WIFI_SUCCESS) {
            SOFTBUS_PRINT( "[DISCOVERY]RegisterWifiEvent 失敗、エラー:%d\n" 、エラー);
            (void)CoapDeinitWifiEvent();
            g_wifiキューID = -1;
エラーを返します。
        }
 #終了
    }
 NSTACKX_EOKを返します。
 }
 ===================================================================================
 # 定義されている場合(__LITEOS_M__) ||定義済み(__LITEOS_RISCV__)
静的void CoapConnectionChangedHandler( int状態、 WifiLinkedInfo* 情報)
 {
    (void)情報;
    CoapWriteMsgQueue(状態); //以下の分析を参照
}
 ===================================================================================
 void CoapWriteMsgQueue( int状態)
 {
    SOFTBUS_PRINT( "[DISCOVERY] CoapWriteMsgQueue\n" );
    AddressEventHandler ハンドラ;
    ハンドラ.handler = CoapHandleWifiEvent; //以下の分析を参照
    ハンドラの状態 = 状態;
    /* 新しいイベントが来る間は、前のループを停止する必要があります */
    g_queryIpFlag = 0;
    (void)WriteMsgQue(g_wifiQueueId、&handler、sizeof(AddressEventHandler));
 }
 ===================================================================================
 void CoapHandleWifiEvent(符号なし整数パラメタ)
 {
    if (g_wifiCallback != NULL ) { //g_wifiCallback in int InitService(void){RegisterWifiCallback(WifiEventTrigger);}
        g_wifiCallback(パラレル); //Wifiイベントトリガー()
    }
 }

紀元前COAPリスニングスレッドHandleReadEvent()を作成する

// COAP_DEFAULT_PORT ポート上の UDP ソケットのデータ (つまり、COAP プロトコルに基づく検出ブロードキャスト メッセージ) を処理するための CoapReadHandle スレッドを作成します。
 Z:\harmony110\foundation\communication\softbus_lite\discovery\coap\source\coap_discover.c
 int CoapListenThread の作成(void)
 {
    g_terminalフラグ = 1; 
 
 # 定義されている場合(__LITEOS_M__) ||定義済み(__LITEOS_RISCV__)
    g_coapTaskId != NULL の場合{
 NSTACKX_EOKを返します。
    } 
 
    osThreadAttr_t 属性; //osThreadAttr_t構造体を作成する
    属性。名前= "coap_listen_task" ;
    attr.attr_bits = 0U;
    attr.cb_mem = NULL ;
    attr.cb_size = 0U;
    attr.stack_mem = NULL ;
    attr.stack_size = LOSCFG_BASE_CORE_TSK_DEFAULT_STACK_SIZE;
    attr.priority = osPriorityNormal4; // COAP_DEFAULT_PRIO -> cmsis 優先度
    //新しいシステムスレッド、グローバル変数g_coapTaskIdを作成します
    g_coapTaskId = osThreadNew((osThreadFunc_t)CoapReadHandle, NULL , &attr); //CoapReadHandleを解析するには以下を参照してください
    g_coapTaskId == NULLの場合{
        g_terminalフラグ = 0;
        SOFTBUS_PRINT( "[DISCOVERY] タスクの作成に失敗しました\n" );
 NSTACKX_EFAILED を返します。
    }
 ＃それ以外 
    g_coapTaskId != -1 の場合 {
 NSTACKX_EOKを返します。
    } 
 
    スレッド属性 attr = { "coap_listen_task" , 0x800, 20, 0, 0};
 int error = CreateThread((Runnable)CoapReadHandle、 NULL 、&attr、(unsigned int *)&g_coapTaskId);
    (エラー!= 0)の場合{
        g_terminalフラグ = 0;
        SOFTBUS_PRINT( "[DISCOVERY] タスクの作成に失敗しました\n" );
 NSTACKX_EFAILED を返します。
    }
 #終了
NSTACKX_EOKを返します。
 }
 ===================================================================================
 #TIME_MICRO_SEC 10000 を定義します
静的void CoapReadHandle(unsigned int uwParam1、unsigned int uwParam2、unsigned int uwParam3、unsigned int uwParam4)
 {
    (void)uwParam1;
    (void)uwParam2;
    (void)uwParam3;
    (void)uwParam4;
整数戻り値;
    fd_set 読み取りセット;
 int serverFd = GetCoapServerSocket();
    SOFTBUS_PRINT( "[DISCOVERY] CoapReadHandle コイン選択開始\n" );
    (g_terminalFlag) の間{
        FD_ZERO(&readSet);
        FD_SET(serverFd, &readSet);
        //非同期通信はselectを呼び出すことで実現されます
        ret = select (serverFd + 1, &readSet, NULL , NULL , NULL );
        戻り値 > 0 の場合 {
            FD_ISSET(serverFd, &readSet)の場合{
                //ポートで監視されているパケットはHandleReadEvent関数によって処理され、受信されたデータパケットが処理されます
                ハンドル読み取りイベント(serverFd); //[3. を参照。検出側（携帯電話など）がブロードキャストを送信する場合]
            }
        }それ以外{
            SOFTBUS_PRINT( "[DISCOVERY]ret:%d,error:%d\n" , ret, errno);
        }
    }
    SOFTBUS_PRINT( "[DISCOVERY] CoapReadHandle 終了\n" );
 }

2. g_publishModuleにモジュールを追加

//g_publishModule とは何ですか?上記の分析を参照してください: 1.2。グローバル g_publishModule と g_capabilityData を初期化します
// 入力パラメータは PublishInfo *info であり、g_publishModule のコンテンツのほとんどは PublishInfo を継承します
//PublishInfo構造体の内容は、PublishService()を呼び出すときに提供する必要があるパラメータです。
 //簡単に言えば、システム g_publishModule にソフト バスのモジュール名と情報を追加します。
 PublishModule *AddPublishModule(const char *packageName, const PublishInfo *info)
 {
    //パラメータを確認する
    if (packageName == NULL || g_publishModule == NULL || info == NULL ) {
戻る  NULL ;
    }
    if (info->dataLen > MAX_SERVICE_DATA_LEN) {
戻る  NULL ;
    }
    (FindExistModule(パッケージ名、info->publishId) != NULL ) の場合 {
戻る  NULL ;
    }
    (FindFreeModule() == NULL )の場合{
戻る  NULL ;
    } 
     
    //
整数戻り値;
 for ( int i = 0; i < MAX_MODULE_COUNT; i++) { //# MAX_MODULE_COUNT 3 を定義する
        g_publishModule[i].used == 1の場合{
続く;
        } 
 
        （ParseCapability（info->capability、＆g_publishModule[i].capabilityBitmap））{
戻る  NULL ;
        } 
 
        g_publishModule[i].used = 1;
        g_publishModule[i].capabilityData = calloc(1, info->dataLen + 1);
        g_publishModule[i].capabilityData == NULLの場合{
            memset_s(&g_publishModule[i], サイズ(g_publishModule[i]), 0, サイズ(g_publishModule[i]));
戻る  NULL ;
        }
        g_publishModule[i].dataLength = info->dataLen + 1;
        ret = memcpy_s(g_publishModule[i].capabilityData,
                       g_publishModule[i].dataLength、
                       info->capabilityData、info->dataLen);
        戻り値が 0 の場合
g_publishModule[i].capabilityDataを解放します。
            g_publishModule[i].capabilityData = NULL ;
            memset_s(&g_publishModule[i], サイズ(g_publishModule[i]), 0, サイズ(g_publishModule[i]));
戻る  NULL ;
        }
        g_publishModule[i].medium = 情報->medium;
        g_publishModule[i].publishId = info->publishId;
        ret = memcpy_s(g_publishModule[i].package, MAX_PACKAGE_NAME, packageName, strlen(packageName));
        戻り値が 0 の場合
g_publishModule[i].capabilityDataを解放します。
            g_publishModule[i].capabilityData = NULL ;
            memset_s(&g_publishModule[i], サイズ(g_publishModule[i]), 0, サイズ(g_publishModule[i]));
戻る  NULL ;
        }
 &g_publishModule[i] を返します。
    }
戻る  NULL ;
 }

3.CoapRegisterDefaultService()

 Z:\harmony110\foundation\communication\softbus_lite\discovery\discovery_service\source\coap_service.c 
 
 int CoapRegisterDefaultService(void) は、
 {
    デバイス情報 *info = GetCommonDeviceInfo(); //infoはグローバル変数g_deviceInfo構造体を継承します
    if (情報 == NULL ) {
 ERROR_FAIL を返します。
    } 
 
 charサービスデータ[MAX_DEFAULT_SERVICE_DATA_LEN] = {0};
    if (sprintf_s(serviceData, sizeof(serviceData), "port:%d" , info->devicePort) == -1) {
 ERROR_FAIL を返します。
    } 
 
 NSTACKX_RegisterServiceData(serviceData)を返します。
 }
 ======================================================================
 Z:\harmony110\foundation\communication\softbus_lite\discovery\coap\source\nstackx_common.c 
 
 int NSTACKX_RegisterServiceData(const char *サービスデータ)
 {
    サービスデータ== NULL の場合
NSTACKX_EINVALを返します。
    } 
 
    g_nstackInitState != NSTACKX_INIT_STATE_DONE の場合 {
 NSTACKX_EFAILED を返します。
    }
    符号なし整数serviceLen = strlen(serviceData);
    サービス長さ >= NSTACKX_MAX_SERVICE_DATA_LEN の場合 {
 NSTACKX_EINVALを返します。
    } 
 
    RegisterServiceData(serviceData, serviceLen + 1) != NSTACKX_EOK の場合 {
 NSTACKX_EINVALを返します。
    }
 NSTACKX_EOKを返します。
 }
 ======================================================================
 Z:\harmony110\foundation\communication\softbus_lite\discovery\coap\source\nstackx_device.c 
 
 int RegisterServiceData(const char * serviceData, int長さ)
 {
    サービスデータ== NULL の場合
NSTACKX_EINVALを返します。
    } 
 
    (void)memset_s(g_localDeviceInfo.serviceData, sizeof(g_localDeviceInfo.serviceData),
        0、サイズ(g_localDeviceInfo.serviceData));
    strcpy_s(g_localDeviceInfo.serviceData, NSTACKX_MAX_SERVICE_DATA_LEN, serviceData) が EOK の場合 {
 NSTACKX_EFAILED を返します。
    } 
 
    (void)長さ;
 NSTACKX_EOKを返します。
 }
 ======================================================================
 Z:\harmony110\foundation\communication\softbus_lite\discovery\coap\source\nstackx_device.c 
 
 int RegisterServiceData(const char * serviceData, int長さ)
 {
    サービスデータ== NULL の場合
NSTACKX_EINVALを返します。
    } 
 
    (void)memset_s(g_localDeviceInfo.serviceData, sizeof(g_localDeviceInfo.serviceData),
        0、サイズ(g_localDeviceInfo.serviceData));
    strcpy_s(g_localDeviceInfo.serviceData, NSTACKX_MAX_SERVICE_DATA_LEN, serviceData) が EOK の場合 {
 NSTACKX_EFAILED を返します。
    } 
 
    (void)長さ;
 NSTACKX_EOKを返します。
 }

要約:

モジュール情報を通じてサービスを登録および公開すると、システムは 2 つのスレッドを生成します。1 つはネットワークを監視するスレッド、もう 1 つはローカル エリア ネットワーク内の UDP の検出終了要求を監視するスレッドです。

ネットワークにアクセスし、[2]を実行します。ネットワークにアクセスするときに、WifiEventTrigger() をトリガーしてソフトバスを開始します]

UDPブロードキャストを聴く[3.端末（携帯電話など）がブロードキャストを送信する場合]

記事に関連する添付ファイルをダウンロードするには、以下のリンクをクリックしてください。

オリジナルリンク: https://harmonyos..com/posts/4776

詳細については、以下をご覧ください。

51CTOとHuaweiが共同で構築したHongmengテクノロジーコミュニティ

https://harmonyos..com