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. 
   
9. #define JSON_PATH "device_def.json"
   
10. 
    
11. static const char *URI_POWERSWITCH = "/switch/main/0";
    
12. static const char *URI_VOLUME = "/audioVolume/main/0";
    
13. 
    
14. /* Handle: for getting request on resources */
    
15. static bool
    
16. handle_get_request(st_things_get_request_message_s *req_msg, st_things_representation_s *resp_rep)
    
17. {
    
18.     DBG("resource_uri [%s]", req_msg->resource_uri);
    
19. 
    
20.     if (0 == strcmp(req_msg->resource_uri, URI_POWERSWITCH))
    
21.         return handle_get_request_on_switch(req_msg, resp_rep);
    
22.     if (0 == strcmp(req_msg->resource_uri, URI_VOLUME))
    
23.         return handle_get_request_on_volume(req_msg, resp_rep);
    
24. 
    
25.     ERR("not supported uri");
    
26. 
    
27.     return false;
    
28. }
    
29. 
    
30. /* Handle: for setting request on resources */
    
31. static bool
    
32. handle_set_request(st_things_set_request_message_s *req_msg, st_things_representation_s *resp_rep)
    
33. {
    
34.     DBG("resource_uri [%s]", req_msg->resource_uri);
    
35. 
    
36.     if (0 == strcmp(req_msg->resource_uri, URI_POWERSWITCH))
    
37.         return handle_set_request_on_switch(req_msg, resp_rep);
    
38.     if (0 == strcmp(req_msg->resource_uri, URI_VOLUME))
    
39.         return handle_set_request_on_volume(req_msg, resp_rep);
    
40. 
    
41.     ERR("not supported uri");
    
42. 
    
43.     return false;
    
44. }
    
45. 
    
46. /* Initialize */
    
47. void
    
48. init_thing()
    
49. {
    
50.     FN_CALL;
    
51.     static bool binitialized = false;
    
52.     if (binitialized) {
    
53.         DBG("Already initialized!!");
    
54. 
    
55.         return;
    
56.     }
    
57.     binitialized = true;
    
58.     init_user();
    
59. 
    
60.     bool easysetup_complete = false;
    
61. 
    
62.     char app_json_path[128] = {0,};
    
63.     char *app_res_path = app_get_resource_path();
    
64.     snprintf(app_json_path, sizeof(app_json_path), "%s/%s", app_res_path, JSON_PATH);
    
65.     free(app_res_path);
    
66. 
    
67.     if (0 != st_things_initialize(app_json_path, &easysetup_complete)) {
    
68.         ERR("st_things_initialize() failed!!");
    
69. 
    
70.         return;
    
71.     }
    
72. 
    
73.     DBG("easysetup_complete:[%d]", easysetup_complete);
    
74. 
    
75.     st_things_register_request_cb(handle_get_request, handle_set_request);
    
76.     st_things_register_reset_cb(handle_reset_request, handle_reset_result);
    
77.     st_things_register_user_confirm_cb(handle_ownership_transfer_request);
    
78.     st_things_register_things_status_change_cb(handle_things_status_change);
    
79. 
    
80.     st_things_start();
    
81. 
    
82.     FN_END;
    
83. }

复制代码

以下内容在user.h和user.c文件中：

1. #ifndef __USER_H__
   
2. #define  __USER_H__
   
3. 
   
4. #include <stdio.h>
   
5. #include <string.h>
   
6. 
   
7. #ifdef __cplusplus
   
8. extern "C" {
   
9. #endif
   
10. 
    
11. bool handle_get_request_on_switch(st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep);
    
12. bool handle_set_request_on_switch(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep);
    
13. bool handle_get_request_on_volume(st_things_get_request_message_s* req_msg, st_things_representation_s* resp_rep);
    
14. bool handle_set_request_on_volume(st_things_set_request_message_s* req_msg, st_things_representation_s* resp_rep);
    
15. 
    
16. bool handle_reset_request();
    
17. void handle_reset_result(bool result);
    
18. bool handle_ownership_transfer_request();
    
19. void handle_things_status_change(st_things_status_e things_status);
    
20. bool init_user();
    
21. 
    
22. #ifdef __cplusplus
    
23. }
    
24. #endif
    
25. 
    
26. #endif /* __USER_H__ */
    
27. 
    
28. #include <stdio.h>
    
29. #include <string.h>
    
30. #include <stdbool.h>
    
31. #include <inttypes.h>
    
32. #include <app_common.h>
    
33. #include "st_things.h"
    
34. #include "user.h"
    
35. #include "player.h"
    
36. #include "headlessthingsapp.h"
    
37. 
    
38. #define VALUE_STR_LEN_MAX 32
    
39. 
    
40. static const char* KEY_SWITCH = "power";
    
41. static const char* VALUE_SWITCH_ON = "on";
    
42. static const char* VALUE_SWITCH_OFF = "off";
    
43. static char g_switch[VALUE_STR_LEN_MAX+1] = "off";
    
44. 
    
45. static const char* KEY_VOLUME = "volume";
    
46. static int64_t g_volume;
    
47. 
    
48. static const char* KEY_MUTE = "mute";
    
49. static bool g_mute;
    
50. 
    
51. static const char* KEY_VOLUME_COMMAND = "command";
    
52. static const char* VALUE_VOLUME_COMMAND_INC = "increase";
    
53. static const char* VALUE_VOLUME_COMMAND_DEC = "decrease";
    
54. static const char* VALUE_VOLUME_COMMAND_MAX = "max";
    
55. static const char* VALUE_VOLUME_COMMAND_MIN = "min";
    
56. static char g_volume_cmd[VALUE_STR_LEN_MAX+1] = "increase";
    
57. 
    
58. /******************************************************/
    
59. 
    
60. #define AUDIO_FILE_NAME "sample.mp3"
    
61. 
    
62. static player_h g_player;
    
63. 
    
64. static char audio_file[128];
    
65. 
    
66. /* Player: get mute */
    
67. static bool
    
68. user_player_is_muted(bool *muted)
    
69. {
    
70.     FN_CALL;
    
71. 
    
72.     int ret;
    
73.     ret = player_is_muted(g_player, muted);
    
74.     if (ret != PLAYER_ERROR_NONE) {
    
75.         ERR("player_is_muted is failed [%d]", ret);
    
76. 
    
77.         return false;
    
78.     }
    
79. 
    
80.     return true;
    
81. }
    
82. 
    
83. /* Player: set mute */
    
84. static bool
    
85. user_player_set_mute(bool muted)
    
86. {
    
87.     FN_CALL;
    
88. 
    
89.     int ret;
    
90.     ret = player_set_mute(g_player, muted);
    
91.     if (ret != PLAYER_ERROR_NONE) {
    
92.         ERR("player_set_mute is failed [%d]", ret);
    
93. 
    
94.         return false;
    
95.     }
    
96. 
    
97.     return true;
    
98. }
    
99. 
    
100. /* Player: set volume */
     
101. static bool
     
102. user_player_set_volume(float vol)
     
103. {
     
104.     FN_CALL;
     
105. 
     
106.     int ret;
     
107.     ret = player_set_volume(g_player, vol, vol);
     
108.     if (ret != PLAYER_ERROR_NONE) {
     
109.         ERR("player_set_volume is failed [%d]", ret);
     
110. 
     
111.         return false;
     
112.     }
     
113. 
     
114.     return true;
     
115. }
     
116. 
     
117. /* Player: get volume */
     
118. static bool
     
119. user_player_get_volume(float *vol)
     
120. {
     
121.     FN_CALL;
     
122. 
     
123.     int ret;
     
124.     float vol2;
     
125.     ret = player_get_volume(g_player, vol, &vol2);
     
126.     if (ret != PLAYER_ERROR_NONE) {
     
127.         ERR("player_get_volume is failed [%d]", ret);
     
128. 
     
129.         return false;
     
130.     }
     
131. 
     
132.     return true;
     
133. }
     
134. 
     
135. /* Player: start player */
     
136. static bool
     
137. user_player_start()
     
138. {
     
139.     FN_CALL;
     
140. 
     
141.     int ret;
     
142.     ret = player_set_uri(g_player, audio_file);
     
143.     if (ret != PLAYER_ERROR_NONE) {
     
144.         ERR("player_set_uri is failed [%d]", ret);
     
145. 
     
146.         return false;
     
147.     }
     
148.     ret = player_prepare(g_player);
     
149.     if (ret != PLAYER_ERROR_NONE) {
     
150.         ERR("player_prepare is failed [%d]", ret);
     
151. 
     
152.         return false;
     
153.     }
     
154.     ret = player_start(g_player);
     
155.     if (ret != PLAYER_ERROR_NONE) {
     
156.         ERR("player_start is failed [%d]", ret);
     
157. 
     
158.         return false;
     
159.     }
     
160. 
     
161.     return true;
     
162. }
     
163. 
     
164. /* Player: stop player */
     
165. static bool
     
166. user_player_stop()
     
167. {
     
168.     FN_CALL;
     
169. 
     
170.     int ret;
     
171.     ret = player_stop(g_player);
     
172.     if (ret != PLAYER_ERROR_NONE) {
     
173.         ERR("player_stop is failed [%d]", ret);
     
174. 
     
175.         return false;
     
176.     }
     
177.     ret = player_unprepare(g_player);
     
178.     if (ret != PLAYER_ERROR_NONE) {
     
179.         ERR("player_unprepare is failed [%d]", ret);
     
180. 
     
181.         return false;
     
182.     }
     
183. 
     
184.     return true;
     
185. }
     
186. 
     
187. /* Player: init player */
     
188. static bool
     
189. user_player_init()
     
190. {
     
191.     FN_CALL;
     
192. 
     
193.     int ret;
     
194.     ret = player_create(&g_player);
     
195.     if (ret != PLAYER_ERROR_NONE) {
     
196.         ERR("player_create is failed [%d]", ret);
     
197. 
     
198.         return false;
     
199.     }
     
200.     ret = player_set_looping(g_player, true);
     
201.     if (ret != PLAYER_ERROR_NONE) {
     
202.         ERR("player_set_looping is failed [%d]", ret);
     
203. 
     
204.         return false;
     
205.     }
     
206. 
     
207.     char *app_res_path = app_get_resource_path();
     
208.     snprintf(audio_file, sizeof(audio_file), "%s/%s", app_res_path, AUDIO_FILE_NAME);
     
209.     free(app_res_path);
     
210. 
     
211.     return true;
     
212. }
     
213. 
     
214. /* Initialize player */
     
215. bool
     
216. init_user()
     
217. {
     
218.     FN_CALL;
     
219. 
     
220.     int ret;
     
221. 
     
222.     ret = user_player_init();
     
223. 
     
224.     return ret;
     
225. }
     
226. 
     
227. /* Handle: for getting request on switch */
     
228. bool
     
229. handle_get_request_on_switch(st_things_get_request_message_s *req_msg, st_things_representation_s *resp_rep)
     
230. {
     
231.     DBG("current g_switch: [%s]", g_switch);
     
232.     resp_rep->set_str_value(resp_rep, KEY_SWITCH, g_switch);
     
233. 
     
234.     return true;
     
235. }
     
236. 
     
237. /* Handle: for setting request on switch */
     
238. bool
     
239. handle_set_request_on_switch(st_things_set_request_message_s *req_msg, st_things_representation_s *resp_rep)
     
240. {
     
241.     DBG("current g_switch: [%s]", g_switch);
     
242. 
     
243.     char *str_value = NULL;
     
244.     req_msg->rep->get_str_value(req_msg->rep, KEY_SWITCH, &str_value);
     
245.     DBG("requested switch: [%s]", str_value);
     
246. 
     
247.     /* Check validation */
     
248.     if ((0 != strncmp(str_value, VALUE_SWITCH_ON, strlen(VALUE_SWITCH_ON)))
     
249.         && (0 != strncmp(str_value, VALUE_SWITCH_OFF, strlen(VALUE_SWITCH_OFF)))) {
     
250.         ERR("Not supported value!!");
     
251.         free(str_value);
     
252. 
     
253.         return false;
     
254.     }
     
255. 
     
256.     if (0 != strncmp(str_value, g_switch, strlen(g_switch))) {
     
257.         strncpy(g_switch, str_value, VALUE_STR_LEN_MAX);
     
258.         if (0 == strncmp(g_switch, VALUE_SWITCH_ON, strlen(VALUE_SWITCH_ON)))
     
259.             user_player_start();
     
260.         else
     
261.             user_player_stop();
     
262.     }
     
263.     resp_rep->set_str_value(resp_rep, KEY_SWITCH, g_switch);
     
264. 
     
265.     st_things_notify_observers(req_msg->resource_uri);
     
266. 
     
267.     free(str_value);
     
268. 
     
269.     return true;
     
270. }
     
271. 
     
272. /* Handle: for getting request on volume */
     
273. bool
     
274. handle_get_request_on_volume(st_things_get_request_message_s *req_msg, st_things_representation_s *resp_rep)
     
275. {
     
276.     DBG("current g_volume: [%lld], g_mute:[%d]", g_volume, g_mute);
     
277. 
     
278.     if (req_msg->has_property_key(req_msg, KEY_VOLUME)) {
     
279.         DBG("key[%s] exists", KEY_VOLUME);
     
280.         float temp_vol = 0.0;
     
281.         user_player_get_volume(&temp_vol);
     
282.         g_volume = (int64_t) (temp_vol * 100);
     
283.         DBG("current g_volume: [%lld]", g_volume);
     
284.         resp_rep->set_int_value(resp_rep, KEY_VOLUME, g_volume);
     
285.     }
     
286. 
     
287.     if (req_msg->has_property_key(req_msg, KEY_MUTE)) {
     
288.         DBG("key[%s] exists", KEY_MUTE);
     
289.         user_player_is_muted(&g_mute);
     
290.         DBG("current g_mute: [%d]", g_mute);
     
291.         resp_rep->set_bool_value(resp_rep, KEY_MUTE, g_mute);
     
292.     }
     
293. 
     
294.     if (req_msg->has_property_key(req_msg, KEY_VOLUME_COMMAND))
     
295.         WARN("key[%s] exists..Ignore It!", KEY_VOLUME_COMMAND);
     
296. 
     
297.     return true;
     
298. }
     
299. 
     
300. /* Handle: for setting request on volume */
     
301. bool
     
302. handle_set_request_on_volume(st_things_set_request_message_s *req_msg, st_things_representation_s *resp_rep)
     
303. {
     
304.     DBG("current g_volume: [%lld], g_mute:[%d]", g_volume, g_mute);
     
305. 
     
306.     int64_t ivalue;
     
307.     if (req_msg->rep->get_int_value(req_msg->rep, KEY_VOLUME, &ivalue)) {
     
308.         DBG("requested volume: [%lld]", ivalue);
     
309.         g_volume = ivalue;
     
310.         float temp_vol = (float) (g_volume/100.);
     
311.         user_player_set_volume(temp_vol);
     
312.         resp_rep->set_int_value(resp_rep, KEY_VOLUME, g_volume);
     
313.     }
     
314. 
     
315.     bool bvalue;
     
316.     if (req_msg->rep->get_bool_value(req_msg->rep, KEY_MUTE, &bvalue)) {
     
317.         DBG("requested mute: [%d]", bvalue);
     
318.         g_mute = bvalue;
     
319.         user_player_set_mute(g_mute);
     
320.         resp_rep->set_bool_value(resp_rep, KEY_MUTE, g_mute);
     
321.     }
     
322. 
     
323.     char *str_value = NULL;
     
324.     if (req_msg->rep->get_str_value(req_msg->rep, KEY_VOLUME_COMMAND, &str_value)) {
     
325.         DBG("requested volume_cmd: [%s]", str_value);
     
326. 
     
327.         strncpy(g_volume_cmd, str_value, VALUE_STR_LEN_MAX);
     
328.         if (0 == strncmp(g_volume_cmd, VALUE_VOLUME_COMMAND_INC, strlen(VALUE_VOLUME_COMMAND_INC)))
     
329.             DBG("TODO");
     
330.         else if (0 == strncmp(g_volume_cmd, VALUE_VOLUME_COMMAND_DEC, strlen(VALUE_VOLUME_COMMAND_DEC)))
     
331.             DBG("TODO");
     
332.         else if (0 == strncmp(g_volume_cmd, VALUE_VOLUME_COMMAND_MAX, strlen(VALUE_VOLUME_COMMAND_MAX)))
     
333.             DBG("TODO");
     
334.         else if (0 == strncmp(g_volume_cmd, VALUE_VOLUME_COMMAND_MIN, strlen(VALUE_VOLUME_COMMAND_MIN)))
     
335.             DBG("TODO");
     
336.         else
     
337.             ERR("Not supported command");
     
338. 
     
339.         resp_rep->set_str_value(resp_rep, KEY_VOLUME_COMMAND, g_volume_cmd);
     
340.         free(str_value);
     
341.     }
     
342. 
     
343.     st_things_notify_observers(req_msg->resource_uri);
     
344. 
     
345.     return true;
     
346. }
     
347. 
     
348. /* Handle: reset request*/
     
349. bool
     
350. handle_reset_request()
     
351. {
     
352.     bool confirmed = true;
     
353.     DBG("confirmed : [%d]", confirmed);
     
354. 
     
355.     return confirmed;
     
356. }
     
357. 
     
358. /* Handle: reset result */
     
359. void
     
360. handle_reset_result(bool result)
     
361. {
     
362.     DBG("result : [%d]", result);
     
363. }
     
364. 
     
365. /* Handle: ownership transfer request */
     
366. bool
     
367. handle_ownership_transfer_request()
     
368. {
     
369.     bool confirmed = true;
     
370.     DBG("confirmed : [%d]", confirmed);
     
371. 
     
372.     return confirmed;
     
373. }
     
374. 
     
375. /* Handle: for things status change */
     
376. void
     
377. handle_things_status_change(st_things_status_e things_status)
     
378. {
     
379.     DBG("things_status : [%d]", things_status);
     
380. }

复制代码

测试
测试样品：

1.将您的ARTIK 530或Raspberry Pi 3板通过USB连接到Linux计算机，然后打开SDB。
2.右键单击项目，然后选择“运行方式”>“Tizen Native项目”。

3.要检查样品是否启动，请使用SDB shell中的ifconfig命令检查Wi-Fi（Soft AP）是否已打开。
使用您的Samsung Connect App搜索并添加设备。 然后，您可以看到目标板已连接到SmartThings Cloud，Samsung Connect App在其UI中显示此设备。

附：
PREV Tizen外设I / O Native API