<var id="vnpxn"><i id="vnpxn"></i></var>

              <rp id="vnpxn"><delect id="vnpxn"><pre id="vnpxn"></pre></delect></rp>
              <rp id="vnpxn"><span id="vnpxn"><th id="vnpxn"></th></span></rp>

              <rp id="vnpxn"></rp>

                <ruby id="vnpxn"><th id="vnpxn"><em id="vnpxn"></em></th></ruby>
                快捷導航 新聞投稿開啟輔助訪問
                搜索

                Tizen網絡音頻樣本概述

                2017-10-31 22:52| 發布者: zouyang5| 查看: 1| 評論: 0|原作者: 紙風鈴|來自: 泰澤網

                摘要: 網絡音頻示例應用程序演示了用戶如何管理事物。 源代碼顯示了在初始化,啟動,所有權轉移和資源處理的情況下使用st-things SDK的工作。 先決條件 為確保正確的應用程序執行,必須設置以下權限: http://tizen ...
                網絡音頻示例應用程序演示了用戶如何管理事物。 源代碼顯示了在初始化,啟動,所有權轉移和資源處理的情況下使用st-things SDK的工作。

                先決條件
                為確保正確的應用程序執行,必須設置以下權限:

                http://tizen.org/privilege/network.get
                http://tizen.org/privilege/network.set
                http://tizen.org/privilege/internet
                http://tizen.org/privilege/alarm.set
                http://tizen.org/privilege/network.profile

                必須安裝Tizen Studio 2.0。
                在包管理器中,必須安裝主SDK中的4.0 Mobile。
                在軟件包管理器中,必須安裝擴展SDK中的其他> IOT-Headless-4.0。
                必須安裝IoT安裝向導(Tizen Studio插件)。
                設備必須通過IoT安裝向導上的SD卡閃爍,并且必須安裝連接驅動程序。
                您必須準備證書(* .pem)和私鑰(* .der)。
                有關與IoT安裝向導相關的上述步驟,請參閱IoT安裝向導。


                Implementation您可以使用Tizen Studio自定義iot-headless v4.0模板開發示例應用程序。 但是,以下示例使用導入的項目中的示例應用程序代碼。 您可以在Tizen Studio中下載此示例應用程序。

                以下內容在thing.c文件中:

                1. #include <stdio.h>
                2. #include <string.h>
                3. #include <stdbool.h>
                4. #include <app_common.h>
                5. #include "st_things.h"
                6. #include "user.h"
                7. #include "headlessthingsapp.h"

                8. #define JSON_PATH "device_def.json"

                9. static const char *URI_POWERSWITCH = "/switch/main/0";
                10. static const char *URI_VOLUME = "/audioVolume/main/0";

                11. /* Handle: for getting request on resources */
                12. static bool
                13. handle_get_request(st_things_get_request_message_s *req_msg, st_things_representation_s *resp_rep)
                14. {
                15.     DBG("resource_uri [%s]", req_msg->resource_uri);

                16.     if (0 == strcmp(req_msg->resource_uri, URI_POWERSWITCH))
                17.         return handle_get_request_on_switch(req_msg, resp_rep);
                18.     if (0 == strcmp(req_msg->resource_uri, URI_VOLUME))
                19.         return handle_get_request_on_volume(req_msg, resp_rep);

                20.     ERR("not supported uri");

                21.     return false;
                22. }

                23. /* Handle: for setting request on resources */
                24. static bool
                25. handle_set_request(st_things_set_request_message_s *req_msg, st_things_representation_s *resp_rep)
                26. {
                27.     DBG("resource_uri [%s]", req_msg->resource_uri);

                28.     if (0 == strcmp(req_msg->resource_uri, URI_POWERSWITCH))
                29.         return handle_set_request_on_switch(req_msg, resp_rep);
                30.     if (0 == strcmp(req_msg->resource_uri, URI_VOLUME))
                31.         return handle_set_request_on_volume(req_msg, resp_rep);

                32.     ERR("not supported uri");

                33.     return false;
                34. }

                35. /* Initialize */
                36. void
                37. init_thing()
                38. {
                39.     FN_CALL;
                40.     static bool binitialized = false;
                41.     if (binitialized) {
                42.         DBG("Already initialized!!");

                43.         return;
                44.     }
                45.     binitialized = true;
                46.     init_user();

                47.     bool easysetup_complete = false;

                48.     char app_json_path[128] = {0,};
                49.     char *app_res_path = app_get_resource_path();
                50.     snprintf(app_json_path, sizeof(app_json_path), "%s/%s", app_res_path, JSON_PATH);
                51.     free(app_res_path);

                52.     if (0 != st_things_initialize(app_json_path, &easysetup_complete)) {
                53.         ERR("st_things_initialize() failed!!");

                54.         return;
                55.     }

                56.     DBG("easysetup_complete:[%d]", easysetup_complete);

                57.     st_things_register_request_cb(handle_get_request, handle_set_request);
                58.     st_things_register_reset_cb(handle_reset_request, handle_reset_result);
                59.     st_things_register_user_confirm_cb(handle_ownership_transfer_request);
                60.     st_things_register_things_status_change_cb(handle_things_status_change);

                61.     st_things_start();

                62.     FN_END;
                63. }
                **代碼
                以下內容在user.h和user.c文件中:
                1. #ifndef __USER_H__
                2. #define  __USER_H__

                3. #include <stdio.h>
                4. #include <string.h>

                5. #ifdef __cplusplus
                6. extern "C" {
                7. #endif

                8. bool handle_get_request_on_switch(st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep);
                9. bool handle_set_request_on_switch(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep);
                10. bool handle_get_request_on_volume(st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep);
                11. bool handle_set_request_on_volume(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep);

                12. bool handle_reset_request();
                13. void handle_reset_result(bool result);
                14. bool handle_ownership_transfer_request();
                15. void handle_things_status_change(st_things_status_e things_status);
                16. bool init_user();

                17. #ifdef __cplusplus
                18. }
                19. #endif

                20. #endif /* __USER_H__ */

                21. #include <stdio.h>
                22. #include <string.h>
                23. #include <stdbool.h>
                24. #include <inttypes.h>
                25. #include <app_common.h>
                26. #include "st_things.h"
                27. #include "user.h"
                28. #include "player.h"
                29. #include "headlessthingsapp.h"

                30. #define VALUE_STR_LEN_MAX 32

                31. static const char* KEY_SWITCH = "power";
                32. static const char* VALUE_SWITCH_ON = "on";
                33. static const char* VALUE_SWITCH_OFF = "off";
                34. static char g_switch[VALUE_STR_LEN_MAX+1] = "off";

                35. static const char* KEY_VOLUME = "volume";
                36. static int64_t g_volume;

                37. static const char* KEY_MUTE = "mute";
                38. static bool g_mute;

                39. static const char* KEY_VOLUME_COMMAND = "command";
                40. static const char* VALUE_VOLUME_COMMAND_INC = "increase";
                41. static const char* VALUE_VOLUME_COMMAND_DEC = "decrease";
                42. static const char* VALUE_VOLUME_COMMAND_MAX = "max";
                43. static const char* VALUE_VOLUME_COMMAND_MIN = "min";
                44. static char g_volume_cmd[VALUE_STR_LEN_MAX+1] = "increase";

                45. /******************************************************/

                46. #define AUDIO_FILE_NAME "sample.mp3"

                47. static player_h g_player;

                48. static char audio_file[128];

                49. /* Player: get mute */
                50. static bool
                51. user_player_is_muted(bool *muted)
                52. {
                53.     FN_CALL;

                54.     int ret;
                55.     ret = player_is_muted(g_player, muted);
                56.     if (ret != PLAYER_ERROR_NONE) {
                57.         ERR("player_is_muted is failed [%d]", ret);

                58.         return false;
                59.     }

                60.     return true;
                61. }

                62. /* Player: set mute */
                63. static bool
                64. user_player_set_mute(bool muted)
                65. {
                66.     FN_CALL;

                67.     int ret;
                68.     ret = player_set_mute(g_player, muted);
                69.     if (ret != PLAYER_ERROR_NONE) {
                70.         ERR("player_set_mute is failed [%d]", ret);

                71.         return false;
                72.     }

                73.     return true;
                74. }

                75. /* Player: set volume */
                76. static bool
                77. user_player_set_volume(float vol)
                78. {
                79.     FN_CALL;

                80.     int ret;
                81.     ret = player_set_volume(g_player, vol, vol);
                82.     if (ret != PLAYER_ERROR_NONE) {
                83.         ERR("player_set_volume is failed [%d]", ret);

                84.         return false;
                85.     }

                86.     return true;
                87. }

                88. /* Player: get volume */
                89. static bool
                90. user_player_get_volume(float *vol)
                91. {
                92.     FN_CALL;

                93.     int ret;
                94.     float vol2;
                95.     ret = player_get_volume(g_player, vol, &vol2);
                96.     if (ret != PLAYER_ERROR_NONE) {
                97.         ERR("player_get_volume is failed [%d]", ret);

                98.         return false;
                99.     }

                100.     return true;
                101. }

                102. /* Player: start player */
                103. static bool
                104. user_player_start()
                105. {
                106.     FN_CALL;

                107.     int ret;
                108.     ret = player_set_uri(g_player, audio_file);
                109.     if (ret != PLAYER_ERROR_NONE) {
                110.         ERR("player_set_uri is failed [%d]", ret);

                111.         return false;
                112.     }
                113.     ret = player_prepare(g_player);
                114.     if (ret != PLAYER_ERROR_NONE) {
                115.         ERR("player_prepare is failed [%d]", ret);

                116.         return false;
                117.     }
                118.     ret = player_start(g_player);
                119.     if (ret != PLAYER_ERROR_NONE) {
                120.         ERR("player_start is failed [%d]", ret);

                121.         return false;
                122.     }

                123.     return true;
                124. }

                125. /* Player: stop player */
                126. static bool
                127. user_player_stop()
                128. {
                129.     FN_CALL;

                130.     int ret;
                131.     ret = player_stop(g_player);
                132.     if (ret != PLAYER_ERROR_NONE) {
                133.         ERR("player_stop is failed [%d]", ret);

                134.         return false;
                135.     }
                136.     ret = player_unprepare(g_player);
                137.     if (ret != PLAYER_ERROR_NONE) {
                138.         ERR("player_unprepare is failed [%d]", ret);

                139.         return false;
                140.     }

                141.     return true;
                142. }

                143. /* Player: init player */
                144. static bool
                145. user_player_init()
                146. {
                147.     FN_CALL;

                148.     int ret;
                149.     ret = player_create(&g_player);
                150.     if (ret != PLAYER_ERROR_NONE) {
                151.         ERR("player_create is failed [%d]", ret);

                152.         return false;
                153.     }
                154.     ret = player_set_looping(g_player, true);
                155.     if (ret != PLAYER_ERROR_NONE) {
                156.         ERR("player_set_looping is failed [%d]", ret);

                157.         return false;
                158.     }

                159.     char *app_res_path = app_get_resource_path();
                160.     snprintf(audio_file, sizeof(audio_file), "%s/%s", app_res_path, AUDIO_FILE_NAME);
                161.     free(app_res_path);

                162.     return true;
                163. }

                164. /* Initialize player */
                165. bool
                166. init_user()
                167. {
                168.     FN_CALL;

                169.     int ret;

                170.     ret = user_player_init();

                171.     return ret;
                172. }

                173. /* Handle: for getting request on switch */
                174. bool
                175. handle_get_request_on_switch(st_things_get_request_message_s *req_msg, st_things_representation_s *resp_rep)
                176. {
                177.     DBG("current g_switch: [%s]", g_switch);
                178.     resp_rep->set_str_value(resp_rep, KEY_SWITCH, g_switch);

                179.     return true;
                180. }

                181. /* Handle: for setting request on switch */
                182. bool
                183. handle_set_request_on_switch(st_things_set_request_message_s *req_msg, st_things_representation_s *resp_rep)
                184. {
                185.     DBG("current g_switch: [%s]", g_switch);

                186.     char *str_value = NULL;
                187.     req_msg->rep->get_str_value(req_msg->rep, KEY_SWITCH, &str_value);
                188.     DBG("requested switch: [%s]", str_value);

                189.     /* Check validation */
                190.     if ((0 != strncmp(str_value, VALUE_SWITCH_ON, strlen(VALUE_SWITCH_ON)))
                191.         && (0 != strncmp(str_value, VALUE_SWITCH_OFF, strlen(VALUE_SWITCH_OFF)))) {
                192.         ERR("Not supported value!!");
                193.         free(str_value);

                194.         return false;
                195.     }

                196.     if (0 != strncmp(str_value, g_switch, strlen(g_switch))) {
                197.         strncpy(g_switch, str_value, VALUE_STR_LEN_MAX);
                198.         if (0 == strncmp(g_switch, VALUE_SWITCH_ON, strlen(VALUE_SWITCH_ON)))
                199.             user_player_start();
                200.         else
                201.             user_player_stop();
                202.     }
                203.     resp_rep->set_str_value(resp_rep, KEY_SWITCH, g_switch);

                204.     st_things_notify_observers(req_msg->resource_uri);

                205.     free(str_value);

                206.     return true;
                207. }

                208. /* Handle: for getting request on volume */
                209. bool
                210. handle_get_request_on_volume(st_things_get_request_message_s *req_msg, st_things_representation_s *resp_rep)
                211. {
                212.     DBG("current g_volume: [%lld], g_mute:[%d]", g_volume, g_mute);

                213.     if (req_msg->has_property_key(req_msg, KEY_VOLUME)) {
                214.         DBG("key[%s] exists", KEY_VOLUME);
                215.         float temp_vol = 0.0;
                216.         user_player_get_volume(&temp_vol);
                217.         g_volume = (int64_t) (temp_vol * 100);
                218.         DBG("current g_volume: [%lld]", g_volume);
                219.         resp_rep->set_int_value(resp_rep, KEY_VOLUME, g_volume);
                220.     }

                221.     if (req_msg->has_property_key(req_msg, KEY_MUTE)) {
                222.         DBG("key[%s] exists", KEY_MUTE);
                223.         user_player_is_muted(&g_mute);
                224.         DBG("current g_mute: [%d]", g_mute);
                225.         resp_rep->set_bool_value(resp_rep, KEY_MUTE, g_mute);
                226.     }

                227.     if (req_msg->has_property_key(req_msg, KEY_VOLUME_COMMAND))
                228.         WARN("key[%s] exists..Ignore It!", KEY_VOLUME_COMMAND);

                229.     return true;
                230. }

                231. /* Handle: for setting request on volume */
                232. bool
                233. handle_set_request_on_volume(st_things_set_request_message_s *req_msg, st_things_representation_s *resp_rep)
                234. {
                235.     DBG("current g_volume: [%lld], g_mute:[%d]", g_volume, g_mute);

                236.     int64_t ivalue;
                237.     if (req_msg->rep->get_int_value(req_msg->rep, KEY_VOLUME, &ivalue)) {
                238.         DBG("requested volume: [%lld]", ivalue);
                239.         g_volume = ivalue;
                240.         float temp_vol = (float) (g_volume/100.);
                241.         user_player_set_volume(temp_vol);
                242.         resp_rep->set_int_value(resp_rep, KEY_VOLUME, g_volume);
                243.     }

                244.     bool bvalue;
                245.     if (req_msg->rep->get_bool_value(req_msg->rep, KEY_MUTE, &bvalue)) {
                246.         DBG("requested mute: [%d]", bvalue);
                247.         g_mute = bvalue;
                248.         user_player_set_mute(g_mute);
                249.         resp_rep->set_bool_value(resp_rep, KEY_MUTE, g_mute);
                250.     }

                251.     char *str_value = NULL;
                252.     if (req_msg->rep->get_str_value(req_msg->rep, KEY_VOLUME_COMMAND, &str_value)) {
                253.         DBG("requested volume_cmd: [%s]", str_value);

                254.         strncpy(g_volume_cmd, str_value, VALUE_STR_LEN_MAX);
                255.         if (0 == strncmp(g_volume_cmd, VALUE_VOLUME_COMMAND_INC, strlen(VALUE_VOLUME_COMMAND_INC)))
                256.             DBG("TODO");
                257.         else if (0 == strncmp(g_volume_cmd, VALUE_VOLUME_COMMAND_DEC, strlen(VALUE_VOLUME_COMMAND_DEC)))
                258.             DBG("TODO");
                259.         else if (0 == strncmp(g_volume_cmd, VALUE_VOLUME_COMMAND_MAX, strlen(VALUE_VOLUME_COMMAND_MAX)))
                260.             DBG("TODO");
                261.         else if (0 == strncmp(g_volume_cmd, VALUE_VOLUME_COMMAND_MIN, strlen(VALUE_VOLUME_COMMAND_MIN)))
                262.             DBG("TODO");
                263.         else
                264.             ERR("Not supported command");

                265.         resp_rep->set_str_value(resp_rep, KEY_VOLUME_COMMAND, g_volume_cmd);
                266.         free(str_value);
                267.     }

                268.     st_things_notify_observers(req_msg->resource_uri);

                269.     return true;
                270. }

                271. /* Handle: reset request*/
                272. bool
                273. handle_reset_request()
                274. {
                275.     bool confirmed = true;
                276.     DBG("confirmed : [%d]", confirmed);

                277.     return confirmed;
                278. }

                279. /* Handle: reset result */
                280. void
                281. handle_reset_result(bool result)
                282. {
                283.     DBG("result : [%d]", result);
                284. }

                285. /* Handle: ownership transfer request */
                286. bool
                287. handle_ownership_transfer_request()
                288. {
                289.     bool confirmed = true;
                290.     DBG("confirmed : [%d]", confirmed);

                291.     return confirmed;
                292. }

                293. /* Handle: for things status change */
                294. void
                295. handle_things_status_change(st_things_status_e things_status)
                296. {
                297.     DBG("things_status : [%d]", things_status);
                298. }
                **代碼
                測試
                測試樣品

                1.將您的ARTIK 530或Raspberry Pi 3板通過USB連接到Linux計算機,然后打開SDB。
                2.右鍵單擊項目,然后選擇“運行方式”>“Tizen Native項目”。

                Tizen網絡音頻樣本概述

                3.要檢查樣品是否啟動,請使用SDB shell中的ifconfig命令檢查Wi-Fi(Soft AP)是否已打開。
                使用您的Samsung Connect App搜索并添加設備。 然后,您可以看到目標板已連接到SmartThings Cloud,Samsung Connect App在其UI中顯示此設備。

                附:
                PREV Tizen外設I / O Native API


                鮮花

                握手

                雷人

                路過

                雞蛋

                最新評論

                泰澤為興趣而生,泰澤為極客而活。 登錄泰澤網 注冊泰澤網

                QQ|泰澤應用|泰澤論壇|泰澤網|小黑屋|Archiver|手機版|泰澤郵箱| 百度搜索:泰澤網

                © 2012-2016 泰澤網( 蜀ICP備13024062號-1 )( 川公網安備:51342202000102) Powered by intel and 三星 All ownership X3.4

                禁止發布任何違反國家法律、法規的言論與圖片等內容;本站內容均來自個人觀點與網絡等信息,如遇版權問題,請及時聯系(admin@tizennet.com)

                今天是:  |  本站已經安全運行:    技術支持:泰澤網

                分享泰澤網:

                返回頂部