4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Sungsik Jang <sungsik.jang@samsung.com>, Dongwook Lee <dwmax.lee@samsung.com>
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
21 #ifndef __TIZEN_NET_WIFI_DIRECT_H__
22 #define __TIZEN_NET_WIFI_DIRECT_H__
31 * @addtogroup CAPI_NETWORK_WIFI_DIRECT_MODULE
36 * @brief Wi-Fi Direct Device Name maximum length.
39 #define WIFI_DIRECT_MAX_DEVICE_NAME_LEN 32
42 * @brief Wi-Fi Direct MAC Address length.
45 #define WIFI_DIRECT_MAC_ADDRESS_LEN 18
48 * @brief Enumeration for Wi-Fi Direct error code.
52 WIFI_DIRECT_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
53 WIFI_DIRECT_ERROR_NOT_PERMITTED = TIZEN_ERROR_NOT_PERMITTED, /**< Operation not permitted(1) */
54 WIFI_DIRECT_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory(12) */
55 WIFI_DIRECT_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied(13) */
56 WIFI_DIRECT_ERROR_RESOURCE_BUSY = TIZEN_ERROR_RESOURCE_BUSY, /**< Device or resource busy(16) */
57 WIFI_DIRECT_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid function parameter(22) */
58 WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT = TIZEN_ERROR_CONNECTION_TIME_OUT, /**< Connection timed out(110) */
59 WIFI_DIRECT_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
60 WIFI_DIRECT_ERROR_NOT_INITIALIZED = TIZEN_ERROR_WIFI_DIRECT|0x01, /**< Not initialized */
61 WIFI_DIRECT_ERROR_COMMUNICATION_FAILED = TIZEN_ERROR_WIFI_DIRECT|0x02, /**< I/O error */
62 WIFI_DIRECT_ERROR_WIFI_USED = TIZEN_ERROR_WIFI_DIRECT|0x03, /**< WiFi is being used */
63 WIFI_DIRECT_ERROR_MOBILE_AP_USED = TIZEN_ERROR_WIFI_DIRECT|0x04, /**< Mobile AP is being used */
64 WIFI_DIRECT_ERROR_CONNECTION_FAILED = TIZEN_ERROR_WIFI_DIRECT|0x05, /**< Connection failed */
65 WIFI_DIRECT_ERROR_AUTH_FAILED = TIZEN_ERROR_WIFI_DIRECT|0x06, /**< Authentication failed */
66 WIFI_DIRECT_ERROR_OPERATION_FAILED = TIZEN_ERROR_WIFI_DIRECT|0x07, /**< Operation failed */
67 WIFI_DIRECT_ERROR_TOO_MANY_CLIENT = TIZEN_ERROR_WIFI_DIRECT|0x08, /**< Too many client */
68 WIFI_DIRECT_ERROR_ALREADY_INITIALIZED = TIZEN_ERROR_WIFI_DIRECT|0x09, /**< Already initialized client */
69 WIFI_DIRECT_ERROR_CONNECTION_CANCELED = TIZEN_ERROR_WIFI_DIRECT|0x10, /**< Connection canceled by local device */
70 } wifi_direct_error_e;
74 * @brief Enumeration for Wi-Fi Direct link status.
76 * @see wifi_direct_state_changed_cb()
77 * @see wifi_direct_get_state()
80 WIFI_DIRECT_STATE_DEACTIVATED, /**< Deactivated */
81 WIFI_DIRECT_STATE_DEACTIVATING, /**< Deactivating */
82 WIFI_DIRECT_STATE_ACTIVATING, /**< Activating */
83 WIFI_DIRECT_STATE_ACTIVATED, /**< Activated */
84 WIFI_DIRECT_STATE_DISCOVERING, /**< Discovering */
85 WIFI_DIRECT_STATE_CONNECTING, /**< Connecting */
86 WIFI_DIRECT_STATE_DISCONNECTING, /**< Disconnecting */
87 WIFI_DIRECT_STATE_CONNECTED, /**< Connected */
88 WIFI_DIRECT_STATE_GROUP_OWNER /**< Group owner */
89 } wifi_direct_state_e;
93 * @brief Enumeration for Wi-Fi Direct device state.
95 * @see wifi_direct_device_state_changed_cb()
98 WIFI_DIRECT_DEVICE_STATE_ACTIVATED, /**< Activated */
99 WIFI_DIRECT_DEVICE_STATE_DEACTIVATED, /**< Deactivated */
100 } wifi_direct_device_state_e;
104 * @brief Enumeration for Wi-Fi Direct discovery state.
106 * @see wifi_direct_discovery_state_chagned_cb()
107 * @see wifi_direct_peer_found_cb()
110 WIFI_DIRECT_ONLY_LISTEN_STARTED, /**< Only listen started */
111 WIFI_DIRECT_DISCOVERY_STARTED, /**< Discovery started */
112 WIFI_DIRECT_DISCOVERY_FOUND, /**< A remote peer is found */
113 WIFI_DIRECT_DISCOVERY_FINISHED, /**< Discovery finished */
114 WIFI_DIRECT_DISCOVERY_LOST, /**< A remote peer is lost (Since 3.0)*/
115 } wifi_direct_discovery_state_e;
119 * @brief Enumeration for Wi-Fi Direct connection state.
121 * @see wifi_direct_connection_state_changed_cb()
124 WIFI_DIRECT_CONNECTION_REQ, /**< Connection is requested */
125 WIFI_DIRECT_CONNECTION_WPS_REQ, /**< WPS is requested */
126 WIFI_DIRECT_CONNECTION_IN_PROGRESS, /**< Connection in progress */
127 WIFI_DIRECT_CONNECTION_RSP, /**< Connection response */
128 WIFI_DIRECT_DISASSOCIATION_IND, /**< Disconnected by remote Group Client */
129 WIFI_DIRECT_DISCONNECTION_RSP, /**< Disconnected by local device */
130 WIFI_DIRECT_DISCONNECTION_IND, /**< Disconnected by remote Group Owner */
131 WIFI_DIRECT_GROUP_CREATED, /**< Group is created */
132 WIFI_DIRECT_GROUP_DESTROYED, /**< Group is destroyed */
133 } wifi_direct_connection_state_e;
136 * @brief Enumeration for WPS Config Method type.
140 WIFI_DIRECT_CONFIG_METHOD_DEFAULT = 0x00, /**< Use default config method */
141 WIFI_DIRECT_CONFIG_METHOD_PBC = 0x01, /**< Push Button Configuration */
142 WIFI_DIRECT_CONFIG_METHOD_PIN_DISPLAY = 0x02, /**< Display PIN code */
143 WIFI_DIRECT_CONFIG_METHOD_PIN_KEYPAD = 0x04, /**< Provide the keypad to input the PIN */
144 } wifi_direct_config_method_type_e;
147 * @brief Enumeration for Wi-Fi Direct secondary device type.
149 * @see wifi_direct_get_secondary_device_type()
152 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_COMPUTER_PC = 1, /**< PC */
153 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_COMPUTER_SERVER = 2, /**< Server */
154 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_COMPUTER_MEDIA_CENTER = 3, /**< Media Center */
155 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_COMPUTER_UMPC = 4, /**< UMPC */
156 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_COMPUTER_NOTEBOOK = 5, /**< Notebook */
157 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_COMPUTER_DESKTOP = 6, /**< Desktop */
158 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_COMPUTER_MID = 7, /**< MID */
159 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_COMPUTER_NETBOOK = 8, /**< Netbook */
160 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_KEYBOARD = 1, /**< Keyboard */
161 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_MOUSE = 2, /**< Mouse */
162 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_JOYSTICK = 3, /**< Joystick */
163 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_TRACKBALL = 4, /**< Trackball */
164 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_CONTROLLER = 5, /**< Controller */
165 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_REMOTE = 6, /**< Remote */
166 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_TOUCHSCREEN = 7, /**< Touchscreen */
167 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_BIOMETRIC_READER = 8, /**< Biometric reader */
168 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_BARCODE_READER = 9, /**< Barcode reader */
169 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_PRINTER_PRINTER = 1, /**< Printer */
170 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_PRINTER_SCANNER = 2, /**< Scanner */
171 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_PRINTER_FAX = 3, /**< Fax */
172 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_PRINTER_COPIER = 4, /**< Copier */
173 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_PRINTER_ALL_IN_ONE = 5, /**< All-in-one */
174 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_CAMERA_DIGITAL_STILL = 1, /**< Digital still camera */
175 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_CAMERA_VIDEO = 2, /**< Video camera */
176 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_CAMERA_WEBCAM = 3, /**< Webcam */
177 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_CAMERA_SECURITY = 4, /**< Security camera */
178 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_STORAGE_NAS = 1, /**< NAS */
179 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_NETWORK_INFRA_AP = 1, /**< AP */
180 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_NETWORK_INFRA_ROUTER = 2, /**< Router */
181 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_NETWORK_INFRA_SWITCH = 3, /**< Switch */
182 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_NETWORK_INFRA_GATEWAY = 4, /**< Gateway */
183 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_DISPLAY_TV = 1, /**< TV */
184 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_DISPLAY_PIC_FRAME = 2, /**< Picture frame */
185 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_DISPLAY_PROJECTOR = 3, /**< Projector */
186 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_DISPLAY_MONITOR = 4, /**< Monitor */
187 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_DAR = 1, /**< DAR */
188 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_PVR = 2, /**< PVR */
189 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_MCX = 3, /**< MCX */
190 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_STB = 4, /**< Set-top box */
191 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_MS_MA_ME = 5, /**< Media Server / Media Adapter / Media Extender */
192 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_MULTIMEDIA_PVP = 6, /**< Portable video player */
193 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_GAME_XBOX = 1, /**< Xbox */
194 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_GAME_XBOX_360 = 2, /**< Xbox 360 */
195 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_GAME_PS = 3, /**< Playstation */
196 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_GAME_CONSOLE = 4, /**< Console */
197 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_GAME_PORTABLE = 5, /**< Portable */
198 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_TELEPHONE_WINDOWS_MOBILE = 1, /**< Windows Mobile */
199 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_TELEPHONE_PHONE_SINGLE = 2, /**< Phone - single mode */
200 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_TELEPHONE_PHONE_DUAL = 3, /**< Phone - dual mode */
201 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_TELEPHONE_SMARTPHONE_SINGLE = 4, /**< Smart Phone - single mode */
202 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_TELEPHONE_SMARTPHONE_DUAL = 5, /**< Smart Phone - dual mode */
203 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_AUDIO_TUNER = 1, /**< Tuner */
204 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_AUDIO_SPEAKER = 2, /**< Speaker */
205 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_AUDIO_PMP = 3, /**< Portable Music Player */
206 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_AUDIO_HEADSET = 4, /**< Headset */
207 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_AUDIO_HEADPHONE = 5, /**< Headphone */
208 WIFI_DIRECT_SECONDARY_DEVICE_TYPE_AUDIO_MIC = 6, /**< Microphone */
209 } wifi_direct_secondary_device_type_e;
213 * @brief Enumeration for Wi-Fi Direct primary device type.
215 * @see wifi_direct_get_primary_device_type()
218 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_COMPUTER = 1, /**< Computer */
219 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_INPUT_DEVICE = 2, /**< Input device */
220 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_PRINTER = 3, /**< Printer */
221 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_CAMERA = 4, /**< Camera */
222 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_STORAGE = 5, /**< Storage */
223 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_NETWORK_INFRA = 6, /**< Network Infrastructure */
224 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_DISPLAY = 7, /**< Display */
225 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_MULTIMEDIA_DEVICE = 8, /**< Multimedia device */
226 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_GAME_DEVICE = 9, /**< Game device */
227 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_TELEPHONE = 10, /**< Telephone */
228 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_AUDIO = 11, /**< Audio */
229 WIFI_DIRECT_PRIMARY_DEVICE_TYPE_OTHER = 255 /**< Others */
230 } wifi_direct_primary_device_type_e;
234 * @brief Enumeration for Wi-Fi WPS type.
236 * @see wifi_direct_supported_wps_type_cb()
237 * @see wifi_direct_get_local_wps_type()
238 * @see wifi_direct_set_req_wps_type()
239 * @see wifi_direct_get_req_wps_type()
242 WIFI_DIRECT_WPS_TYPE_NONE = 0x00, /**< No WPS type */
243 WIFI_DIRECT_WPS_TYPE_PBC = 0x01, /**< Push Button Configuration */
244 WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY = 0x02, /**< Display PIN code */
245 WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD = 0x04, /**< Provide the keypad to input the PIN */
246 } wifi_direct_wps_type_e;
250 * @deprecated Deprecated since 5.0. Use #wifi_direct_display_type_e instead.
251 * @brief Enumeration for Wi-Fi Display device type.
255 WIFI_DISPLAY_TYPE_NONE, /**< Configure as WFD Source*/
256 WIFI_DISPLAY_TYPE_SINK, /**< Configure as WFD Primary Sink */
257 WIFI_DISPLAY_TYPE_SRC, /**< Configure as WFD Secondary Sink */
258 WIFI_DISPLAY_TYPE_DUAL, /**< Configure as WFD Dual Role */
259 WIFI_DISPLAY_TYPE_MAX, /**< Not configured */
260 } wifi_display_type_e;
264 * @brief Enumeration for Service Discovery type.
266 * @see wifi_direct_service_state_changed_cb()
267 * @see wifi_direct_start_service_discovery()
268 * @see wifi_direct_cancel_service_discovery()
269 * @see wifi_direct_register_service()
272 WIFI_DIRECT_SERVICE_TYPE_ALL, /**< Service discovery type all */
273 WIFI_DIRECT_SERVICE_TYPE_BONJOUR, /**< Service discovery type bonjour */
274 WIFI_DIRECT_SERVICE_TYPE_UPNP, /**< Service discovery type UPNP */
275 WIFI_DIRECT_SERVICE_TYPE_WS_DISCOVERY, /**< Service discovery type ws discovery */
276 WIFI_DIRECT_SERVICE_TYPE_WIFI_DISPLAY, /**< Service discovery type wifi-display */
277 WIFI_DIRECT_SERVICE_TYPE_BT_ADDR, /**< Service discovery type bt address */
278 WIFI_DIRECT_SERVICE_TYPE_CONTACT_INFO, /**< Service discovery type contact info */
279 WIFI_DIRECT_SERVICE_TYPE_VENDOR = 0xff, /**< Service discovery type vendor-specific */
280 } wifi_direct_service_type_e;
284 * @brief Enumeration for Wi-Fi Display device type.
286 * @see wifi_direct_set_display()
287 * @see wifi_direct_get_peer_display_type()
290 WIFI_DIRECT_DISPLAY_TYPE_SOURCE, /**< Configure as WFD Source*/
291 WIFI_DIRECT_DISPLAY_TYPE_PRISINK, /**< Configure as WFD Primary Sink */
292 WIFI_DIRECT_DISPLAY_TYPE_SECSINK, /**< Configure as WFD Secondary Sink */
293 WIFI_DIRECT_DISPLAY_TYPE_DUAL, /**< Configure as WFD Dual Role */
294 WIFI_DIRECT_DISPLAY_TYPE_MAX, /**< Not configured */
295 } wifi_direct_display_type_e;
299 * @brief Enumeration for Wi-Fi Direct service Discovery state.
301 * @see wifi_direct_service_state_changed_cb()
304 WIFI_DIRECT_SERVICE_DISCOVERY_STARTED, /**< Service discovery started */
305 WIFI_DIRECT_SERVICE_DISCOVERY_FOUND, /**< Service discovery found */
306 WIFI_DIRECT_SERVICE_DISCOVERY_FINISHED, /**< Service discovery finished */
307 } wifi_direct_service_discovery_state_e;
311 * @brief Enumeration for Wi-Fi Direct Discovery Channel.
313 * @see wifi_direct_start_discovery_specific_channel()
316 WIFI_DIRECT_DISCOVERY_FULL_SCAN = 0, /**< Scan full channel */
317 WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL = 1611, /**< Scan social channel */
318 WIFI_DIRECT_DISCOVERY_CHANNEL1 = 1, /**< Scan channel 1 */
319 WIFI_DIRECT_DISCOVERY_CHANNEL6 = 6, /**< Scan channel 6 */
320 WIFI_DIRECT_DISCOVERY_CHANNEL11 = 11, /**< Scan channel 11 */
321 } wifi_direct_discovery_channel_e;
324 * @brief Enumeration for Wi-Fi Frame type.
326 * @see wifi_direct_add_vsie()
327 * @see wifi_direct_remove_vsie()
328 * @see wifi_direct_get_vsie()
332 * P2P probe request frame
334 WIFI_DIRECT_VSIE_FRAME_P2P_PROBE_REQ,
337 * P2P probe response frame
339 WIFI_DIRECT_VSIE_FRAME_P2P_PROBE_RESP,
342 * P2P group owner probe response frame
344 WIFI_DIRECT_VSIE_FRAME_P2P_GO_PROBE_RESP,
347 * P2P probe request frame
349 WIFI_DIRECT_VSIE_FRAME_P2P_GO_BEACON,
352 * P2P provision discovery request frame
354 WIFI_DIRECT_VSIE_FRAME_P2P_PD_REQ,
357 * P2P provision discovery response frame
359 WIFI_DIRECT_VSIE_FRAME_P2P_PD_RESP,
362 * P2P probe request frame
364 WIFI_DIRECT_VSIE_FRAME_P2P_GO_NEG_REQ,
367 * P2P group owner negotiation response frame
369 WIFI_DIRECT_VSIE_FRAME_P2P_GO_NEG_RESP,
372 * P2P group owner negotiation confirmation frame
374 WIFI_DIRECT_VSIE_FRAME_P2P_GO_NEG_CONF,
377 * P2P invitation request frame
379 WIFI_DIRECT_VSIE_FRAME_P2P_INV_REQ,
382 * P2P invitation response frame
384 WIFI_DIRECT_VSIE_FRAME_P2P_INV_RESP,
387 * P2P association request frame
389 WIFI_DIRECT_VSIE_FRAME_P2P_ASSOC_REQ,
392 * P2P association response frame
394 WIFI_DIRECT_VSIE_FRAME_P2P_ASSOC_RESP,
397 * Association request frame
399 WIFI_DIRECT_VSIE_FRAME_ASSOC_REQ,
400 } wifi_direct_vsie_frames_e;
403 * @brief Wi-Fi Direct connection state structure to store result of new connection state callback.
407 char device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN+1]; /**< Null-terminated device friendly name. */
408 char mac_address[WIFI_DIRECT_MAC_ADDRESS_LEN+1]; /**< Null-terminated Device's P2P Device Address */
409 } wifi_direct_connection_state_cb_data_s;
412 * @brief Wi-Fi Direct buffer structure to store result of peer discovery.
414 * @remarks You can use APIs for Wi-Fi Direct display function instead of is_miracast_device value
415 * which is deprecated since 2.4.
416 * @see wifi_direct_discovered_peer_cb()
417 * @see wifi_direct_get_peer_info()
418 * @see wifi_direct_get_connecting_peer_info()
422 * Device's friendly name
427 * Device's P2P Device Address
432 * Device's P2P Interface Address, Valid only if device is a P2P GO
434 char *interface_address;
437 * Channel the device is listening on
447 * Is an active P2P Group Owner
452 * Is a stored Persistent GO
454 bool is_persistent_group_owner;
457 * Primary category of device
459 wifi_direct_primary_device_type_e primary_device_type;
462 * Sub category of device
464 wifi_direct_secondary_device_type_e secondary_device_type;
467 * The list of supported WPS type. The OR operation on
468 * #wifi_direct_wps_type_e can be used like
469 * #WIFI_DIRECT_WPS_TYPE_PBC | #WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY
471 int supported_wps_types;
474 * Is capable of processing P2P Invitation Procedure signaling
476 bool is_p2p_invitation_procedure_supported;
479 * The number of Registered services
481 unsigned int service_count;
484 * The list of registered services
489 * Is a wifi display device
490 * @deprecated Deprecated since 2.4, use wifi direct display APIs instead of
491 * is_miracast_device value.
493 bool is_miracast_device;
496 * The information for vendor specific information element
497 * @deprecated Deprecated since 5.0, use wifi_direct_get_peer_vsie() API instead of
501 } wifi_direct_discovered_peer_info_s;
505 * @brief Wi-Fi Direct buffer structure to store information of connected peer.
507 * @remarks You can use APIs for wifi-direct display function instead of is_miracast_device value
508 * which is deprecated since 2.4.
509 * @see wifi_direct_connected_peer_cb()
513 * Device's friendly name
523 * Device's P2P Device Address
528 * Device's P2P Interface Address
530 char *interface_address;
538 * Whether peer is a P2P device
543 * Primary category of device
545 wifi_direct_primary_device_type_e primary_device_type;
548 * Sub category of device
550 wifi_direct_secondary_device_type_e secondary_device_type;
553 * The number of Registered services
555 unsigned int service_count;
558 * The list of registered services
563 * Is a wifi display device
564 * @deprecated since tizen 2.4, use wifi direct display APIs instead of
565 * is_miracast_device value.
567 bool is_miracast_device;
568 } wifi_direct_connected_peer_info_s;
572 * @brief Called when the state of discovery is changed.
573 * @details The following error codes can be delivered
574 * #WIFI_DIRECT_ERROR_NONE
575 * #WIFI_DIRECT_ERROR_OPERATION_FAILED
576 * #WIFI_DIRECT_ERROR_NOT_PERMITTED
578 * @param[in] error_code The error code
579 * @param[in] discovery_state The discovery state
580 * @param[in] user_data The user data passed from the callback registration function
581 * @pre Either wifi_direct_start_discovery() or wifi_direct_cancel_discovery()
582 * will invoke this callback in the thread-default main context of the thread
583 * from which you registered this callback using wifi_direct_set_discovery_state_changed_cb().
584 * @see wifi_direct_start_discovery()
585 * @see wifi_direct_cancel_discovery()
586 * @see wifi_direct_set_discovery_state_changed_cb()
587 * @see wifi_direct_unset_discovery_state_changed_cb()
589 typedef void (*wifi_direct_discovery_state_chagned_cb) (int error_code,
590 wifi_direct_discovery_state_e discovery_state,
595 * @brief Called when the peer is found.
596 * @details The following error codes can be delivered
597 * #WIFI_DIRECT_ERROR_NONE
598 * #WIFI_DIRECT_ERROR_OPERATION_FAILED
599 * #WIFI_DIRECT_ERROR_NOT_PERMITTED
601 * @remarks The @a mac_address can be used only in the callback. To use outside, make a copy.
602 * @param[in] error_code The error code
603 * @param[in] discovery_state The discovery state
604 * @param[in] mac_address The MAC address of found peer
605 * @param[in] user_data The user data passed from the callback registration function
606 * @pre Either wifi_direct_start_discovery() or wifi_direct_cancel_discovery()
607 * will invoke this callback in the thread-default main context of the thread
608 * from which you registered this callback using wifi_direct_set_peer_found_cb().
609 * @see wifi_direct_start_discovery()
610 * @see wifi_direct_cancel_discovery()
611 * @see wifi_direct_set_peer_found_cb()
612 * @see wifi_direct_unset_peer_found_cb()
614 typedef void (*wifi_direct_peer_found_cb) (int error_code,
615 wifi_direct_discovery_state_e discovery_state,
616 const char *mac_address,
621 * @brief Called when the state of device is changed.
622 * @details The following error codes can be delivered
623 * #WIFI_DIRECT_ERROR_NONE
624 * #WIFI_DIRECT_ERROR_OPERATION_FAILED
625 * #WIFI_DIRECT_ERROR_NOT_PERMITTED
627 * @param[in] error_code The error code
628 * @param[in] device_state The device state
629 * @param[in] user_data The user data passed from the callback registration function
630 * @pre Either wifi_direct_activate() or wifi_direct_deactivate() will invoke
631 * this callback in the thread-default main context of the thread from which you
632 * registered this callback using wifi_direct_set_device_state_changed_cb().
633 * @see wifi_direct_activate()
634 * @see wifi_direct_deactivate()
635 * @see wifi_direct_set_device_state_changed_cb()
636 * @see wifi_direct_unset_device_state_changed_cb()
638 typedef void (*wifi_direct_device_state_changed_cb) (int error_code,
639 wifi_direct_device_state_e device_state,
644 * @brief Called when the state of connection is changed.
645 * @details The following error codes can be delivered
646 * #WIFI_DIRECT_ERROR_NONE
647 * #WIFI_DIRECT_ERROR_OPERATION_FAILED
648 * #WIFI_DIRECT_ERROR_NOT_PERMITTED
649 * #WIFI_DIRECT_ERROR_CONNECTION_FAILED
651 * @remarks The @a mac_address can be used only in the callback. To use outside, make a copy.
652 * @param[in] error_code The error code
653 * @param[in] connection_state The connection state
654 * @param[in] mac_address The MAC address of the connection peer
655 * @param[in] user_data The user data passed from the callback registration function
656 * @pre wifi_direct_create_group(), wifi_direct_destroy_group(),
657 * wifi_direct_connect(), wifi_direct_disconnect() or
658 * wifi_direct_disconnect_all() will invoke this callback in the thread-default
659 * main context of the thread from which you registered this callback using
660 * using wifi_direct_set_connection_state_changed_cb().
661 * @see wifi_direct_connect()
662 * @see wifi_direct_disconnect()
663 * @see wifi_direct_disconnect_all()
664 * @see wifi_direct_set_connection_state_changed_cb()
665 * @see wifi_direct_unset_connection_state_changed_cb()
667 typedef void (*wifi_direct_connection_state_changed_cb) (int error_code,
668 wifi_direct_connection_state_e connection_state,
669 const char *mac_address,
673 * @brief Called when the state of connection is changed.
674 * @details The following error codes can be delivered:\n
675 * #WIFI_DIRECT_ERROR_NONE\n
676 * #WIFI_DIRECT_ERROR_OPERATION_FAILED\n
677 * #WIFI_DIRECT_ERROR_NOT_PERMITTED
679 * @param[in] error_code The error code
680 * @param[in] connection_state The connection state
681 * @param[in] data_s The structure for peer data
682 * @param[in] user_data The user data passed from the callback registration function
683 * @pre wifi_direct_create_group(), wifi_direct_destroy_group(), wifi_direct_connect(), wifi_direct_disconnect() or wifi_direct_disconnect_all() will invoke this callback
684 * if you register this callback using wifi_direct_set_peer_info_connection_state_changed_cb().
685 * @see wifi_direct_connect()
686 * @see wifi_direct_disconnect()
687 * @see wifi_direct_disconnect_all()
688 * @see wifi_direct_set_peer_info_connection_state_changed_cb()
689 * @see wifi_direct_unset_peer_info_connection_state_changed_cb()
691 typedef void (*wifi_direct_peer_info_connection_state_changed_cb)(wifi_direct_error_e error_code,
692 wifi_direct_connection_state_e connection_state,
693 wifi_direct_connection_state_cb_data_s data_s,
697 * @brief Called when IP address of client is assigned when your device is the group owner.
698 * @details The following error codes can be delivered
699 * #WIFI_DIRECT_ERROR_NONE
700 * #WIFI_DIRECT_ERROR_OPERATION_FAILED
701 * #WIFI_DIRECT_ERROR_NOT_PERMITTED
703 * @remarks The @a mac_address can be used only in the callback. To use outside, make a copy.
704 * The @a ip_address can be used only in the callback. To use outside, make a copy.
705 * The @a interface_address can be used only in the callback. To use outside, make a copy.
706 * @param[in] mac_address The MAC address of connection peer
707 * @param[in] ip_address The IP address of connection peer
708 * @param[in] interface_address The interface address of connection peer
709 * @param[in] user_data The user data passed from the callback registration function
710 * @pre This callback will be invoked in the thread-default main context of the
711 * thread from which you registered this callback using wifi_direct_set_client_ip_address_assigned_cb().
712 * @see wifi_direct_set_client_ip_address_assigned_cb()
713 * @see wifi_direct_unset_client_ip_address_assigned_cb()
715 typedef void (*wifi_direct_client_ip_address_assigned_cb) (const char *mac_address,
716 const char *ip_address,
717 const char *interface_address,
722 * @brief Called when the state of Service discovery is changed.
723 * @details The following error codes can be delivered
724 * #WIFI_DIRECT_ERROR_NONE
725 * #WIFI_DIRECT_ERROR_OPERATION_FAILED
726 * #WIFI_DIRECT_ERROR_NOT_PERMITTED
728 * @remarks The @a mac_address can be used only in the callback. To use outside, make a copy.
729 * @param[in] error_code The error code
730 * @param[in] service_state The service discovery state
731 * @param[in] service_type Specifies the types of service
732 * @param[in] response_data Received response
733 * @param[in] mac_address The MAC address of the connection peer
734 * @param[in] user_data User can transfer the user specific data in callback
735 * @pre Either wifi_direct_start_service_discovery() or
736 * wifi_direct_cancel_service_discovery() will invoke this callback in the
737 * thread-default main context of the thread from which you registered this
738 * callback using wifi_direct_set_service_state_changed_cb().
739 * @see wifi_direct_start_discovery()
740 * @see wifi_direct_cancel_discovery()
741 * @see wifi_direct_set_discovery_state_changed_cb()
742 * @see wifi_direct_unset_discovery_state_changed_cb()
744 typedef void (*wifi_direct_service_state_changed_cb) (int error_code,
745 wifi_direct_service_discovery_state_e service_state,
746 wifi_direct_service_type_e service_type,
748 const char *mac_address,
753 * @brief Called when the state of Wi-FI Direct is changed.
755 * @param[in] state The Wi-Fi Direct state
756 * @param[in] user_data The user data passed from the callback registration function
757 * @pre Changes in Wi-Fi Direct state will invoke this callback
758 * if you register this callback using wifi_direct_set_state_changed_cb().
759 * @see wifi_direct_set_state_changed_cb()
760 * @see wifi_direct_unset_state_changed_cb()
762 typedef void (*wifi_direct_state_changed_cb) (wifi_direct_state_e state,
767 * @brief Initializes Wi-Fi Direct service.
770 * @privilege http://tizen.org/privilege/wifidirect
771 * @return @c 0 on success,
772 * otherwise a negative error value
773 * @retval #WIFI_DIRECT_ERROR_NONE Successful
774 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
775 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
776 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
777 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
778 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
779 * @see wifi_direct_deinitialize()
782 * Here is an example of the usage:
785 * #include <wifi_direct.h>
787 * void function(void)
791 * ret = wifi_direct_initialize();
793 * if (ret != WIFI_DIRECT_ERROR_NONE) {
794 * printf("Failed to initialize\n");
798 * printf("Initialized Successfully\n");
803 * function(); // initialize Wi-Fi Direct
804 * wifi_direct_deinitialize(); // deinitialize Wi-Fi Direct
809 int wifi_direct_initialize(void);
812 * @brief Deinitializes Wi-Fi Direct service.
814 * @return @c 0 on success,
815 * otherwise a negative error value
816 * @retval #WIFI_DIRECT_ERROR_NONE Successful
817 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
818 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
819 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
820 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
821 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
822 * @see wifi_direct_initialize()
825 * Here is an example of the usage:
828 * #include <wifi_direct.h>
830 * void function(void)
834 * ret = wifi_direct_deinitialize();
836 * if (ret != WIFI_DIRECT_ERROR_NONE) {
837 * printf("Failed to deinitialize\n");
841 * printf("Deinitialized Successfully\n");
846 * wifi_direct_initialize(); // initialize Wi-Fi Direct
847 * function(); // deinitialize Wi-Fi Direct
852 int wifi_direct_deinitialize(void);
856 * @brief Sets the callback called when the state of device is changed.
858 * @param[in] cb The callback function to invoke
859 * @param[in] user_data The user data to be passed to the callback function
860 * @return @c 0 on success,
861 * otherwise a negative error value
862 * @retval #WIFI_DIRECT_ERROR_NONE Successful
863 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
864 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
865 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
866 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
867 * @see wifi_direct_initialize()
868 * @see wifi_direct_unset_device_state_changed_cb()
869 * @see wifi_direct_device_state_changed_cb()
872 * Here is an example of the usage:
875 * #include <wifi_direct.h>
877 * void callback(int error_code,
878 * Wifi_direct_device_state_e device_state,
881 * switch (device_state) {
882 * case WIFI_DIRECT_DEVICE_STATE_ACTIVATED:
883 * printf("device activated\n");
885 * //Do stuff here when Wi-Fi Direct is activated
889 * case WIFI_DIRECT_DEVICE_STATE_DEACTIVATED:
890 * printf("device deactivated\n");
892 * //Do stuff here when Wi-Fi Direct is deactivated
901 * void function(void)
905 * ret = wifi_direct_set_device_state_changed_cb(callback, NULL);
907 * if (ret != WIFI_DIRECT_ERROR_NONE) {
908 * printf("Failed to register callback\n");
912 * printf("callback registered Successfully\n");
917 * wifi_direct_initialize(); // initialize Wi-Fi Direct
918 * wifi_direct_activate(); // Activate Wi-Fi Direct
920 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
921 * wifi_direct_deinitialize(); // deinitialize Wi-Fi Direct
926 int wifi_direct_set_device_state_changed_cb(wifi_direct_device_state_changed_cb cb, void *user_data);
930 * @brief Unsets the callback called when the state of device is changed.
932 * @return @c 0 on success,
933 * otherwise a negative error value
934 * @retval #WIFI_DIRECT_ERROR_NONE Successful
935 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
936 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
937 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
938 * @see wifi_direct_initialize()
939 * @see wifi_direct_set_device_state_changed_cb()
942 * Here is an example of the usage:
945 * #include <wifi_direct.h>
947 * void function(void)
951 * ret = wifi_direct_unset_device_state_changed_cb();
953 * if (ret != WIFI_DIRECT_ERROR_NONE) {
954 * printf("Failed to deregister callback\n");
958 * printf("callback deregistered Successfully\n");
963 * wifi_direct_initialize(); // initialize Wi-Fi Direct
965 * wifi_direct_deinitialize(); // deinitialize Wi-Fi Direct
970 int wifi_direct_unset_device_state_changed_cb(void);
974 * @brief Sets the callback called when the state of discovery is changed.
976 * @param[in] cb The callback function to invoke
977 * @param[in] user_data The user data to be passed to the callback function
978 * @return @c 0 on success,
979 * otherwise a negative error value
980 * @retval #WIFI_DIRECT_ERROR_NONE Successful
981 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
982 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
983 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
984 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
985 * @see wifi_direct_initialize()
986 * @see wifi_direct_unset_discovery_state_changed_cb()
987 * @see wifi_direct_discovery_state_chagned_cb()
990 * Here is an example of the usage:
993 * #include <wifi_direct.h>
995 * void callback(int error_code,
996 * wifi_direct_discovery_state_e discovery_state,
999 * switch(discovery_state) {
1000 * case WIFI_DIRECT_DISCOVERY_STARTED:
1001 * printf("Discovery started\n");
1004 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
1005 * printf("listen started\n");
1008 * case WIFI_DIRECT_DISCOVERY_FINISHED:
1009 * printf("Discovery finished\n");
1012 * case WIFI_DIRECT_DISCOVERY_FOUND:
1013 * printf("peer devices found\n");
1016 * case WIFI_DIRECT_DISCOVERY_LOST:
1017 * printf("Discovery lost\n");
1026 * void function(void)
1030 * ret = wifi_direct_set_discovery_state_changed_cb(callback, NULL);
1032 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1033 * printf("Failed to register callback\n");
1037 * printf("callback registered Successfully\n");
1042 * wifi_direct_initialize(); // initialize Wi-Fi Direct
1043 * wifi_direct_activate(); // Activate Wi-Fi Direct
1045 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
1046 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1051 int wifi_direct_set_discovery_state_changed_cb(wifi_direct_discovery_state_chagned_cb cb, void* user_data);
1055 * @brief Unsets the callback called when the state of discovery is changed.
1057 * @return @c 0 on success,
1058 * otherwise a negative error value
1059 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1060 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1061 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1062 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1063 * @see wifi_direct_initialize()
1064 * @see wifi_direct_set_discovery_state_changed_cb()
1067 * Here is an example of the usage:
1069 * #include <stdio.h>
1070 * #include <wifi_direct.h>
1072 * void function(void)
1076 * ret = wifi_direct_unset_discovery_state_changed_cb();
1078 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1079 * printf("Failed to deregister callback\n");
1083 * printf("callback deregistered Successfully\n");
1088 * wifi_direct_initialize(); // initialize Wi-Fi Direct
1089 * wifi_direct_activate(); // Activate Wi-FI Direct
1091 * wifi_direct_deactivate(); // Deactivate Wi-FI Direct
1092 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1097 int wifi_direct_unset_discovery_state_changed_cb(void);
1101 * @brief Sets the callback called when the peer is found.
1103 * @param[in] cb The callback function to invoke
1104 * @param[in] user_data The user data to be passed to the callback function
1105 * @return @c 0 on success,
1106 * otherwise a negative error value
1107 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1108 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
1109 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1110 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1111 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1112 * @see wifi_direct_initialize()
1113 * @see wifi_direct_unset_peer_found_cb()
1114 * @see wifi_direct_peer_found_cb()
1117 * Here is an example of the usage:
1119 * #include <stdio.h>
1120 * #include <wifi_direct.h>
1122 * void callback(int error_code,
1123 * wifi_direct_discovery_state_e discovery_state,
1124 * const char *mac_address,
1127 * switch (discovery_state) {
1128 * case WIFI_DIRECT_DISCOVERY_FOUND:
1129 * printf("Peer found\n");
1130 * printf("MAC Address=%s\n", mac_address);
1132 * // Do stuff here for discovered devices
1141 * void function(void)
1145 * ret = wifi_direct_set_peer_found_cb(callback, NULL);
1147 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1148 * printf("Failed to register callback\n");
1152 * printf("callback registered Successfully\n");
1157 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1158 * wifi_direct_activate(); // Activate Wi-Fi Direct
1160 * wifi_direct_deactivate(); // Deactivate Wi-FI Direct
1161 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1166 int wifi_direct_set_peer_found_cb(wifi_direct_peer_found_cb cb, void* user_data);
1170 * @brief Unsets the callback called when the peer is found.
1172 * @return @c 0 on success,
1173 * otherwise a negative error value
1174 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1175 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1176 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1177 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1178 * @see wifi_direct_initialize()
1179 * @see wifi_direct_set_peer_found_cb()
1182 * Here is an example of the usage:
1184 * #include <stdio.h>
1185 * #include <wifi_direct.h>
1187 * void function(void)
1191 * ret = wifi_direct_unset_peer_found_cb();
1193 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1194 * printf("Failed to deregister callback\n");
1198 * printf("callback deregistered Successfully\n");
1203 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1205 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1210 int wifi_direct_unset_peer_found_cb(void);
1214 * @brief Sets the callback called when the state of connection is changed.
1216 * @param[in] cb The callback function to invoke
1217 * @param[in] user_data The user data to be passed to the callback function
1218 * @return @c 0 on success,
1219 * otherwise a negative error value
1220 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1221 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
1222 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1223 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1224 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1225 * @see wifi_direct_initialize()
1226 * @see wifi_direct_unset_connection_state_changed_cb()
1227 * @see wifi_direct_connection_state_changed_cb()
1230 * Here is an example of the usage:
1232 * #include <stdio.h>
1233 * #include <wifi_direct.h>
1235 * void callback(int error_code,
1236 * wifi_direct_connection_state_e connection_state,
1237 * const char *mac_address,
1244 * switch (connection_state) {
1246 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
1247 * printf("Connection in progress\n");
1250 * case WIFI_DIRECT_CONNECTION_RSP:
1251 * if (error_code == WIFI_DIRECT_ERROR_NONE) {
1252 * printf("Peer Device Connected\n"); // device is connected
1254 * printf("MAC=%s\n", mac_address); // device's MAC address
1256 * wifi_direct_get_ip_address(&ip);
1257 * printf("IP=%s\n", ip); //device's IP address
1259 * wifi_direct_is_group_owner(&owner);
1260 * printf("Ownership=%s\n", (owner)? "GO":"STA"); // (GO or client role)
1262 * } else if (error_code == WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT) {
1263 * printf("Connection timeout occurred\n");
1264 * } else if (error_code == WIFI_DIRECT_ERROR_AUTH_FAILED) {
1265 * printf("Connection authorization Failed\n");
1267 * printf("Connection failed\n");
1270 * case WIFI_DIRECT_CONNECTION_WPS_REQ:
1272 * wifi_direct_get_local_wps_type(&wps_mode);
1274 * if (wps_mode == WIFI_DIRECT_WPS_TYPE_PBC) {
1275 * printf("Connection type WPS PBC\n");
1276 * // Handle WPS PBC case here
1279 * if (wps_mode == WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY) {
1280 * printf("Connection type WPS PIN DISPLAY\n");
1281 * // Handle WPS PIN Display case here
1284 * if (wps_mode == WIFI_DIRECT_WPS_PIN_KEYPAD) {
1285 * printf("Connection type WPS PIN KEYPAD\n");
1286 * // Handle WPS PIN Keypad case here
1290 * case WIFI_DIRECT_CONNECTION_REQ:
1291 * printf("Connection request from MAC %s\n", mac_address);
1293 * // Handle the connection request from peer device here
1295 * // 2. WPS PIN Display
1296 * // 3. WPS PIN Keypad
1298 * wifi_direct_accept_connection(mac_address);
1301 * case WIFI_DIRECT_DISCONNECTION_IND:
1302 * if (error_code == WIFI_DIRECT_ERROR_NONE)
1303 * printf("peer device disconnected MAC %s\n", mac_address);
1306 * case WIFI_DIRECT_DISCONNECTION_RSP:
1307 * if (error_code == WIFI_DIRECT_ERROR_NONE)
1308 * printf("peer device disconnection response MAC %s\n", mac_address);
1311 * case WIFI_DIRECT_CONNECTION_DISASSOCIATION_IND:
1312 * if (error_code == WIFI_DIRECT_ERROR_NONE)
1313 * printf("peer device disassociation MAC %s\n", mac_address);
1316 * case WIFI_DIRECT_GROUP_CREATED:
1317 * printf("Group Created\n");
1320 * case WIFI_DIRECT_GROUP_DESTROYED:
1321 * printf("Group Destroyed\n");
1329 * void function(void)
1333 * ret = wifi_direct_set_connection_state_changed_cb(callback,
1336 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1337 * printf("Failed to register callback\n");
1341 * printf("callback registered Successfully\n");
1346 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1347 * wifi_direct_activate(); // Activate Wi-Fi Direct
1349 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
1350 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1355 int wifi_direct_set_connection_state_changed_cb(wifi_direct_connection_state_changed_cb cb, void *user_data);
1359 * @brief Unsets the callback called when the state of connection is changed.
1361 * @return @c 0 on success,
1362 * otherwise a negative error value
1363 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1364 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1365 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1366 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1367 * @see wifi_direct_initialize()
1368 * @see wifi_direct_set_connection_state_changed_cb()
1371 * Here is an example of the usage:
1373 * #include <stdio.h>
1374 * #include <wifi_direct.h>
1376 * void function(void)
1380 * ret = wifi_direct_unset_connection_state_changed_cb();
1382 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1383 * printf("Failed to deregister callback\n");
1387 * printf("callback deregistered Successfully\n");
1392 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1394 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1399 int wifi_direct_unset_connection_state_changed_cb(void);
1402 * @brief Sets the callback called when the state of connection is changed.
1404 * @param[in] cb The callback function to invoke
1405 * @param[in] user_data The user data to be passed to the callback function
1406 * @return @c 0 on success,
1407 * otherwise a negative error value
1408 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1409 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
1410 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1411 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1412 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1413 * @see wifi_direct_initialize()
1414 * @see wifi_direct_unset_peer_info_connection_state_changed_cb()
1415 * @see wifi_direct_peer_info_connection_state_changed_cb()
1417 int wifi_direct_set_peer_info_connection_state_changed_cb(wifi_direct_peer_info_connection_state_changed_cb cb, void *user_data);
1420 * @brief Unsets the callback called when the state of connection is changed.
1422 * @return @c 0 on success,
1423 * otherwise a negative error value
1424 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1425 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1426 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1427 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1428 * @see wifi_direct_initialize()
1429 * @see wifi_direct_set_peer_info_connection_state_changed_cb()
1431 int wifi_direct_unset_peer_info_connection_state_changed_cb(void);
1435 * @brief Sets the callback called when the IP address of the client is assigned
1436 * if your device is the group owner.
1438 * @param[in] cb The callback function to invoke
1439 * @param[in] user_data The user data to be passed to the callback function
1440 * @return @c 0 on success,
1441 * otherwise a negative error value
1442 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1443 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
1444 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1445 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1446 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1447 * @see wifi_direct_initialize()
1448 * @see wifi_direct_unset_client_ip_address_assigned_cb()
1449 * @see wifi_direct_client_ip_address_assigned_cb()
1452 * Here is an example of the usage:
1454 * #include <stdio.h>
1455 * #include <wifi_direct.h>
1458 * void callback(const char *mac_address,
1459 * const char *ip_address,
1460 * const char *interface_address,
1463 * printf("IP Assigned to the client device\n");
1465 * printf("mac=%s\n", mac_address);
1466 * printf("ip=%s\n", ip_address);
1467 * printf("iface=%s\n", interface_address);
1470 * void function(void)
1474 * ret = wifi_direct_set_client_ip_address_assigned_cb(callback,
1477 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1478 * printf("Failed to register callback\n");
1482 * printf("callback registered Successfully\n");
1487 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1488 * wifi_direct_activate(); // Activate Wi-Fi Direct
1490 * wifi_direct_deactivate(); // deactivate Wi-Fi Direct
1491 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1496 int wifi_direct_set_client_ip_address_assigned_cb(wifi_direct_client_ip_address_assigned_cb cb, void *user_data);
1500 * @brief Unsets the callback called when the IP address of the client is assigned
1501 * if your device is the group owner.
1503 * @return @c 0 on success,
1504 * otherwise a negative error value
1505 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1506 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1507 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1508 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1509 * @see wifi_direct_initialize()
1510 * @see wifi_direct_set_connection_state_changed_cb()
1513 * Here is an example of the usage:
1515 * #include <stdio.h>
1516 * #include <wifi_direct.h>
1518 * void function(void)
1522 * ret = wifi_direct_unset_client_ip_address_assigned_cb();
1524 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1525 * printf("Failed to deregister callback\n");
1529 * printf("callback deregistered Successfully\n");
1534 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1536 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1541 int wifi_direct_unset_client_ip_address_assigned_cb(void);
1545 * @brief Sets the callback called when the state of the service discovery is changed.
1547 * @param[in] cb The callback function to invoke
1548 * @param[in] user_data The user data to be passed to the callback function
1549 * @return @c 0 on success,
1550 * otherwise a negative error value
1551 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1552 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
1553 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1554 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1555 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1556 * @see wifi_direct_initialize()
1557 * @see wifi_direct_unset_service_state_changed_cb()
1558 * @see wifi_direct_service_state_changed_cb()
1561 * Here is an example of the usage:
1563 * #include <stdio.h>
1564 * #include <wifi_direct.h>
1567 * void callback(int error_code,
1568 * wifi_direct_service_discovery_state_e discovery_state,
1569 * wifi_direct_service_type_e service_type,
1570 * void *response_data,
1571 * const char *mac_address,
1574 * switch (discovery_state) {
1575 * case WIFI_DIRECT_SERVICE_DISCOVERY_STARTED:
1576 * printf("Discovery Started\n");
1579 * case WIFI_DIRECT_SERVICE_DISCOVERY_FINISHED:
1580 * printf("Discovery finished\n");
1583 * case WIFI_DIRECT_SERVICE_DISCOVERY_FOUND:
1584 * printf("Discovery found\n");
1585 * if (mac_address != NULL)
1586 * printf("Peer MAC=%s\n", mac_address);
1588 * if (response_data != NULL)
1589 * printf("Peer response=%s\n", (char *)response_data);
1591 * if (service_type == WIFI_DIRECT_SERVICE_TYPE_ALL)
1592 * printf("service type all\n");
1593 * if (service_type == WIFI_DIRECT_SERVICE_TYPE_BONJOUR)
1594 * printf("service type bonjour\n");
1595 * if (service_type == WIFI_DIRECT_SERVICE_TYPE_UPNP)
1596 * printf("service type UPNP\n");
1597 * if (service_type == WIFI_DIRECT_SERVICE_TYPE_BT_ADDR)
1598 * printf("service type BT_ADDR\n");
1599 * if (service_type == WIFI_DIRECT_SERVICE_TYPE_CONTACT_INFO)\
1600 * printf("service type contact info\n");
1608 * void function(void)
1612 * ret = wifi_direct_set_service_state_changed_cb(callback,
1615 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1616 * printf("Failed to register callback\n");
1620 * printf("callback registered Successfully\n");
1625 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1626 * wifi_direct_activate(); // Activate Wi-Fi Direct
1628 * wifi_direct_deactivate(); // deactivate Wi-Fi Direct
1629 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1634 int wifi_direct_set_service_state_changed_cb(wifi_direct_service_state_changed_cb cb, void *user_data);
1638 * @brief Unsets the callback called when the state of the service discovery is changed.
1640 * @return @c 0 on success,
1641 * otherwise a negative error value
1642 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1643 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1644 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1645 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1646 * @see wifi_direct_initialize()
1647 * @see wifi_direct_set_service_state_changed_cb()
1650 * Here is an example of the usage:
1652 * #include <stdio.h>
1653 * #include <wifi_direct.h>
1655 * void function(void)
1659 * ret = wifi_direct_unset_service_state_changed_cb();
1661 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1662 * printf("Failed to deregister callback\n");
1666 * printf("callback deregistered Successfully\n");
1671 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1673 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1678 int wifi_direct_unset_service_state_changed_cb(void);
1682 * @brief Sets the callback called when the state of Wi-Fi Direct is changed.
1684 * @param[in] cb The callback function to invoke
1685 * @param[in] user_data The user data to be passed to the callback function
1686 * @return @c 0 on success,
1687 * otherwise a negative error value
1688 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1689 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
1690 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation Failed
1691 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1692 * @see wifi_direct_unset_state_changed_cb()
1695 * Here is an example of the usage:
1697 * #include <stdio.h>
1698 * #include <wifi_direct.h>
1701 * char* print_link_state(wifi_direct_state_e state)
1703 * if (state == WIFI_DIRECT_STATE_DEACTIVATED)
1704 * return "DEACTIVATED";
1705 * if (state == WIFI_DIRECT_STATE_ACTIVATING)
1706 * return "ACTIVATING";
1707 * if (state == WIFI_DIRECT_STATE_ACTIVATED)
1708 * return "ACTIVATED";
1709 * if (state == WIFI_DIRECT_STATE_DISCOVERING)
1710 * return "DISCOVERING";
1711 * if (state == WIFI_DIRECT_STATE_CONNECTING)
1712 * return "CONNECTING";
1713 * if (state == WIFI_DIRECT_STATE_DISCONNECTING)
1714 * return "DISCONNECTING";
1715 * if (state == WIFI_DIRECT_STATE_CONNECTED)
1716 * return "CONNECTED";
1717 * if (state == WIFI_DIRECT_STATE_GROUP_OWNER)
1718 * return "GROUP OWNER";
1719 * return "Unknown state";
1722 * void callback(wifi_direct_state_e state,
1725 * printf("State changed [%s]\n", print_link_state(state));
1728 * void function(void)
1732 * ret = wifi_direct_set_state_changed_cb(callback,
1735 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1736 * printf("Failed to register callback\n");
1740 * printf("callback registered Successfully\n");
1745 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1746 * wifi_direct_activate(); // Activate Wi-Fi Direct
1748 * wifi_direct_deactivate(); // deactivate Wi-Fi Direct
1749 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1754 int wifi_direct_set_state_changed_cb(wifi_direct_state_changed_cb cb, void *user_data);
1758 * @brief Unsets the callback called when the state of Wi-Fi Direct is changed.
1760 * @return @c 0 on success,
1761 * otherwise a negative error value
1762 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1763 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation Failed
1764 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1765 * @see wifi_direct_initialize()
1766 * @see wifi_direct_set_state_changed_cb()
1769 * Here is an example of the usage:
1771 * #include <stdio.h>
1772 * #include <wifi_direct.h>
1774 * void function(void)
1778 * ret = wifi_direct_unset_state_changed_cb();
1780 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1781 * printf("Failed to deregister callback\n");
1785 * printf("callback deregistered Successfully\n");
1790 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1792 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1797 int wifi_direct_unset_state_changed_cb(void);
1801 * @brief Activates the Wi-Fi Direct service, asynchronously.
1804 * @privilege http://tizen.org/privilege/wifidirect
1805 * @return @c 0 on success,
1806 * otherwise a negative error value
1807 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1808 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
1809 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
1810 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
1811 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
1812 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1813 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1814 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
1815 * @retval #WIFI_DIRECT_ERROR_WIFI_USED Wi-Fi is being used
1816 * @retval #WIFI_DIRECT_ERROR_MOBILE_AP_USED Mobile AP is being used
1817 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
1818 * @post wifi_direct_device_state_changed_cb() will be invoked.
1819 * @see wifi_direct_initialize()
1820 * @see wifi_direct_deactivate()
1821 * @see wifi_direct_device_state_changed_cb()
1824 * Here is an example of the usage:
1826 * #include <stdio.h>
1827 * #include <wifi_direct.h>
1830 * int function(void)
1834 * ret = wifi_direct_activate(); // Activate Wi-Fi Direct
1836 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1837 * printf("Failed to activate Wi-Fi Direct\n");
1841 * printf("Wi-Fi Direct Activated\n");
1847 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1849 * wifi_direct_deactivate(); // deactivate Wi-Fi Direct
1850 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1855 int wifi_direct_activate(void);
1859 * @brief Deactivates the Wi-Fi Direct service, asynchronously.
1862 * @privilege http://tizen.org/privilege/wifidirect
1863 * @return @c 0 on success,
1864 * otherwise a negative error value
1865 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1866 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
1867 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
1868 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
1869 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
1870 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1871 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1872 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
1873 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
1874 * @post wifi_direct_device_state_changed_cb() will be invoked.
1875 * @see wifi_direct_activate()
1876 * @see wifi_direct_device_state_changed_cb()
1879 * Here is an example of the usage:
1881 * #include <stdio.h>
1882 * #include <wifi_direct.h>
1885 * int function(void)
1889 * ret = wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
1891 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1892 * printf("Failed to deactivate Wi-Fi Direct\n");
1896 * printf("Wi-Fi Direct Deactivated\n");
1902 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
1903 * wifi_direct_activate(); // Activated Wi-Fi Direct
1905 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
1910 int wifi_direct_deactivate(void);
1914 * @brief Starts discovery to find all P2P capable devices, asynchronously.
1915 * @details If application developers call wifi_direct_start_discovery() with @a listen_only as @c true,
1916 * then skip the initial 802.11 Scan and then enter Listen state instead of
1917 * cycling between Scan and Listen.
1920 * @privilege http://tizen.org/privilege/wifidirect
1921 * @remarks The function can be called if the Wi-Fi Direct state is one of:\n
1922 * #WIFI_DIRECT_STATE_ACTIVATED\n
1923 * #WIFI_DIRECT_STATE_DISCOVERING\n
1924 * #WIFI_DIRECT_STATE_GROUP_OWNER\n
1925 * The function can be called even if there is another discovery in progress.
1926 * All started processes will run simultaneously. Each process will receive
1927 * #WIFI_DIRECT_DISCOVERY_FINISHED
1928 * event in wifi_direct_discovery_state_chagned_cb().
1929 * @param[in] listen_only The status of listen only: (@c true = listen only,
1930 * @c false = cycling between Scan and Listen)
1931 * @param[in] timeout Specifies the duration of discovery period, in seconds.
1932 * If @c 0, then there is no limit on how long the discovery takes.
1933 * The actual limit (and time after which discovery stops) depends on
1934 * the vendor's hardware and firmware
1935 * @return @c 0 on success,
1936 * otherwise a negative error value
1937 * @retval #WIFI_DIRECT_ERROR_NONE Successful
1938 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
1939 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
1940 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
1941 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
1942 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
1943 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
1944 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
1945 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
1946 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
1947 * @post wifi_direct_discovery_state_chagned_cb() will be invoked.
1948 * @see wifi_direct_activate()
1949 * @see wifi_direct_cancel_discovery()
1950 * @see wifi_direct_discovery_state_chagned_cb()
1953 * Here is an example of the usage:
1955 * #include <stdio.h>
1956 * #include <wifi_direct.h>
1959 * void callback(int error_code,
1960 * wifi_direct_discovery_state_e discovery_state,
1963 * switch(discovery_state) {
1964 * case WIFI_DIRECT_DISCOVERY_STARTED:
1965 * printf("Discovery started\n");
1968 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
1969 * printf("listen started\n");
1972 * case WIFI_DIRECT_DISCOVERY_FINISHED:
1973 * printf("Discovery finished\n");
1976 * case WIFI_DIRECT_DISCOVERY_FOUND:
1977 * printf("peer devices found\n");
1980 * case WIFI_DIRECT_DISCOVERY_LOST:
1981 * printf("Discovery lost\n");
1989 * int function(void)
1993 * ret = wifi_direct_start_discovery(TRUE, 15); // Start discovery with listen only
1995 * if (ret != WIFI_DIRECT_ERROR_NONE) {
1996 * printf("Failed to start scan\n");
2005 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
2006 * wifi_direct_set_discovery_state_changed_cb(callback,
2007 * NULL); // Register callback
2008 * wifi_direct_activate(); // Activated Wi-Fi Direct
2012 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
2013 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
2014 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
2019 int wifi_direct_start_discovery(bool listen_only, int timeout);
2023 * @brief Starts discovery to find all P2P capable devices with specified channel, asynchronously.
2024 * @details If you call this function with @a channel as @c #WIFI_DIRECT_DISCOVERY_FULL_SCAN
2025 * it works same as wifi_direct_start_discovery() API.
2026 * If application developers call this function with @a channel as @c #WIFI_DIRECT_DISCOVERY_SOCIAL_CHANNEL,
2027 * then will search only the devices on the social channels(channel 1 or 6 or 11).
2028 * If application developers call this function with @a channel as @c #WIFI_DIRECT_DISCOVERY_CHANNEL1,
2029 * then will search only the devices on the channel 1.
2030 * If application developers call this function with @a channel as @c #WIFI_DIRECT_DISCOVERY_CHANNEL6,
2031 * then will search only the devices on the channel 6.
2032 * If application developers call this function with @a channel as @c #WIFI_DIRECT_DISCOVERY_CHANNEL11,
2033 * then will search only the devices on the channel 11.
2036 * @privilege http://tizen.org/privilege/wifidirect
2037 * @remarks The function can be called if the Wi-Fi Direct state is one of:\n
2038 * #WIFI_DIRECT_STATE_ACTIVATED\n
2039 * #WIFI_DIRECT_STATE_DISCOVERING\n
2040 * #WIFI_DIRECT_STATE_GROUP_OWNER\n
2041 * The function can be called even if there is another discovery in progress.
2042 * All started processes will run simultaneously. Each process will receive
2043 * #WIFI_DIRECT_DISCOVERY_FINISHED
2044 * event in wifi_direct_discovery_state_chagned_cb().
2045 * @param[in] listen_only The status of listen only: (@c true = listen only,
2046 * @c false = cycling between Scan and Listen)
2047 * @param[in] timeout Specifies the duration of discovery period, in seconds.
2048 * If @c 0, then there is no limit on how long the discovery takes.
2049 * The actual limit (and time after which discovery stops) depends on
2050 * the vendor's hardware and firmware
2051 * @param[in] channel Specifies the discovery channel. (Full scan, social channels, channel 1, 6, 11)
2052 * @return @c 0 on success,
2053 * otherwise a negative error value
2054 * @retval #WIFI_DIRECT_ERROR_NONE Successful
2055 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
2056 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
2057 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
2058 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
2059 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
2060 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
2061 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
2062 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
2063 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
2064 * @post wifi_direct_discovery_state_chagned_cb() will be invoked.
2065 * @see wifi_direct_activate()
2066 * @see wifi_direct_cancel_discovery()
2067 * @see wifi_direct_discovery_state_chagned_cb()
2070 * Here is an example of the usage:
2072 * #include <stdio.h>
2073 * #include <wifi_direct.h>
2076 * void callback(int error_code,
2077 * wifi_direct_discovery_state_e discovery_state,
2080 * switch(discovery_state) {
2081 * case WIFI_DIRECT_DISCOVERY_STARTED:
2082 * printf("Discovery started\n");
2085 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
2086 * printf("listen started\n");
2089 * case WIFI_DIRECT_DISCOVERY_FINISHED:
2090 * printf("Discovery finished\n");
2093 * case WIFI_DIRECT_DISCOVERY_FOUND:
2094 * printf("peer devices found\n");
2097 * case WIFI_DIRECT_DISCOVERY_LOST:
2098 * printf("Discovery lost\n");
2106 * int function(void)
2110 * ret = wifi_direct_start_discovery_specific_channel(TRUE, 15, // start discovery with 15sec timeout
2111 * WIFI_DIRECT_DISCOVERY_FULL_SCAN); // scan all channels
2113 * if (ret != WIFI_DIRECT_ERROR_NONE) {
2114 * printf("Failed to start scan\n");
2123 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
2124 * wifi_direct_set_discovery_state_changed_cb(callback,
2125 * NULL); // Register callback
2126 * wifi_direct_activate(); // Activated Wi-Fi Direct
2130 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
2131 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
2132 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
2137 int wifi_direct_start_discovery_specific_channel(bool listen_only, int timeout, wifi_direct_discovery_channel_e channel);
2141 * @brief Starts discovery to find all P2P capable devices with specified frequency, asynchronously.
2144 * @privilege http://tizen.org/privilege/wifidirect
2145 * @remarks The function can be called if the Wi-Fi Direct state is one of:\n
2146 * #WIFI_DIRECT_STATE_ACTIVATED\n
2147 * #WIFI_DIRECT_STATE_DISCOVERING\n
2148 * #WIFI_DIRECT_STATE_GROUP_OWNER\n
2149 * The function can be called even if there is another discovery in progress.
2150 * All started processes will run simultaneously. Each process will receive
2151 * #WIFI_DIRECT_DISCOVERY_FINISHED
2152 * event in wifi_direct_discovery_state_chagned_cb().
2153 * @param[in] listen_only Indicates mode in which the discovery service will work.
2154 * If @c true, the service will only listen, otherwise
2155 * it will cycle between scanning and listening
2156 * @param[in] timeout Specifies the duration of discovery period, in seconds.
2157 * If @c 0, then there is no limit on how long the discovery takes.
2158 * The actual limit (and time after which discovery stops) depends on
2159 * the vendor's hardware and firmware
2160 * @param[in] frequency Specifies the discovery frequency in MHz
2161 * @return @c 0 on success,
2162 * otherwise a negative error value
2163 * @retval #WIFI_DIRECT_ERROR_NONE Successful
2164 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
2165 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
2166 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
2167 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
2168 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
2169 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
2170 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
2171 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
2172 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
2173 * @post wifi_direct_discovery_state_chagned_cb() will be invoked.
2174 * @see wifi_direct_activate()
2175 * @see wifi_direct_cancel_discovery()
2176 * @see wifi_direct_discovery_state_chagned_cb()
2177 * @see wifi_direct_discovered_peer_cb()
2180 * Here is an example of the usage:
2182 * #include <stdio.h>
2183 * #include <wifi_direct.h>
2186 * void callback(int error_code,
2187 * wifi_direct_discovery_state_e discovery_state,
2190 * switch(discovery_state) {
2191 * case WIFI_DIRECT_DISCOVERY_STARTED:
2192 * printf("Discovery started\n");
2195 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
2196 * printf("listen started\n");
2199 * case WIFI_DIRECT_DISCOVERY_FINISHED:
2200 * printf("Discovery finished\n");
2203 * case WIFI_DIRECT_DISCOVERY_FOUND:
2204 * printf("peer devices found\n");
2207 * case WIFI_DIRECT_DISCOVERY_LOST:
2208 * printf("Discovery lost\n");
2216 * int function(void)
2220 * ret = wifi_direct_start_discovery_specific_freq(TRUE, 15, // start discovery with 15sec timeout
2221 * 2437); // scan for 2437 MHz frequency (Channel 6)
2223 * if (ret != WIFI_DIRECT_ERROR_NONE) {
2224 * printf("Failed to start scan\n");
2233 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
2234 * wifi_direct_set_discovery_state_changed_cb(callback,
2235 * NULL); // Register callback
2236 * wifi_direct_activate(); // Activated Wi-Fi Direct
2240 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
2241 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
2242 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
2247 int wifi_direct_start_discovery_specific_freq(bool listen_only, int timeout, int frequency);
2251 * @brief Cancels discovery process, asynchronously.
2252 * @details This function stops all discovery processes started with
2253 * wifi_direct_start_discovery() functions.
2256 * @privilege http://tizen.org/privilege/wifidirect
2257 * @return @c 0 on success,
2258 * otherwise a negative error value
2259 * @retval #WIFI_DIRECT_ERROR_NONE Successful
2260 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
2261 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
2262 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
2263 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
2264 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
2265 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
2266 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
2267 * @pre Discovery must be started by wifi_direct_start_discovery().
2268 * @post wifi_direct_discovery_state_chagned_cb() will be invoked.
2269 * @see wifi_direct_start_discovery()
2270 * @see wifi_direct_start_discovery_specific_channel()
2271 * @see wifi_direct_start_discovery_specific_freq()
2272 * @see wifi_direct_discovery_state_chagned_cb()
2275 * Here is an example of the usage:
2277 * #include <stdio.h>
2278 * #include <wifi_direct.h>
2281 * void callback(int error_code,
2282 * wifi_direct_discovery_state_e discovery_state,
2285 * switch(discovery_state) {
2286 * case WIFI_DIRECT_DISCOVERY_STARTED:
2287 * printf("Discovery started\n");
2290 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
2291 * printf("listen started\n");
2294 * case WIFI_DIRECT_DISCOVERY_FINISHED:
2295 * printf("Discovery finished\n");
2298 * case WIFI_DIRECT_DISCOVERY_FOUND:
2299 * printf("peer devices found\n");
2302 * case WIFI_DIRECT_DISCOVERY_LOST:
2303 * printf("Discovery lost\n");
2311 * int function(void)
2315 * ret = wifi_direct_cancel_discovery(); // Cancel ongoing discovery
2317 * if (ret != WIFI_DIRECT_ERROR_NONE) {
2318 * printf("Failed to cancel discovery\n");
2327 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
2328 * wifi_direct_set_discovery_state_changed_cb(callback, NULL); // Register callback
2329 * wifi_direct_activate(); // Activate Wi-Fi Direct
2330 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
2334 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
2335 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
2336 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
2341 int wifi_direct_cancel_discovery(void);
2345 * @brief Called repeatedly when you get the information of discovered peers.
2347 * @remarks @a peer is valid only in this function.
2348 * @param[in] peer The information of the discovered peer
2349 * @param[in] user_data The user data passed from foreach function
2350 * @return @c true to continue with the next iteration of the loop,
2351 * @c false to break out of the loop
2352 * @see wifi_direct_foreach_discovered_peers()
2354 typedef bool (*wifi_direct_discovered_peer_cb) (wifi_direct_discovered_peer_info_s *peer, void *user_data);
2358 * @brief Gets the information of discovered peers.
2361 * @privilege http://tizen.org/privilege/wifidirect
2362 * @param[in] callback The callback function to invoke
2363 * @param[in] user_data The user data to be passed to the callback function
2364 * @return @c 0 on success,
2365 * otherwise a negative error value
2366 * @retval #WIFI_DIRECT_ERROR_NONE Successful
2367 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
2368 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
2369 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
2370 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
2371 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
2372 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
2373 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
2374 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
2375 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
2376 * @see wifi_direct_activate()
2377 * @see wifi_direct_discovered_peer_cb()
2380 * Here is an example of the usage:
2382 * #include <stdio.h>
2383 * #include <wifi_direct.h>
2386 * void function_cb(wifi_direct_discovered_peer_info_s* peer,
2390 * printf("peer device=%s MAC=%s\n", peer->device_name, peer->mac_address);
2393 * int function(void)
2397 * ret = wifi_direct_foreach_discovered_peers(function_cb, NULL); // get discovered peer devices info
2399 * if (ret != WIFI_DIRECT_ERROR_NONE) {
2400 * printf("Failed to get discovered peers\n");
2407 * void callback(int error_code,
2408 * wifi_direct_discovery_state_e discovery_state,
2411 * switch(discovery_state) {
2412 * case WIFI_DIRECT_DISCOVERY_STARTED:
2413 * printf("Discovery started\n");
2416 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
2417 * printf("listen started\n");
2420 * case WIFI_DIRECT_DISCOVERY_FINISHED:
2421 * printf("Discovery finished\n");
2427 * case WIFI_DIRECT_DISCOVERY_FOUND:
2428 * printf("peer devices found\n");
2431 * case WIFI_DIRECT_DISCOVERY_LOST:
2432 * printf("Discovery lost\n");
2442 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
2443 * wifi_direct_set_discovery_state_changed_cb(callback, NULL); // Register callback
2444 * wifi_direct_activate(); // Activate Wi-Fi Direct
2445 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
2449 * // App must clean up Wi-Fi Direct before exiting
2451 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
2452 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
2453 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
2458 int wifi_direct_foreach_discovered_peers(wifi_direct_discovered_peer_cb callback, void *user_data);
2462 * @brief Connects to a specified peer, asynchronously.
2463 * @details This function connects to specified peer by automatically determining
2464 * whether to perform group formation, join an existing group, invite, re-invoke a group.
2465 * The decision is based on the current state of the peers (i.e. GO, STA, not connected)
2466 * and the availability of persistent data.
2469 * @privilege http://tizen.org/privilege/wifidirect
2470 * @param[in] mac_address The MAC address of remote device
2471 * @return @c 0 on success,
2472 * otherwise a negative error value
2473 * @retval #WIFI_DIRECT_ERROR_NONE Successful
2474 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
2475 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
2476 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
2477 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
2478 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
2479 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
2480 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
2481 * @retval #WIFI_DIRECT_ERROR_TOO_MANY_CLIENT Too many client
2482 * @retval #WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT Connection timed out
2483 * @retval #WIFI_DIRECT_ERROR_CONNECTION_FAILED Connection failed
2484 * @retval #WIFI_DIRECT_ERROR_AUTH_FAILED Authentication failed
2485 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
2486 * @post wifi_direct_connection_state_changed_cb() will be invoked.
2487 * @see wifi_direct_activate()
2488 * @see wifi_direct_disconnect()
2489 * @see wifi_direct_disconnect_all()
2490 * @see wifi_direct_connection_state_changed_cb()
2493 * Here is an example of the usage:
2495 * #include <stdio.h>
2496 * #include <wifi_direct.h>
2499 * bool device_selected = false;
2501 * void peers_cb(wifi_direct_discovered_peer_info_s* peer,
2504 * if (peer && !device_selected) {
2505 * printf("peer device=%s MAC=%s\n", peer->device_name, peer->mac_address);
2507 * device_selected = true;
2509 * function(peer->mac_address); // Connect to the first discovered peer
2513 * int function(const char *mac)
2517 * ret = wifi_direct_connect(mac); // connect to the peer device
2519 * if (ret != WIFI_DIRECT_ERROR_NONE) {
2520 * printf("Failed to connect the peer\n");
2527 * void callback_2(int error_code,
2528 * wifi_direct_connection_state_e state,
2529 * const char *mac, void *user_data)
2532 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
2533 * printf("Connection in progress\n");
2536 * case WIFI_DIRECT_CONNECTON_RSP:
2537 * printf("Connected\n");
2540 * case WIFI_DIRECT_DISCONNECTION_IND:
2541 * printf("Disconnection IND\n");
2544 * case WIFI_DIRECT_DISCONNECTION_RSP;
2545 * printf("Disconnected\n");
2550 * void callback_1(int error_code,
2551 * wifi_direct_discovery_state_e discovery_state,
2554 * switch(discovery_state) {
2555 * case WIFI_DIRECT_DISCOVERY_STARTED:
2556 * printf("Discovery started\n");
2559 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
2560 * printf("listen started\n");
2563 * case WIFI_DIRECT_DISCOVERY_FINISHED:
2564 * printf("Discovery finished\n");
2566 * wifi_direct_foreach_discovered_peers(peers_cb,
2567 * NULL); // Get discovered peer
2570 * case WIFI_DIRECT_DISCOVERY_FOUND:
2571 * printf("peer devices found\n");
2574 * case WIFI_DIRECT_DISCOVERY_LOST:
2575 * printf("Discovery lost\n");
2585 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
2586 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
2587 * wifi_direct_set_connection_state_changed_cb(callback_2, NULL); // Register callback 2
2589 * wifi_direct_activate(); // Activate Wi-Fi Direct
2590 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
2594 * // App must clean up Wi-Fi Direct before exiting
2596 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
2597 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
2598 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
2603 int wifi_direct_connect(char *mac_address);
2607 * @brief Cancels the connection now in progress.
2610 * @privilege http://tizen.org/privilege/wifidirect
2611 * @param[in] mac_address The MAC address of rejected device
2612 * @return @c 0 on success,
2613 * otherwise a negative error value
2614 * @retval #WIFI_DIRECT_ERROR_NONE Successful
2615 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
2616 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
2617 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
2618 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
2619 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
2620 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
2621 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
2622 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
2625 * Here is an example of the usage:
2627 * #include <stdio.h>
2628 * #include <wifi_direct.h>
2630 * bool peer_selected = false;
2631 * int connection_timeout = 0;
2632 * int count = 0; // counter to wait for connection
2634 * int function(char *mac);
2636 * gboolean connection_timeout_cb(gpointer data)
2638 * char *mac = (char *)data;
2645 * function(mac); // cancel ongoing connection
2650 * void peers_cb(wifi_direct_discovered_peer_info_s* peer,
2655 * if (peer && !peer_selected) {
2656 * printf("peer device=%s MAC=%s\n", peer->device_name, peer->mac_address);
2658 * mac = g_strdup(peer->mac_address);
2659 * peer_selected = true;
2661 * wifi_direct_connect(mac); // Connect to the selected peer
2662 * connection_timeout = g_timeout_add(1000,
2663 * connection_timeout_cb,
2664 * mac); // Add 3secs timeout
2668 * int function(char *mac)
2672 * ret = wifi_direct_cancel_connection(mac); // cancel connection
2674 * if (ret != WIFI_DIRECT_ERROR_NONE) {
2675 * printf("Failed to cancel the ongoing connection\n");
2682 * void callback_2(int error_code,
2683 * wifi_direct_connection_state_e state,
2684 * const char *mac, void *user_data)
2687 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
2688 * printf("Connection in progress\n");
2691 * case WIFI_DIRECT_CONNECTON_RSP:
2692 * printf("Connected\n");
2693 * g_source_remove(connection_timeout);
2696 * case WIFI_DIRECT_DISCONNECTION_IND:
2697 * printf("Disconnection IND\n");
2700 * case WIFI_DIRECT_DISCONNECTION_RSP;
2701 * printf("Disconnected\n");
2706 * void callback_1(int error_code,
2707 * wifi_direct_discovery_state_e discovery_state,
2710 * switch(discovery_state) {
2711 * case WIFI_DIRECT_DISCOVERY_STARTED:
2712 * printf("Discovery started\n");
2715 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
2716 * printf("listen started\n");
2719 * case WIFI_DIRECT_DISCOVERY_FINISHED:
2720 * printf("Discovery finished\n");
2722 * wifi_direct_foreach_discovered_peers(peers_cb,
2723 * NULL); // Get discovered peer
2726 * case WIFI_DIRECT_DISCOVERY_FOUND:
2727 * printf("peer devices found\n");
2730 * case WIFI_DIRECT_DISCOVERY_LOST:
2731 * printf("Discovery lost\n");
2741 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
2742 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
2743 * wifi_direct_set_connection_state_changed_cb(callback_2, NULL); // Register callback 2
2745 * wifi_direct_activate(); // Activate Wi-Fi Direct
2746 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
2748 * // App must clean up Wi-Fi Direct before exiting
2750 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
2751 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback 2
2752 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback 1
2753 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
2758 int wifi_direct_cancel_connection(char *mac_address);
2762 * @brief Disconnects all connected links to peers, asynchronously.
2765 * @privilege http://tizen.org/privilege/wifidirect
2766 * @return @c 0 on success,
2767 * otherwise a negative error value
2768 * @retval #WIFI_DIRECT_ERROR_NONE Successful
2769 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
2770 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
2771 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
2772 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
2773 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
2774 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
2775 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
2776 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
2777 * @post wifi_direct_connection_state_changed_cb() will be invoked.
2778 * @see wifi_direct_activate()
2779 * @see wifi_direct_disconnect()
2780 * @see wifi_direct_connection_state_changed_cb()
2783 * Here is an example of the usage:
2785 * #include <stdio.h>
2786 * #include <wifi_direct.h>
2788 * void callback(int error_code,
2789 * wifi_direct_connection_state_e state,
2790 * const char *mac, void *user_data)
2793 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
2794 * printf("Connection in progress\n");
2797 * case WIFI_DIRECT_CONNECTON_RSP:
2798 * printf("Connected\n");
2801 * case WIFI_DIRECT_DISCONNECTION_IND:
2802 * printf("Disconnection IND\n");
2805 * case WIFI_DIRECT_DISCONNECTION_RSP;
2806 * printf("Disconnected\n"); // disconnect notification
2811 * int function(void)
2815 * res = wifi_direct_disconnect_all(); // disconnect all the connected peers
2817 * if (res != WIFI_DIRECT_ERROR_NONE) {
2818 * printf("Failed to disconnect all clients\n");
2827 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
2828 * wifi_direct_set_connection_state_changed_cb(callback, NULL); // Register callback
2829 * wifi_direct_activate(); // Activate Wi-Fi Direct *
2835 * // App must clean up Wi-Fi Direct before exiting
2837 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
2838 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback
2839 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
2844 int wifi_direct_disconnect_all(void);
2848 * @brief Disconnects the specified peer, asynchronously.
2851 * @privilege http://tizen.org/privilege/wifidirect
2852 * @param[in] mac_address The MAC address of remote device
2853 * @return @c 0 on success,
2854 * otherwise a negative error value
2855 * @retval #WIFI_DIRECT_ERROR_NONE Successful
2856 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
2857 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
2858 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
2859 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
2860 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
2861 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
2862 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
2863 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
2864 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
2865 * @post wifi_direct_connection_state_changed_cb() will be invoked.
2866 * @see wifi_direct_activate()
2867 * @see wifi_direct_disconnect()
2868 * @see wifi_direct_connection_state_changed_cb()
2871 * Here is an example of the usage:
2873 * #include <stdio.h>
2874 * #include <wifi_direct.h>
2876 * bool callback_2(wifi_direct_connected_peer_info_s* peer,
2880 * printf("connected device=%s mac=%s\n",
2881 * peer->device_name, peer->mac_address);
2885 * void callback_1(int error_code,
2886 * wifi_direct_connection_state_e state,
2887 * const char *mac, void *user_data)
2890 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
2891 * printf("Connection in progress\n");
2894 * case WIFI_DIRECT_CONNECTON_RSP:
2895 * printf("Connected\n");
2898 * case WIFI_DIRECT_DISCONNECTION_IND:
2899 * printf("Disconnection IND\n");
2902 * case WIFI_DIRECT_DISCONNECTION_RSP;
2903 * printf("Disconnected mac=%s\n", mac_address); // disconnect notification
2908 * int function(char *mac)
2912 * res = wifi_direct_disconnect(mac); // disconnect the connected peer with input mac
2914 * if (res != WIFI_DIRECT_ERROR_NONE) {
2915 * printf("Failed to disconnect all clients\n");
2924 * char mac[16] = {0,};
2926 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
2927 * wifi_direct_set_connection_state_changed_cb(callback_1, NULL); // Register callback_1
2928 * wifi_direct_activate(); // Activate Wi-Fi Direct *
2930 * wifi_direct_foreach_connected_peers(callback_2, NULL); // Register callback_2
2932 * printf("Enter the connected peer mac address\n");
2933 * read(stdin, mac, 15);
2939 * // App must clean up Wi-Fi Direct before exiting
2941 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
2942 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback
2943 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
2948 int wifi_direct_disconnect(char *mac_address);
2952 * @brief Called repeatedly when you get the information of connected peers.
2954 * @remarks @a peer is valid only in this function.
2955 * @param[in] peer The information of discovered peer
2956 * @param[in] user_data The user data passed from foreach function
2957 * @return @c true to continue with the next iteration of the loop,
2958 * @c false to break out of the loop
2959 * @see wifi_direct_foreach_connected_peers()
2961 typedef bool (*wifi_direct_connected_peer_cb) (wifi_direct_connected_peer_info_s *peer, void *user_data);
2965 * @brief Gets the information of connected peers.
2968 * @privilege http://tizen.org/privilege/wifidirect
2969 * @param[in] callback The callback function to invoke
2970 * @param[in] user_data The user data to be passed to the callback function
2971 * @return @c 0 on success,
2972 * otherwise a negative error value
2973 * @retval #WIFI_DIRECT_ERROR_NONE Successful
2974 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
2975 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
2976 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
2977 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
2978 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
2979 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
2980 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
2981 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
2982 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
2983 * @see wifi_direct_activate()
2984 * @see wifi_direct_discovered_peer_cb()
2987 * Here is an example of the usage:
2989 * #include <stdio.h>
2990 * #include <wifi_direct.h>
2992 * bool callback_1(wifi_direct_connected_peer_info_s* peer,
2996 * printf("connected device=%s mac=%s\n",
2997 * peer->device_name, peer->mac_address);
3001 * int function(char *mac)
3005 * res = wifi_direct_foreach_connected_peers(callback_1, NULL) // Get connected peers
3007 * if (res != WIFI_DIRECT_ERROR_NONE) {
3008 * printf("Failed to get connected peers\n");
3017 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3018 * wifi_direct_activate(); // Activate Wi-Fi Direct
3024 * // App must clean up Wi-Fi Direct before exiting
3026 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3027 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3032 int wifi_direct_foreach_connected_peers(wifi_direct_connected_peer_cb callback, void *user_data);
3036 * @brief Creates a Wi-Fi Direct Group, asynchronously.
3037 * @details This function sets up device as the Group Owner and waits for clients to connect.
3038 * In addition, a soft AP will be created, the WPS registrar and the DHCP server will be started.
3041 * @privilege http://tizen.org/privilege/wifidirect
3042 * @return @c 0 on success,
3043 * otherwise a negative error value
3044 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3045 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3046 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3047 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3048 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3049 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3050 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3051 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3052 * @retval #WIFI_DIRECT_ERROR_AUTH_FAILED Authentication failed
3053 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
3054 * @post wifi_direct_connection_state_changed_cb() will be invoked with #WIFI_DIRECT_GROUP_CREATED.
3055 * @see wifi_direct_activate()
3056 * @see wifi_direct_destroy_group()
3057 * @see wifi_direct_connection_state_changed_cb()
3060 * Here is an example of the usage:
3062 * #include <stdio.h>
3063 * #include <wifi_direct.h>
3065 * void callback_1(int error_code,
3066 * wifi_direct_connection_state_e state,
3067 * const char *mac, void *user_data)
3069 * if (state == WIFI_DIRECT_GROUP_CREATED) {
3070 * printf("Group created\n");
3074 * int function(void)
3078 * res = wifi_direct_create_group() // create autonomous group
3080 * if (res != WIFI_DIRECT_ERROR_NONE) {
3081 * printf("Failed to create group\n");
3090 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3091 * wifi_direct_set_connection_state_changed_cb(callback_1, NULL); // Register callback_1
3092 * wifi_direct_activate(); // Activate Wi-Fi Direct
3098 * // App must clean up Wi-Fi Direct before exiting
3100 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3101 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback_1
3102 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3107 int wifi_direct_create_group(void);
3110 * @brief Creates a Wi-Fi Direct Group, asynchronously with given SSID name.
3111 * @details This function sets up device as the Group Owner and waits for clients to connect.
3112 * In addition, a soft AP will be created, the WPS registrar and the DHCP server will be started.
3115 * @privilege http://tizen.org/privilege/wifidirect
3116 * @param[in] ssid Referred to as a network name, it is a name that identifies a wireless network
3117 * @return 0 on success, otherwise a negative error value
3118 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3119 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3120 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3121 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3122 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameters
3123 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3124 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3125 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3126 * @retval #WIFI_DIRECT_ERROR_AUTH_FAILED Authentication failed
3127 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
3128 * @post wifi_direct_connection_state_changed_cb() will be invoked with #WIFI_DIRECT_GROUP_CREATED.
3129 * @see wifi_direct_activate()
3130 * @see wifi_direct_destroy_group()
3131 * @see wifi_direct_connection_state_changed_cb()
3133 int wifi_direct_create_group_with_ssid(const char *ssid);
3136 * @brief Destroys the Wi-Fi Direct Group, asynchronously.
3137 * @details This function destroys the Wi-Fi Direct Group owned by a local device.
3138 * If creating a Group is in progress, this function cancels that creating.
3141 * @privilege http://tizen.org/privilege/wifidirect
3142 * @return @c 0 on success,
3143 * otherwise a negative error value
3144 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3145 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3146 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3147 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3148 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3149 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3150 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3151 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3152 * @retval #WIFI_DIRECT_ERROR_AUTH_FAILED Authentication failed
3153 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
3154 * @post wifi_direct_connection_state_changed_cb() will be invoked with #WIFI_DIRECT_GROUP_DESTROYED.
3155 * @see wifi_direct_activate()
3156 * @see wifi_direct_create_group()
3157 * @see wifi_direct_connection_state_changed_cb()
3160 * Here is an example of the usage:
3162 * #include <stdio.h>
3163 * #include <wifi_direct.h>
3165 * void callback_1(int error_code,
3166 * wifi_direct_connection_state_e state,
3167 * const char *mac, void *user_data)
3169 * if (state == WIFI_DIRECT_GROUP_DESTROYED) {
3170 * printf("Group destroyed\n");
3174 * int function(void)
3178 * res = wifi_direct_destroy_group() // destroy autonomous group
3180 * if (res != WIFI_DIRECT_ERROR_NONE) {
3181 * printf("Failed to destroy group\n");
3190 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3191 * wifi_direct_set_connection_state_changed_cb(callback_1, NULL); // Register callback_1
3192 * wifi_direct_activate(); // Activate Wi-Fi Direct
3198 * // App must clean up Wi-Fi Direct before exiting
3200 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3201 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback_1
3202 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3207 int wifi_direct_destroy_group(void);
3211 * @brief Checks whether this device is the group owner or not.
3214 * @privilege http://tizen.org/privilege/wifidirect
3215 * @param[out] is_group_owner Indicates whether this device is the group owner or not
3216 * @return @c 0 on success,
3217 * otherwise a negative error value
3218 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3219 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
3220 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3221 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3222 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3223 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3224 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3225 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3226 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3227 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
3228 * @see wifi_direct_activate()
3231 * Here is an example of the usage:
3233 * #include <stdio.h>
3234 * #include <wifi_direct.h>
3236 * int function(void)
3241 * res = wifi_direct_is_group_owner(&owner); // destroy autonomous group
3243 * if (res != WIFI_DIRECT_ERROR_NONE) {
3244 * printf("Failed to get ownership role\n");
3248 * printf("role = %s\n", (owner)?"GO":"STA");
3252 * void callback_1(int error_code,
3253 * wifi_direct_connection_state_e state,
3254 * const char *mac, void *user_data)
3256 * if (state == WIFI_DIRECT_GROUP_DESTROYED) {
3257 * printf("Group destroyed\n");
3262 * if (state == WIFI_DIRECT_GROUP_CREATED) {
3263 * printf("Group created\n");
3271 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3272 * wifi_direct_set_connection_state_changed_cb(callback_1, NULL); // Register callback_1
3273 * wifi_direct_activate(); // Activate Wi-Fi Direct
3275 * wifi_direct_create_group();
3277 * wifi_direct_destroy_group();
3281 * // App must clean up Wi-Fi Direct before exiting
3283 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3284 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback_1
3285 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3290 int wifi_direct_is_group_owner(bool *is_group_owner);
3294 * @brief Checks whether the current group is the autonomous group or not.
3295 * @details If you create a group by wifi_direct_create_group(),
3296 * then the current group is the autonomous group.
3299 * @privilege http://tizen.org/privilege/wifidirect
3300 * @param[out] is_autonomous_group Indicates whether the current group is the autonomous group or not
3301 * @return @c 0 on success,
3302 * otherwise a negative error value
3303 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3304 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
3305 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3306 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3307 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3308 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3309 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3310 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3311 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3312 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
3313 * @see wifi_direct_activate()
3314 * @see wifi_direct_create_group()
3315 * @see wifi_direct_destroy_group()
3318 * Here is an example of the usage:
3320 * #include <stdio.h>
3321 * #include <wifi_direct.h>
3323 * int function(void)
3328 * res = wifi_direct_is_autonomous_group(&owner); // autonomous group
3330 * if (res != WIFI_DIRECT_ERROR_NONE) {
3331 * printf("Failed to get ownership role\n");
3335 * printf("Group = %s\n", (owner)?"Auto":"Non-Auto");
3339 * void callback_1(int error_code,
3340 * wifi_direct_connection_state_e state,
3341 * const char *mac, void *user_data)
3343 * if (state == WIFI_DIRECT_GROUP_DESTROYED) {
3344 * printf("Group destroyed\n");
3347 * if (state == WIFI_DIRECT_GROUP_CREATED) {
3348 * printf("Group created\n");
3356 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3357 * wifi_direct_set_connection_state_changed_cb(callback_1, NULL); // Register callback_1
3358 * wifi_direct_activate(); // Activate Wi-Fi Direct
3360 * wifi_direct_create_group();
3364 * // App must clean up Wi-Fi Direct before exiting
3366 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3367 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback_1
3368 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3373 int wifi_direct_is_autonomous_group(bool *is_autonomous_group);
3377 * @brief Sets the friendly name of a local device.
3378 * @details This device name is shown to other devices during device discovery.
3381 * @privilege http://tizen.org/privilege/wifidirect
3382 * @remarks The name set is only valid during activated state.
3383 * After Wi-Fi Direct is deactivated, this name will be same as the phone name.
3384 * @param[in] device_name The name of a local device
3385 * @return @c 0 on success,
3386 * otherwise a negative error value
3387 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3388 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
3389 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3390 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3391 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3392 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3393 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3394 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3395 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3396 * @pre Wi-Fi Direct must be activated by wifi_direct_activate().
3397 * @see wifi_direct_activate()
3398 * @see wifi_direct_get_device_name()
3401 * Here is an example of the usage:
3403 * #include <stdio.h>
3404 * #include <wifi_direct.h>
3406 * int function(char *name)
3410 * res = wifi_direct_set_device_name(&name); // set device name
3412 * if (res != WIFI_DIRECT_ERROR_NONE) {
3413 * printf("Failed to set device name\n");
3422 * char name[256] = {0, };
3423 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3424 * wifi_direct_activate(); // Activate Wi-Fi Direct
3426 * printf("Enter the device name\n");
3427 * read(stdin, name, 255);
3433 * // App must clean up Wi-Fi Direct before exiting
3435 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3436 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3441 int wifi_direct_set_device_name(const char *device_name);
3445 * @brief Gets the name of a local device.
3448 * @privilege http://tizen.org/privilege/wifidirect
3449 * @remarks @a device_name must be released with free().
3450 * @param[out] device_name The name of a local device
3451 * @return @c 0 on success,
3452 * otherwise a negative error value
3453 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3454 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
3455 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3456 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3457 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3458 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3459 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3460 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3461 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
3462 * @see wifi_direct_initialize()
3463 * @see wifi_direct_set_device_name()
3466 * Here is an example of the usage:
3468 * #include <stdio.h>
3469 * #include <wifi_direct.h>
3471 * int function(void)
3476 * res = wifi_direct_get_device_name(&name); // get device name
3478 * if (res != WIFI_DIRECT_ERROR_NONE) {
3479 * printf("Failed to get device name\n");
3483 * printf("device name = %s\n", name);
3490 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3491 * wifi_direct_activate(); // Activate Wi-Fi Direct
3497 * // App must clean up Wi-Fi Direct before exiting
3499 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3500 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3505 int wifi_direct_get_device_name(char** device_name);
3509 * @brief Gets SSID (Service Set Identifier) of a local device.
3512 * @privilege http://tizen.org/privilege/wifidirect
3513 * @remarks @a ssid must be released using free().
3514 * @param[out] ssid The SSID
3515 * @return @c 0 on success,
3516 * otherwise a negative error value
3517 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3518 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
3519 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3520 * @retval #WIFI_DIRECT_ERROR_OUT_OF_MEMORY Out of memory
3521 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3522 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3523 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3524 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3525 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3526 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3527 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
3528 * @see wifi_direct_initialize()
3531 * Here is an example of the usage:
3533 * #include <stdio.h>
3534 * #include <wifi_direct.h>
3536 * int function(void)
3541 * res = wifi_direct_get_ssid(&ssid); // get SSID
3543 * if (res != WIFI_DIRECT_ERROR_NONE) {
3544 * printf("Failed to get ssid name\n");
3548 * printf("SSID name = %s\n", ssid);
3555 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3556 * wifi_direct_activate(); // Activate Wi-Fi Direct
3562 * // App must clean up Wi-Fi Direct before exiting
3564 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3565 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3570 int wifi_direct_get_ssid(char **ssid);
3574 * @brief Gets the name of network interface (for example: eth0, pdp0).
3577 * @privilege http://tizen.org/privilege/wifidirect
3578 * @remarks @a name must be released using free().
3579 * @param[out] name The name of the network interface
3580 * @return @c 0 on success,
3581 * otherwise negative error value
3582 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3583 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
3584 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3585 * @retval #WIFI_DIRECT_ERROR_OUT_OF_MEMORY Out of memory
3586 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3587 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3588 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3589 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3590 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3591 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3592 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
3593 * @see wifi_direct_activate()
3596 * Here is an example of the usage:
3598 * #include <stdio.h>
3599 * #include <wifi_direct.h>
3601 * int function(void)
3606 * res = wifi_direct_get_network_interface_name(&iface_name); // get interface name
3608 * if (res != WIFI_DIRECT_ERROR_NONE) {
3609 * printf("Failed to get interface name\n");
3613 * printf("interface = %s\n", iface_name);
3614 * g_free(iface_name);
3620 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3621 * wifi_direct_activate(); // Activate Wi-Fi Direct
3627 * // App must clean up Wi-Fi Direct before exiting
3629 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3630 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3635 int wifi_direct_get_network_interface_name(char **name);
3639 * @brief Gets IP address of a local device.
3642 * @privilege http://tizen.org/privilege/wifidirect
3643 * @remarks @a ip_address must be released using free().
3644 * @param[out] ip_address The IP address
3645 * @return @c 0 on success,
3646 * otherwise a negative error value
3647 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3648 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
3649 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3650 * @retval #WIFI_DIRECT_ERROR_OUT_OF_MEMORY Out of memory
3651 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3652 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3653 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3654 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3655 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3656 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3657 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
3658 * @see wifi_direct_activate()
3662 * Here is an example of the usage:
3664 * #include <stdio.h>
3665 * #include <wifi_direct.h>
3667 * int function(void);
3669 * bool device_selected = false;
3671 * void peers_cb(wifi_direct_discovered_peer_info_s* peer,
3674 * if (peer && !device_selected) {
3675 * printf("peer device=%s MAC=%s\n", peer->device_name, peer->mac_address);
3677 * device_selected = true;
3679 * wifi_direct_connect(peer->mac_address); // Connect to the first discovered peer
3683 * int function(void)
3688 * ret = wifi_direct_get_ip_address(&ip); // get ip address
3690 * if (ret != WIFI_DIRECT_ERROR_NONE) {
3691 * printf("Failed to connect the peer\n");
3695 * printf("IP address=%s\n", ip);
3700 * void callback_2(int error_code,
3701 * wifi_direct_connection_state_e state,
3702 * const char *mac, void *user_data)
3705 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
3706 * printf("Connection in progress\n");
3709 * case WIFI_DIRECT_CONNECTON_RSP:
3710 * printf("Connected\n");
3715 * case WIFI_DIRECT_DISCONNECTION_IND:
3716 * printf("Disconnection IND\n");
3719 * case WIFI_DIRECT_DISCONNECTION_RSP;
3720 * printf("Disconnected\n");
3725 * void callback_1(int error_code,
3726 * wifi_direct_discovery_state_e discovery_state,
3729 * switch(discovery_state) {
3730 * case WIFI_DIRECT_DISCOVERY_STARTED:
3731 * printf("Discovery started\n");
3734 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
3735 * printf("listen started\n");
3738 * case WIFI_DIRECT_DISCOVERY_FINISHED:
3739 * printf("Discovery finished\n");
3741 * wifi_direct_foreach_discovered_peers(peers_cb,
3745 * case WIFI_DIRECT_DISCOVERY_FOUND:
3746 * printf("peer devices found\n");
3749 * case WIFI_DIRECT_DISCOVERY_LOST:
3750 * printf("Discovery lost\n");
3760 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3761 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
3762 * wifi_direct_set_connection_state_changed_cb(callback_2, NULL); // Register callback 2
3764 * wifi_direct_activate(); // Activate Wi-Fi Direct
3765 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
3769 * // App must clean up Wi-Fi Direct before exiting
3771 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3772 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
3773 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3778 int wifi_direct_get_ip_address(char **ip_address);
3782 * @brief Gets the Subnet Mask.
3785 * @privilege http://tizen.org/privilege/wifidirect
3786 * @remarks @a subnet_mask must be released using free().
3787 * @param[out] subnet_mask The subnet mask
3788 * @return @c 0 on success,
3789 * otherwise a negative error value
3790 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3791 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
3792 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3793 * @retval #WIFI_DIRECT_ERROR_OUT_OF_MEMORY Out of memory
3794 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3795 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3796 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3797 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3798 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3799 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3800 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
3801 * @see wifi_direct_activate()
3804 * Here is an example of the usage:
3806 * #include <stdio.h>
3807 * #include <wifi_direct.h>
3809 * int function(void);
3811 * bool device_selected = false;
3813 * void peers_cb(wifi_direct_discovered_peer_info_s* peer,
3816 * if (peer && !device_selected) {
3817 * printf("peer device=%s MAC=%s\n", peer->device_name, peer->mac_address);
3819 * device_selected = true;
3821 * wifi_direct_connect(peer->mac_address); // Connect to the first discovered peer
3825 * int function(void)
3831 * wifi_direct_get_ip_address(&ip); // get ip address
3833 * ret = wifi_direct_get_subnetmask(&subnet); // get subnet mask
3835 * if (ret != WIFI_DIRECT_ERROR_NONE) {
3836 * printf("Failed to get subnet mask\n");
3840 * printf("subnet address=%s\n", subnet);
3846 * void callback_2(int error_code,
3847 * wifi_direct_connection_state_e state,
3848 * const char *mac, void *user_data)
3851 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
3852 * printf("Connection in progress\n");
3855 * case WIFI_DIRECT_CONNECTON_RSP:
3856 * printf("Connected\n");
3861 * case WIFI_DIRECT_DISCONNECTION_IND:
3862 * printf("Disconnection IND\n");
3865 * case WIFI_DIRECT_DISCONNECTION_RSP;
3866 * printf("Disconnected\n");
3871 * void callback_1(int error_code,
3872 * wifi_direct_discovery_state_e discovery_state,
3875 * switch(discovery_state) {
3876 * case WIFI_DIRECT_DISCOVERY_STARTED:
3877 * printf("Discovery started\n");
3880 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
3881 * printf("listen started\n");
3884 * case WIFI_DIRECT_DISCOVERY_FINISHED:
3885 * printf("Discovery finished\n");
3887 * wifi_direct_foreach_discovered_peers(peers_cb,
3891 * case WIFI_DIRECT_DISCOVERY_FOUND:
3892 * printf("peer devices found\n");
3895 * case WIFI_DIRECT_DISCOVERY_LOST:
3896 * printf("Discovery lost\n");
3906 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
3907 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
3908 * wifi_direct_set_connection_state_changed_cb(callback_2, NULL); // Register callback 2
3910 * wifi_direct_activate(); // Activate Wi-Fi Direct
3911 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
3915 * // App must clean up Wi-Fi Direct before exiting
3917 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
3918 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
3919 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
3924 int wifi_direct_get_subnet_mask(char **subnet_mask);
3928 * @brief Gets the Gateway address.
3931 * @privilege http://tizen.org/privilege/wifidirect
3932 * @remarks @a gateway_address must be released using free().
3933 * @param[out] gateway_address The gateway address
3934 * @return @c 0 on success,
3935 * otherwise a negative error value
3936 * @retval #WIFI_DIRECT_ERROR_NONE Successful
3937 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
3938 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
3939 * @retval #WIFI_DIRECT_ERROR_OUT_OF_MEMORY Out of memory
3940 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
3941 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
3942 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
3943 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
3944 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
3945 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
3946 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
3947 * @see wifi_direct_activate()
3950 * Here is an example of the usage:
3952 * #include <stdio.h>
3953 * #include <wifi_direct.h>
3955 * int function(void);
3957 * bool device_selected = false;
3959 * void peers_cb(wifi_direct_discovered_peer_info_s* peer,
3962 * if (peer && !device_selected) {
3963 * printf("peer device=%s MAC=%s\n", peer->device_name, peer->mac_address);
3965 * device_selected = true;
3967 * wifi_direct_connect(peer->mac_address); // Connect to the first discovered peer
3971 * int function(void)
3977 * wifi_direct_get_ip_address(&ip); // get ip address
3979 * ret = wifi_direct_get_gateway_address(&gateway); // get gateway address
3981 * if (ret != WIFI_DIRECT_ERROR_NONE) {
3982 * printf("Failed to get gateway address\n");
3986 * printf("gateway address=%s\n", gateway);
3992 * void callback_2(int error_code,
3993 * wifi_direct_connection_state_e state,
3994 * const char *mac, void *user_data)
3997 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
3998 * printf("Connection in progress\n");
4001 * case WIFI_DIRECT_CONNECTON_RSP:
4002 * printf("Connected\n");
4007 * case WIFI_DIRECT_DISCONNECTION_IND:
4008 * printf("Disconnection IND\n");
4011 * case WIFI_DIRECT_DISCONNECTION_RSP;
4012 * printf("Disconnected\n");
4017 * void callback_1(int error_code,
4018 * wifi_direct_discovery_state_e discovery_state,
4021 * switch(discovery_state) {
4022 * case WIFI_DIRECT_DISCOVERY_STARTED:
4023 * printf("Discovery started\n");
4026 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
4027 * printf("listen started\n");
4030 * case WIFI_DIRECT_DISCOVERY_FINISHED:
4031 * printf("Discovery finished\n");
4033 * wifi_direct_foreach_discovered_peers(peers_cb,
4037 * case WIFI_DIRECT_DISCOVERY_FOUND:
4038 * printf("peer devices found\n");
4041 * case WIFI_DIRECT_DISCOVERY_LOST:
4042 * printf("Discovery lost\n");
4052 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
4053 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
4054 * wifi_direct_set_connection_state_changed_cb(callback_2, NULL); // Register callback 2
4056 * wifi_direct_activate(); // Activate Wi-Fi Direct
4057 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
4061 * // App must clean up Wi-Fi Direct before exiting
4063 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
4064 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback
4065 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
4066 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
4071 int wifi_direct_get_gateway_address(char **gateway_address);
4075 * @brief Gets MAC address of a local device.
4078 * @privilege http://tizen.org/privilege/wifidirect
4079 * @remarks @a mac_address must be released using free().
4080 * @param[out] mac_address The MAC address
4081 * @return @c 0 on success,
4082 * otherwise a negative error value
4083 * @retval #WIFI_DIRECT_ERROR_NONE Successful
4084 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
4085 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
4086 * @retval #WIFI_DIRECT_ERROR_OUT_OF_MEMORY Out of memory
4087 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
4088 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
4089 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
4090 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
4091 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
4092 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
4093 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
4094 * @see wifi_direct_initialize()
4097 * Here is an example of the usage:
4099 * #include <stdio.h>
4100 * #include <wifi_direct.h>
4102 * int function(void);
4104 * bool device_selected = false;
4106 * void peers_cb(wifi_direct_discovered_peer_info_s* peer,
4109 * if (peer && !device_selected) {
4110 * printf("peer device=%s MAC=%s\n", peer->device_name, peer->mac_address);
4112 * device_selected = true;
4114 * wifi_direct_connect(peer->mac_address); // Connect to the first discovered peer
4118 * int function(void)
4124 * wifi_direct_get_ip_address(&ip); // get ip address
4126 * ret = wifi_direct_get_mac_address(&mac); // get MAC address
4128 * if (ret != WIFI_DIRECT_ERROR_NONE) {
4129 * printf("Failed to get mac address\n");
4133 * printf("MAC address=%s\n", mac);
4139 * void callback_2(int error_code,
4140 * wifi_direct_connection_state_e state,
4141 * const char *mac, void *user_data)
4144 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
4145 * printf("Connection in progress\n");
4148 * case WIFI_DIRECT_CONNECTON_RSP:
4149 * printf("Connected\n");
4154 * case WIFI_DIRECT_DISCONNECTION_IND:
4155 * printf("Disconnection IND\n");
4158 * case WIFI_DIRECT_DISCONNECTION_RSP;
4159 * printf("Disconnected\n");
4164 * void callback_1(int error_code,
4165 * wifi_direct_discovery_state_e discovery_state,
4168 * switch(discovery_state) {
4169 * case WIFI_DIRECT_DISCOVERY_STARTED:
4170 * printf("Discovery started\n");
4173 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
4174 * printf("listen started\n");
4177 * case WIFI_DIRECT_DISCOVERY_FINISHED:
4178 * printf("Discovery finished\n");
4180 * wifi_direct_foreach_discovered_peers(peers_cb,
4184 * case WIFI_DIRECT_DISCOVERY_FOUND:
4185 * printf("peer devices found\n");
4188 * case WIFI_DIRECT_DISCOVERY_LOST:
4189 * printf("Discovery lost\n");
4199 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
4200 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
4201 * wifi_direct_set_connection_state_changed_cb(callback_2, NULL); // Register callback 2
4203 * wifi_direct_activate(); // Activate Wi-Fi Direct
4204 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
4208 * // App must clean up Wi-Fi Direct before exiting
4210 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
4211 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback
4212 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
4213 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
4218 int wifi_direct_get_mac_address(char **mac_address);
4222 * @brief Gets the state of Wi-Fi Direct service.
4224 * @param[out] state The state of Wi-Fi Direct service
4225 * @return @c 0 on success,
4226 * otherwise a negative error value
4227 * @retval #WIFI_DIRECT_ERROR_NONE Successful
4228 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
4229 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
4230 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
4231 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
4232 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
4235 * Here is an example of the usage:
4237 * #include <stdio.h>
4238 * #include <wifi_direct.h>
4240 * char* print_state(wifi_direct_state_e state)
4242 * if (state == WIFI_DIRECT_STATE_DEACTIVATED)
4243 * return "DEACTIVATED";
4244 * if (state == WIFI_DIRECT_STATE_ACTIVATING)
4245 * return "ACTIVATING";
4246 * if (state == WIFI_DIRECT_STATE_ACTIVATED)
4247 * return "ACTIVATED";
4248 * if (state == WIFI_DIRECT_STATE_DISCOVERING)
4249 * return "DISCOVERING";
4250 * if (state == WIFI_DIRECT_STATE_CONNECTING)
4251 * return "CONNECTING";
4252 * if (state == WIFI_DIRECT_STATE_DISCONNECTING)
4253 * return "DISCONNECTING";
4254 * if (state == WIFI_DIRECT_STATE_CONNECTED)
4255 * return "CONNECTED";
4256 * if (state == WIFI_DIRECT_STATE_GROUP_OWNER)
4257 * return "GROUP OWNER";
4259 * return "Unknown state";
4262 * int function(void)
4267 * ret = wifi_direct_get_state(&state); // get Wi-Fi Direct state
4269 * if (ret != WIFI_DIRECT_ERROR_NONE) {
4270 * printf("Failed to get state\n");
4274 * printf(Wi-Fi Direct State = %s\n, print_state(state));
4281 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
4282 * wifi_direct_activate(); // Activate Wi-Fi Direct
4288 * // App must clean up Wi-Fi Direct before exiting
4290 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
4291 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
4296 int wifi_direct_get_state(wifi_direct_state_e *state);
4300 * @brief Checks whether this device is discoverable or not by P2P discovery.
4301 * @details If you call wifi_direct_start_discovery(), then your device can be discoverable.
4304 * @privilege http://tizen.org/privilege/wifidirect
4305 * @param[out] discoverable The status of discoverable:
4306 * (@c true = discoverable, @c false = non-discoverable)
4307 * @return @c 0 on success,
4308 * otherwise a negative error value
4309 * @retval #WIFI_DIRECT_ERROR_NONE Successful
4310 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
4311 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
4312 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
4313 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
4314 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
4315 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
4316 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
4317 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
4318 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
4319 * @see wifi_direct_initialize()
4320 * @see wifi_direct_start_discovery()
4321 * @see wifi_direct_cancel_discovery()
4324 * Here is an example of the usage:
4326 * #include <stdio.h>
4327 * #include <wifi_direct.h>
4329 * int function(void)
4332 * bool discoverable;
4334 * ret = wifi_direct_is_discoverable(&discoverable); // check if device is discoverable
4336 * if (ret != WIFI_DIRECT_ERROR_NONE) {
4337 * printf("Failed to get discoverable property\n");
4341 * printf("discoverable=%s\n", discoverable?"Yes":"No");
4346 * void callback_1(int error_code,
4347 * wifi_direct_discovery_state_e discovery_state,
4350 * switch(discovery_state) {
4351 * case WIFI_DIRECT_DISCOVERY_STARTED:
4352 * printf("Discovery started\n");
4357 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
4358 * printf("listen started\n");
4363 * case WIFI_DIRECT_DISCOVERY_FINISHED:
4364 * printf("Discovery finished\n");
4369 * case WIFI_DIRECT_DISCOVERY_FOUND:
4370 * printf("peer devices found\n");
4373 * case WIFI_DIRECT_DISCOVERY_LOST:
4374 * printf("Discovery lost\n");
4384 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
4385 * wifi_direct_activate(); // Activate Wi-Fi Direct
4386 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
4388 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
4394 * // App must clean up Wi-Fi Direct before exiting
4396 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
4397 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
4398 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
4403 int wifi_direct_is_discoverable(bool *discoverable);
4407 * @brief Checks whether the local device is listening only.
4408 * @details If you call wifi_direct_start_discovery() with @a listen_only as @c true,
4409 * it does not support specific channel but the initial 802.11.
4412 * @privilege http://tizen.org/privilege/wifidirect
4413 * @param[out] listen_only The status of listen only:(@c true = listen only, @c false =
4414 * cycling between Scan and Listen or not in discovery state)
4415 * @return @c 0 on success,
4416 * otherwise a negative error value
4417 * @retval #WIFI_DIRECT_ERROR_NONE Successful
4418 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
4419 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
4420 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
4421 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
4422 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
4423 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
4424 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
4425 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
4426 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
4427 * @see wifi_direct_activate()
4428 * @see wifi_direct_start_discovery()
4429 * @see wifi_direct_cancel_discovery()
4430 * @see wifi_direct_is_discoverable()
4433 * Here is an example of the usage:
4435 * #include <stdio.h>
4436 * #include <wifi_direct.h>
4438 * int function(void)
4443 * ret = wifi_direct_is_listening_only(&listen_only); // check if device is listening
4445 * if (ret != WIFI_DIRECT_ERROR_NONE) {
4446 * printf("Failed to get discoverable property\n");
4450 * printf("listening=%s\n", listen_only?"Yes":"No");
4455 * void callback_1(int error_code,
4456 * wifi_direct_discovery_state_e discovery_state,
4459 * switch(discovery_state) {
4460 * case WIFI_DIRECT_DISCOVERY_STARTED:
4461 * printf("Discovery started\n");
4464 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
4465 * printf("listen started\n");
4470 * case WIFI_DIRECT_DISCOVERY_FINISHED:
4471 * printf("Discovery finished\n");
4476 * case WIFI_DIRECT_DISCOVERY_FOUND:
4477 * printf("peer devices found\n");
4480 * case WIFI_DIRECT_DISCOVERY_LOST:
4481 * printf("Discovery lost\n");
4491 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
4492 * wifi_direct_activate(); // Activate Wi-Fi Direct
4493 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
4495 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
4501 * // App must clean up Wi-Fi Direct before exiting
4503 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
4504 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
4505 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
4510 int wifi_direct_is_listening_only(bool *listen_only);
4514 * @brief Gets the primary device type of a local device.
4517 * @privilege http://tizen.org/privilege/wifidirect
4518 * @param[out] type The primary device type
4519 * @return @c 0 on success,
4520 * otherwise a negative error value
4521 * @retval #WIFI_DIRECT_ERROR_NONE Successful
4522 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
4523 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
4524 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
4525 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
4526 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
4527 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
4528 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
4529 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
4530 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
4531 * @see wifi_direct_initialize()
4534 * Here is an example of the usage:
4536 * #include <stdio.h>
4537 * #include <wifi_direct.h>
4539 * char* print_type(wifi_direct_primary_device_type_e type)
4541 * if (type == WIFI_DIRECT_PRIMARY_DEVICE_TYPE_COMPUTER)
4542 * return "Computer";
4543 * if (state == WIFI_DIRECT_PRIMARY_DEVICE_TYPE_CAMERA)
4545 * if (state == WIFI_DIRECT_PRIMARY_DEVICE_TYPE_STORAGE)
4547 * if (state == WIFI_DIRECT_PRIMARY_DEVICE_TYPE_DISPLAY)
4549 * if (state == WIFI_DIRECT_PRIMARY_DEVICE_TYPE_TELEPHONE)
4550 * return "Telephone";
4552 * // Refer wifi_direct_primary_device_type_e enum for all devices
4555 * int function(void)
4560 * ret = wifi_direct_get_primary_device_type(&type); // get primary device type
4562 * if (ret != WIFI_DIRECT_ERROR_NONE) {
4563 * printf("Failed to get primary device type\n");
4567 * printf("primary Device = %s\n", print_type(type));
4574 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
4575 * wifi_direct_activate(); // Activate Wi-Fi Direct
4581 * // App must clean up Wi-Fi Direct before exiting
4583 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
4584 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
4589 int wifi_direct_get_primary_device_type(wifi_direct_primary_device_type_e *type);
4593 * @brief Gets the secondary device type of a local device.
4596 * @privilege http://tizen.org/privilege/wifidirect
4597 * @param[out] type The secondary device type
4598 * @return @c 0 on success,
4599 * otherwise a negative error value
4600 * @retval #WIFI_DIRECT_ERROR_NONE Successful
4601 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
4602 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
4603 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
4604 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
4605 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
4606 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
4607 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
4608 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
4609 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
4610 * @see wifi_direct_initialize()
4613 * Here is an example of the usage:
4615 * #include <stdio.h>
4616 * #include <wifi_direct.h>
4618 * char* print_type(wifi_direct_primary_device_type_e type)
4620 * if (type == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_COMPUTER_PC)
4621 * return "Computer pc";
4622 * if (state == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_INPUT_KEYBOARD)
4623 * return "input Keyboard";
4624 * if (state == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_CAMERA_VIDEO)
4625 * return "Camera Video";
4626 * if (state == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_STORAGE_NAS)
4627 * return "Storage NAS";
4628 * if (state == WIFI_DIRECT_SECONDARY_DEVICE_TYPE_DISPLAY_TV)
4629 * return "Display TV";
4631 * // Refer wifi_direct_secondary_device_type_e enum for all devices
4634 * int function(void)
4639 * ret = wifi_direct_get_secondary_device_type(&type); // get secondary device type
4641 * if (ret != WIFI_DIRECT_ERROR_NONE) {
4642 * printf("Failed to get secondary device type\n");
4646 * printf("secondary Device = %s\n", print_type(type));
4653 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
4654 * wifi_direct_activate(); // Activate Wi-Fi Direct
4660 * // App must clean up Wi-Fi Direct before exiting
4662 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
4663 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
4668 int wifi_direct_get_secondary_device_type(wifi_direct_secondary_device_type_e* type);
4672 * @brief Sets the WPS config PBC as preferred method for connection.
4675 * @privilege http://tizen.org/privilege/wifidirect
4676 * @return @c 0 on success,
4677 * otherwise a negative error value
4678 * @retval #WIFI_DIRECT_ERROR_NONE Successful
4679 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
4680 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
4681 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
4682 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
4683 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
4684 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
4685 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
4686 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
4687 * @see wifi_direct_activate()
4690 * Here is an example of the usage:
4692 * #include <stdio.h>
4693 * #include <wifi_direct.h>
4695 * int function(void)
4699 * ret = wifi_direct_activate_pushbutton(); // Activate WPS PBC Push Button
4701 * if (ret != WIFI_DIRECT_ERROR_NONE) {
4702 * printf("Failed to activate push button\n");
4706 * printf("Push button Activated successfully\n");
4713 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
4714 * wifi_direct_activate(); // Activate Wi-Fi Direct
4720 * // App must clean up Wi-Fi Direct before exiting
4722 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
4723 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
4728 int wifi_direct_activate_pushbutton(void);
4732 * @brief Sets or updates the WPS PIN number user expects.
4735 * @privilege http://tizen.org/privilege/wifidirect
4736 * @param[in] pin New pin to set. Application must set the new pin number before
4737 * @return @c 0 on success,
4738 * otherwise a negative error value
4739 * @retval #WIFI_DIRECT_ERROR_NONE Successful
4740 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
4741 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
4742 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
4743 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
4744 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
4745 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
4746 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
4747 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
4748 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
4749 * @see wifi_direct_activate()
4750 * @see wifi_direct_get_wps_pin()
4753 * Here is an example of the usage:
4755 * #include <stdio.h>
4756 * #include <wifi_direct.h>
4759 * int function(void)
4762 * char pin[9] = {0, };
4764 * printf("Input 8 digit PIN to set the WPS PIN mode\n");
4765 * read(stdin, pin, 8);
4767 * ret = wifi_direct_set_wps_pin(pin); // Set the WPS PIN for connection
4769 * if (ret != WIFI_DIRECT_ERROR_NONE) {
4770 * printf("Failed to set the WPS PIN\n");
4774 * printf("WPS PIN set success\n");
4778 * void callback(int error_code,
4779 * wifi_direct_connection_state_e connection_state,
4780 * const char *mac_address,
4787 * switch (connection_state) {
4789 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
4790 * printf("Connection in progress\n");
4793 * case WIFI_DIRECT_CONNECTION_RSP:
4794 * if (error_code == WIFI_DIRECT_ERROR_NONE) {
4795 * printf("Peer Device Connected\n"); // device is connected
4797 * printf("MAC=%s\n", mac_address); // device's MAC address
4799 * wifi_direct_get_ip_address(&ip);
4800 * printf("IP=%s\n", ip); //device's IP address
4802 * wifi_direct_is_group_owner(&owner);
4803 * printf("Ownership=%s\n", (owner)? "GO":"STA"); // (GO or client role)
4805 * } else if (error_code == WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT) {
4806 * printf("Connection timeout occurred\n");
4807 * } else if (error_code == WIFI_DIRECT_ERROR_AUTH_FAILED) {
4808 * printf("Connection authorization Failed\n");
4810 * printf("Connection failed\n");
4813 * case WIFI_DIRECT_CONNECTION_WPS_REQ:
4815 * wifi_direct_get_local_wps_type(&wps_mode);
4817 * if (wps_mode == WIFI_DIRECT_WPS_TYPE_PBC) {
4818 * printf("Connection type WPS PBC\n");
4819 * // Handle WPS PBC case here
4822 * if (wps_mode == WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY) {
4823 * printf("Connection type WPS PIN DISPLAY\n");
4824 * // Handle WPS PIN Display case here
4827 * if (wps_mode == WIFI_DIRECT_WPS_PIN_KEYPAD) {
4828 * printf("Connection type WPS PIN KEYPAD\n");
4830 * // Set 8 digit WPS PIN here
4831 * // Since the device has received the wps mode as PIN Keypad
4832 * // User need to set the WPS PIN for peer
4833 * // device connection using PIN method.
4835 * if (function() == 0)
4836 * wifi_direct_accept_connection(mac_address); // Accept the requested connection
4841 * case WIFI_DIRECT_CONNECTION_REQ:
4842 * printf("Connection request from MAC %s\n", mac_address);
4844 * // Handle the connection request from peer device here
4846 * // 2. WPS PIN Display
4847 * // 3. WPS PIN Keypad
4849 * wifi_direct_accept_connection(mac_address);
4852 * case WIFI_DIRECT_DISCONNECTION_IND:
4853 * if (error_code == WIFI_DIRECT_ERROR_NONE)
4854 * printf("peer device disconnected MAC %s\n", mac_address);
4857 * case WIFI_DIRECT_DISCONNECTION_RSP:
4858 * if (error_code == WIFI_DIRECT_ERROR_NONE)
4859 * printf("peer device disconnection response MAC %s\n", mac_address);
4862 * case WIFI_DIRECT_CONNECTION_DISASSOCIATION_IND:
4863 * if (error_code == WIFI_DIRECT_ERROR_NONE)
4864 * printf("peer device disassociation MAC %s\n", mac_address);
4867 * case WIFI_DIRECT_GROUP_CREATED:
4868 * printf("Group Created\n");
4871 * case WIFI_DIRECT_GROUP_DESTROYED:
4872 * printf("Group Destroyed\n");
4882 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
4883 * wifi_direct_set_connection_state_changed_cb(callback, NULL); // Register callback
4885 * wifi_direct_activate(); // Activate Wi-Fi Direct
4889 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
4891 * wifi_direct_set_connection_state_changed_cb(callback, NULL); // Deregister callback
4892 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
4897 int wifi_direct_set_wps_pin(char *pin);
4901 * @brief Gets the WPS PIN number.
4904 * @privilege http://tizen.org/privilege/wifidirect
4905 * @remarks @a pin must be released with free().
4906 * @param[out] pin Pointer to store pin number. Application must free this memory
4907 * @return @c 0 on success,
4908 * otherwise a negative error value
4909 * @retval #WIFI_DIRECT_ERROR_NONE Successful
4910 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
4911 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
4912 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
4913 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
4914 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
4915 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
4916 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
4917 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
4918 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
4919 * @see wifi_direct_activate()
4920 * @see wifi_direct_set_wps_pin()
4923 * Here is an example of the usage:
4925 * #include <stdio.h>
4926 * #include <wifi_direct.h>
4929 * int function(void)
4934 * ret = wifi_direct_get_wps_pin(&pin); // Get the WPS PIN
4936 * if (ret != WIFI_DIRECT_ERROR_NONE) {
4937 * printf("Failed to get the WPS PIN\n");
4941 * printf("WPS PIN : %s\n", pin);
4946 * void callback(int error_code,
4947 * wifi_direct_connection_state_e connection_state,
4948 * const char *mac_address,
4955 * switch (connection_state) {
4957 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
4958 * printf("Connection in progress\n");
4961 * case WIFI_DIRECT_CONNECTION_RSP:
4962 * if (error_code == WIFI_DIRECT_ERROR_NONE) {
4963 * printf("Peer Device Connected\n"); // device is connected
4965 * printf("MAC=%s\n", mac_address); // device's MAC address
4967 * wifi_direct_get_ip_address(&ip);
4968 * printf("IP=%s\n", ip); //device's IP address
4970 * wifi_direct_is_group_owner(&owner);
4971 * printf("Ownership=%s\n", (owner)? "GO":"STA"); // (GO or client role)
4973 * } else if (error_code == WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT) {
4974 * printf("Connection timeout occurred\n");
4975 * } else if (error_code == WIFI_DIRECT_ERROR_AUTH_FAILED) {
4976 * printf("Connection authorization Failed\n");
4978 * printf("Connection failed\n");
4981 * case WIFI_DIRECT_CONNECTION_WPS_REQ:
4983 * wifi_direct_get_local_wps_type(&wps_mode);
4985 * if (wps_mode == WIFI_DIRECT_WPS_TYPE_PBC) {
4986 * printf("Connection type WPS PBC\n");
4987 * // Handle WPS PBC case here
4990 * if (wps_mode == WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY) {
4991 * printf("Connection type WPS PIN DISPLAY\n");
4992 * // Handle WPS PIN Display case here
4995 * // Display WPS PIN here
4996 * // Since the device received WPS PIN Display connection request
4997 * // user need to display the WPS PIN which is shared by peer device
5002 * if (wps_mode == WIFI_DIRECT_WPS_PIN_KEYPAD) {
5003 * printf("Connection type WPS PIN KEYPAD\n");
5004 * // Handle WPS PIN Keypad case here
5008 * case WIFI_DIRECT_CONNECTION_REQ:
5009 * printf("Connection request from MAC %s\n", mac_address);
5011 * // Handle the connection request from peer device here
5013 * // 2. WPS PIN Display
5014 * // 3. WPS PIN Keypad
5016 * wifi_direct_accept_connection(mac_address);
5019 * case WIFI_DIRECT_DISCONNECTION_IND:
5020 * if (error_code == WIFI_DIRECT_ERROR_NONE)
5021 * printf("peer device disconnected MAC %s\n", mac_address);
5024 * case WIFI_DIRECT_DISCONNECTION_RSP:
5025 * if (error_code == WIFI_DIRECT_ERROR_NONE)
5026 * printf("peer device disconnection response MAC %s\n", mac_address);
5029 * case WIFI_DIRECT_CONNECTION_DISASSOCIATION_IND:
5030 * if (error_code == WIFI_DIRECT_ERROR_NONE)
5031 * printf("peer device disassociation MAC %s\n", mac_address);
5034 * case WIFI_DIRECT_GROUP_CREATED:
5035 * printf("Group Created\n");
5038 * case WIFI_DIRECT_GROUP_DESTROYED:
5039 * printf("Group Destroyed\n");
5049 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5050 * wifi_direct_set_connection_state_changed_cb(callback, NULL); // Register callback
5052 * wifi_direct_activate(); // Activate Wi-Fi Direct
5056 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5058 * wifi_direct_set_connection_state_changed_cb(callback, NULL); // Deregister callback
5059 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5064 int wifi_direct_get_wps_pin(char **pin);
5068 * @brief Gets all the supported WPS (Wi-Fi Protected Setup) types at local device.
5071 * @privilege http://tizen.org/privilege/wifidirect
5072 * @param[out] wps_mode Supported WPS mode for local device
5073 * @return @c 0 on success,
5074 * otherwise a negative error value
5075 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5076 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5077 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5078 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5079 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5080 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5081 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5082 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5083 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5084 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5085 * @see wifi_direct_initialize()
5088 * Here is an example of the usage:
5090 * #include <stdio.h>
5091 * #include <wifi_direct.h>
5093 * int function(void)
5098 * ret = wifi_direct_get_supported_wps_mode(&wps_mode); // Get supported WPS mode
5100 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5101 * printf("Failed to get supported wps mode\n");
5105 * switch (wps_mode) {
5106 * case WIFI_DIRECT_WPS_TYPE_PBC:
5107 * printf("mode is WPS PBC\n");
5110 * case WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY:
5111 * printf("mode is WPS PIN Display\n");
5114 * case WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD:
5115 * printf("mode is WPS PIN Keypad\n");
5124 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5125 * wifi_direct_activate(); // Activate Wi-Fi Direct
5131 * // App must clean up Wi-Fi Direct before exiting
5133 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5134 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5139 int wifi_direct_get_supported_wps_mode(int *wps_mode);
5143 * @brief Called when you get the supported WPS (Wi-Fi Protected Setup) type repeatedly.
5145 * @param[in] type The type of WPS
5146 * @param[in] user_data The user data passed from the request function
5147 * @return @c true to continue with the next iteration of the loop, \n
5148 * @c false to break out of the loop
5149 * @pre wifi_direct_foreach_supported_wps_types() will invoke this callback.
5150 * @see wifi_direct_foreach_supported_wps_types()
5152 typedef bool(*wifi_direct_supported_wps_type_cb)(wifi_direct_wps_type_e type, void *user_data);
5156 * @brief Gets the supported WPS (Wi-Fi Protected Setup) types.
5159 * @privilege http://tizen.org/privilege/wifidirect
5160 * @param[in] callback The callback function to invoke
5161 * @param[in] user_data The user data to be passed to the callback function
5162 * @return @c 0 on success,
5163 * otherwise a negative error value
5164 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5165 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5166 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5167 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5168 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5169 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5170 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5171 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5172 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5173 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5174 * @see wifi_direct_initialize()
5175 * @see wifi_direct_supported_wps_type_cb()
5178 * Here is an example of the usage:
5180 * #include <stdio.h>
5181 * #include <wifi_direct.h>
5184 * bool callback(wifi_direct_wps_types_e type, void *user_data)
5187 * case WIFI_DIRECT_WPS_TYPE_PBC:
5188 * printf("mode is WPS PBC\n");
5191 * case WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY:
5192 * printf("mode is WPS PIN Display\n");
5195 * case WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD:
5196 * printf("mode is WPS PIN Keypad\n");
5201 * int function(void)
5205 * ret = wifi_direct_foreach_supported_wps_types(callback, NULL);
5207 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5208 * printf("Failed to get supported wps types\n");
5217 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5218 * wifi_direct_activate(); // Activate Wi-Fi Direct
5224 * // App must clean up Wi-Fi Direct before exiting
5226 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5227 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5232 int wifi_direct_foreach_supported_wps_types(wifi_direct_supported_wps_type_cb callback, void *user_data);
5236 * @brief Gets the WPS (Wi-Fi Protected Setup) type.
5239 * @privilege http://tizen.org/privilege/wifidirect
5240 * @param[out] type The type of WPS
5241 * @return @c 0 on success,
5242 * otherwise a negative error value
5243 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5244 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5245 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5246 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5247 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5248 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5249 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5250 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5251 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5252 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5253 * @see wifi_direct_initialize()
5254 * @see wifi_direct_foreach_supported_wps_types()
5257 * Here is an example of the usage:
5259 * #include <stdio.h>
5260 * #include <wifi_direct.h>
5263 * int function(void)
5268 * ret = wifi_direct_get_local_wps_type(&wps_type);
5270 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5271 * printf("Failed to get supported wps types\n");
5275 * switch (wps_type) {
5276 * case WIFI_DIRECT_WPS_TYPE_PBC:
5277 * printf("mode is WPS PBC\n");
5280 * case WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY:
5281 * printf("mode is WPS PIN Display\n");
5284 * case WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD:
5285 * printf("mode is WPS PIN Keypad\n");
5293 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5294 * wifi_direct_activate(); // Activate Wi-Fi Direct
5300 * // App must clean up Wi-Fi Direct before exiting
5302 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5303 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5308 int wifi_direct_get_local_wps_type(wifi_direct_wps_type_e *type);
5312 * @brief Sets the requested WPS (Wi-Fi Protected Setup) type.
5315 * @privilege http://tizen.org/privilege/wifidirect
5316 * @param[in] type The type of WPS
5317 * @return @c 0 on success,
5318 * otherwise a negative error value
5319 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5320 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5321 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5322 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5323 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5324 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5325 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5326 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5327 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5328 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5329 * @see wifi_direct_initialize()
5330 * @see wifi_direct_foreach_supported_wps_types()
5333 * Here is an example of the usage:
5335 * #include <stdio.h>
5336 * #include <wifi_direct.h>
5339 * int function(void)
5345 * printf("Input new WPS mode\n");
5346 * printf("1. WPS Type PBC\n");
5347 * printf("2. WPS Type PIN Display\n");
5348 * printf("3. WPS Type PIN Keypad\n");
5349 * scanf("%1d", &option);
5353 * wps_type = WIFI_DIRECT_WPS_TYPE_PBC;
5357 * wps_type = WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY;
5361 * wps_type = WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD;
5365 * ret = wifi_direct_set_req_wps_type(wps_type);
5367 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5368 * printf("Failed to set requested wps types\n");
5377 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5378 * wifi_direct_activate(); // Activate Wi-Fi Direct
5384 * // App must clean up Wi-Fi Direct before exiting
5386 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5387 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5392 int wifi_direct_set_req_wps_type(wifi_direct_wps_type_e type);
5396 * @brief Gets the requested WPS (Wi-Fi Protected Setup) type.
5399 * @privilege http://tizen.org/privilege/wifidirect
5400 * @param[out] type The type of WPS
5401 * @return @c 0 on success,
5402 * otherwise a negative error value
5403 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5404 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5405 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5406 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5407 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5408 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5409 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5410 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5411 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5412 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5413 * @see wifi_direct_initialize()
5414 * @see wifi_direct_foreach_supported_wps_types()
5417 * Here is an example of the usage:
5419 * #include <stdio.h>
5420 * #include <wifi_direct.h>
5423 * int function(void)
5428 * ret = wifi_direct_get_req_wps_type(&wps_type);
5430 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5431 * printf("Failed to get supported wps types\n");
5435 * switch (wps_type) {
5436 * case WIFI_DIRECT_WPS_TYPE_PBC:
5437 * printf("mode is WPS PBC\n");
5440 * case WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY:
5441 * printf("mode is WPS PIN Display\n");
5444 * case WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD:
5445 * printf("mode is WPS PIN Keypad\n");
5453 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5454 * wifi_direct_activate(); // Activate Wi-Fi Direct
5460 * // App must clean up Wi-Fi Direct before exiting
5462 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5463 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5468 int wifi_direct_get_req_wps_type(wifi_direct_wps_type_e *type);
5472 * @brief Sets the intent of the group owner.
5475 * @privilege http://tizen.org/privilege/wifidirect
5476 * @remarks The range of intent is 0 - 15. The higher the @a intent is,
5477 * the higher the probability to be the group owner is.
5478 * @param[in] intent The intent of the group owner
5479 * @return @c 0 on success,
5480 * otherwise a negative error value
5481 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5482 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5483 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5484 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5485 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5486 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5487 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5488 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5489 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5490 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5491 * @see wifi_direct_initialize()
5492 * @see wifi_direct_get_group_owner_intent()
5495 * Here is an example of the usage:
5497 * #include <stdio.h>
5498 * #include <wifi_direct.h>
5501 * int function(void)
5506 * printf("Input the GO Intent range(0~15)\n");
5507 * scanf("%2d", &go_intent);
5509 * ret = wifi_direct_set_group_owner_intent(go_intent);
5511 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5512 * printf("Failed to set go intent\n");
5521 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5522 * wifi_direct_activate(); // Activate Wi-Fi Direct
5528 * // App must clean up Wi-Fi Direct before exiting
5530 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5531 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5536 int wifi_direct_set_group_owner_intent(int intent);
5539 * @brief Sets the intent of the group owner for each connection type.
5542 * @privilege http://tizen.org/privilege/wifidirect
5543 * @remarks The range of intent is 0 - 15. The higher the @a intent is, the higher the probability to be the group owner is.
5544 * @param[in] type The type of connection for a peer device
5545 * @param[in] intent The intent of the group owner
5546 * @return 0 on success, otherwise a negative error value
5547 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5548 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5549 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5550 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5551 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5552 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5553 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5554 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5555 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5556 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5557 * @see wifi_direct_initialize()
5558 * @see wifi_direct_get_go_intent_per_type()
5560 int wifi_direct_set_go_intent_per_type(int type, int intent);
5563 * @brief Gets the intent of the group owner.
5566 * @privilege http://tizen.org/privilege/wifidirect
5567 * @param[out] intent The intent of the group owner
5568 * @return @c 0 on success,
5569 * otherwise a negative error value
5570 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5571 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5572 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5573 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5574 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5575 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5576 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5577 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5578 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5579 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5580 * @see wifi_direct_initialize()
5581 * @see wifi_direct_set_group_owner_intent()
5584 * Here is an example of the usage:
5586 * #include <stdio.h>
5587 * #include <wifi_direct.h>
5590 * int function(void)
5595 * ret = wifi_direct_get_group_owner_intent(&go_intent);
5597 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5598 * printf("Failed to get go intent\n");
5602 * printf("Current GO Intent = %d\n", go_intent);
5608 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5609 * wifi_direct_activate(); // Activate Wi-Fi Direct
5615 * // App must clean up Wi-Fi Direct before exiting
5617 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5618 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5623 int wifi_direct_get_group_owner_intent(int *intent);
5626 * @brief Gets the intent of the group owner for each connection type.
5629 * @privilege http://tizen.org/privilege/wifidirect
5630 * @param[in] type The type of connection for a peer device
5631 * @param[out] intent The intent of the group owner
5632 * @return 0 on success, otherwise a negative error value
5633 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5634 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5635 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5636 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5637 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5638 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5639 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5640 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5641 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5642 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5643 * @see wifi_direct_initialize()
5644 * @see wifi_direct_set_go_intent_per_type()
5646 int wifi_direct_get_go_intent_per_type(int type, int *intent);
5649 * @brief Sets the max number of clients.
5652 * @privilege http://tizen.org/privilege/wifidirect
5653 * @param[in] max The max number of clients
5654 * @return @c 0 on success,
5655 * otherwise a negative error value
5656 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5657 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5658 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5659 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5660 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5661 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5662 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5663 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5664 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5665 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5666 * @see wifi_direct_initialize()
5667 * @see wifi_direct_get_max_clients()
5670 * Here is an example of the usage:
5672 * #include <stdio.h>
5673 * #include <wifi_direct.h>
5676 * int function(void)
5681 * printf("Input the maximum clients to be connected\n");
5682 * scanf("%4d", &max_client);
5684 * ret = wifi_direct_set_max_clients(max_client);
5686 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5687 * printf("Failed to set max clients\n");
5691 * printf("max client set success\n");
5697 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5698 * wifi_direct_activate(); // Activate Wi-Fi Direct
5704 * // App must clean up Wi-Fi Direct before exiting
5706 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5707 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5712 int wifi_direct_set_max_clients(int max);
5716 * @brief Gets the max number of clients.
5719 * @privilege http://tizen.org/privilege/wifidirect
5720 * @param[in] max The max number of clients
5721 * @return @c 0 on success,
5722 * otherwise a negative error value
5723 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5724 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5725 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5726 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5727 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5728 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5729 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5730 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5731 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5732 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5733 * @see wifi_direct_initialize()
5734 * @see wifi_direct_set_max_clients()
5737 * Here is an example of the usage:
5739 * #include <stdio.h>
5740 * #include <wifi_direct.h>
5743 * int function(void)
5748 * ret = wifi_direct_get_max_clients(&max_client);
5750 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5751 * printf("Failed to get max clients\n");
5755 * printf("max client = %d\n", max_client);
5761 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5762 * wifi_direct_activate(); // Activate Wi-Fi Direct
5768 * // App must clean up Wi-Fi Direct before exiting
5770 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5771 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5776 int wifi_direct_get_max_clients(int *max);
5780 * @brief Sets or updates Wi-Fi Protected Access (WPA) password.
5781 * When creating Wi-Fi Direct Group, this password will be used.
5784 * @privilege http://tizen.org/privilege/wifidirect
5785 * @remarks A peer can connect to this group as Wi-Fi Infrastructured mode with a passphrase.
5786 * @param[in] passphrase new wpa password to set. Application must set the new password before.
5787 * @return @c 0 on success,
5788 * otherwise a negative error value
5789 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5790 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5791 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5792 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5793 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5794 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5795 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5796 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5797 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5798 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
5799 * @see wifi_direct_activate()
5800 * @see wifi_direct_get_passphrase()
5803 * Here is an example of the usage:
5805 * #include <stdio.h>
5806 * #include <wifi_direct.h>
5809 * int function(void)
5812 * char key[65] = {0, };
5814 * printf("Input the passphrase\n");
5815 * read(stdin, key, 64);
5817 * ret = wifi_direct_set_passphrase(key);
5819 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5820 * printf("Failed to set passphrase\n");
5824 * printf("passphrase set success\n");
5830 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5831 * wifi_direct_activate(); // Activate Wi-Fi Direct
5837 * // App must clean up Wi-Fi Direct before exiting
5839 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5840 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5845 int wifi_direct_set_passphrase(const char *passphrase);
5849 * @brief Gets the Wi-Fi Protected Access (WPA) password when creating Wi-Fi Direct Group.
5852 * @privilege http://tizen.org/privilege/wifidirect
5853 * @remarks @a passphrase must be released with free().
5854 * @param[out] passphrase Pointer to store wpa password. Application must free this memory
5855 * @return @c 0 on success,
5856 * otherwise a negative error value
5857 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5858 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5859 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5860 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5861 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5862 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5863 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5864 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5865 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5866 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
5867 * @see wifi_direct_activate()
5868 * @see wifi_direct_set_passphrase()
5871 * Here is an example of the usage:
5873 * #include <stdio.h>
5874 * #include <wifi_direct.h>
5877 * int function(void)
5882 * ret = wifi_direct_get_passphrase(&key);
5884 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5885 * printf("Failed to get passphrase\n");
5889 * printf("passphrase = %s\n", key);
5896 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5897 * wifi_direct_activate(); // Activate Wi-Fi Direct
5903 * // App must clean up Wi-Fi Direct before exiting
5905 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5906 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5911 int wifi_direct_get_passphrase(char **passphrase);
5915 * @brief Gets the operating channel.
5918 * @privilege http://tizen.org/privilege/wifidirect
5919 * @param[out] channel The operating channel
5920 * @return @c 0 on success,
5921 * otherwise a negative error value
5922 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5923 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5924 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
5925 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
5926 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5927 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
5928 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5929 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5930 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
5931 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5932 * @see wifi_direct_initialize()
5935 * Here is an example of the usage:
5937 * #include <stdio.h>
5938 * #include <wifi_direct.h>
5941 * int function(void)
5946 * ret = wifi_direct_get_operating_channel(&channel);
5948 * if (ret != WIFI_DIRECT_ERROR_NONE) {
5949 * printf("Failed to get operating channel\n");
5953 * printf("operating channel = %d\n", channel);
5959 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
5960 * wifi_direct_activate(); // Activate Wi-Fi Direct
5966 * // App must clean up Wi-Fi Direct before exiting
5968 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
5969 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
5974 int wifi_direct_get_operating_channel(int *channel);
5978 * @brief Sets the Autoconnection mode.
5981 * @privilege http://tizen.org/privilege/wifidirect
5982 * @param[in] mode Describes the mode of connection. In case of TRUE \n
5983 * auto-connection will be taken care by framework
5984 * @return @c 0 on success,
5985 * otherwise a negative error value
5986 * @retval #WIFI_DIRECT_ERROR_NONE Successful
5987 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
5988 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
5989 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
5990 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
5991 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
5992 * @see wifi_direct_foreach_supported_wps_types()
5995 * Here is an example of the usage:
5997 * #include <stdio.h>
5998 * #include <wifi_direct.h>
6001 * int function(void)
6006 * printf("enable auto connect mode (yes[1] or no[2])\n");
6007 * scanf("%1d", &auto_connect);
6010 * ret = wifi_direct_set_autoconnection_mode(true);
6012 * ret = wifi_direct_set_sutoconnection_mode(false);
6014 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6015 * printf("Failed to set autoconnection mode\n");
6019 * printf("Auto connect mode enabled\n");
6025 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6026 * wifi_direct_activate(); // Activate Wi-Fi Direct
6032 * // App must clean up Wi-Fi Direct before exiting
6034 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6035 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6040 int wifi_direct_set_autoconnection_mode(bool mode);
6044 * @brief Gets the Autoconnection mode status.
6047 * @privilege http://tizen.org/privilege/wifidirect
6048 * @param[out] mode Describes the auto connection mode of framework has set.
6049 * @return @c 0 on success,
6050 * otherwise a negative error value
6051 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6052 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6053 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6054 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6055 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6056 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
6057 * @see wifi_direct_foreach_supported_wps_types()
6058 * @see wifi_direct_initialize()
6061 * Here is an example of the usage:
6063 * #include <stdio.h>
6064 * #include <wifi_direct.h>
6067 * int function(void)
6072 * ret = wifi_direct_is_autoconnection_mode(&status);
6074 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6075 * printf("Failed to get autoconnection mode\n");
6079 * printf("auto connect mode = %s\n", (status)?"Yes":"No");
6085 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6086 * wifi_direct_activate(); // Activate Wi-Fi Direct
6092 * // App must clean up Wi-Fi Direct before exiting
6094 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6095 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6100 int wifi_direct_is_autoconnection_mode(bool *mode);
6104 * @brief Allows a device to connect automatically.
6107 * @privilege http://tizen.org/privilege/wifidirect
6108 * @param[in] mac_address Device MAC address to allow autoconnection
6109 * @return @c 0 on success,
6110 * otherwise a negative error value
6111 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6112 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6113 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6114 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6115 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6116 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6117 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6118 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6119 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6120 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
6121 * @see wifi_direct_activate()
6124 * Here is an example of the usage:
6126 * #include <stdio.h>
6127 * #include <wifi_direct.h>
6129 * bool peer_selected = false;
6130 * int connection_timeout = 0;
6131 * int count = 0; // counter to wait for connection
6133 * int function(char *mac);
6135 * void peers_cb(wifi_direct_discovered_peer_info_s* peer,
6140 * if (peer && !peer_selected) {
6141 * printf("peer device=%s MAC=%s\n", peer->device_name, peer->mac_address);
6143 * peer_selected = true;
6145 * function(peer->mac_address);
6147 * wifi_direct_connect(peer->mac_address); // Connect to the selected peer
6151 * int function(char *mac)
6155 * ret = wifi_direct_set_autoconnection_peer(mac); // set autoconnection
6157 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6158 * printf("Failed to set autoconnection for peer\n");
6162 * printf("set auto-connection success\n");
6166 * void callback_2(int error_code,
6167 * wifi_direct_connection_state_e state,
6168 * const char *mac, void *user_data)
6171 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
6172 * printf("Connection in progress\n");
6175 * case WIFI_DIRECT_CONNECTON_RSP:
6176 * printf("Connected\n");
6177 * g_source_remove(connection_timeout);
6180 * case WIFI_DIRECT_DISCONNECTION_IND:
6181 * printf("Disconnection IND\n");
6184 * case WIFI_DIRECT_DISCONNECTION_RSP;
6185 * printf("Disconnected\n");
6190 * void callback_1(int error_code,
6191 * wifi_direct_discovery_state_e discovery_state,
6194 * switch(discovery_state) {
6195 * case WIFI_DIRECT_DISCOVERY_STARTED:
6196 * printf("Discovery started\n");
6199 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
6200 * printf("listen started\n");
6203 * case WIFI_DIRECT_DISCOVERY_FINISHED:
6204 * printf("Discovery finished\n");
6206 * wifi_direct_foreach_discovered_peers(peers_cb,
6207 * NULL); // Get discovered peer
6210 * case WIFI_DIRECT_DISCOVERY_FOUND:
6211 * printf("peer devices found\n");
6214 * case WIFI_DIRECT_DISCOVERY_LOST:
6215 * printf("Discovery lost\n");
6225 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6226 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
6227 * wifi_direct_set_connection_state_changed_cb(callback_2, NULL); // Register callback 2
6229 * wifi_direct_activate(); // Activate Wi-Fi Direct
6230 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
6232 * // App must clean up Wi-Fi Direct before exiting
6234 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6235 * wifi_direct_unset_connection_state_changed_cb(); // Deregister callback 2
6236 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback 1
6237 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6242 int wifi_direct_set_autoconnection_peer(char *mac_address);
6246 * @brief Enables the persistent group.
6247 * @details If @a enabled is true, then P2P persistent group will be used
6248 * while creating a group and establishing a connection.
6251 * @privilege http://tizen.org/privilege/wifidirect
6252 * @param[in] enabled The status of persistent group: (@c true = enabled, @c false = disabled)
6253 * @return @c 0 on success,
6254 * otherwise a negative error value
6255 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6256 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6257 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6258 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6259 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6260 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6261 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6262 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6263 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
6264 * @see wifi_direct_initialize()
6265 * @see wifi_direct_is_persistent_group_enabled()
6268 * Here is an example of the usage:
6270 * #include <stdio.h>
6271 * #include <wifi_direct.h>
6274 * int function(void)
6278 * ret = wifi_direct_set_persistence_group_enabled(true);
6280 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6281 * printf("Failed to set persistence group enabled\n");
6285 * printf("persistence group enabled success\n");
6291 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6292 * wifi_direct_activate(); // Activate Wi-Fi Direct
6298 * // App must clean up Wi-Fi Direct before exiting
6300 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6301 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6306 int wifi_direct_set_persistent_group_enabled(bool enabled);
6310 * @brief Checks whether the persistent group is enabled or disabled.
6313 * @privilege http://tizen.org/privilege/wifidirect
6314 * @param[out] enabled The status of the persistent group: (@c true = enabled, @c false = disabled)
6315 * @return @c 0 on success,
6316 * otherwise a negative error value
6317 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6318 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6319 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6320 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6321 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6322 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6323 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6324 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6325 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6326 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
6327 * @see wifi_direct_initialize()
6328 * @see wifi_direct_set_persistent_group_enabled()
6331 * Here is an example of the usage:
6333 * #include <stdio.h>
6334 * #include <wifi_direct.h>
6337 * int function(void)
6342 * ret = wifi_direct_is_persistent_group_enabled(&status);
6344 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6345 * printf("Failed to get status of persistence group enabled\n");
6349 * printf("persistence group status = %s\n", status?"Yes":"No");
6355 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6356 * wifi_direct_activate(); // Activate Wi-Fi Direct
6362 * // App must clean up Wi-Fi Direct before exiting
6364 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6365 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6370 int wifi_direct_is_persistent_group_enabled(bool *enabled);
6374 * @brief Called when you get the persistent groups repeatedly.
6376 * @remarks The @a mac_address can be used only in the callback. To use outside, make a copy.
6377 * The @a ssid can be used only in the callback. To use outside, make a copy.
6378 * @param[in] mac_address The MAC address of the persistent group owner
6379 * @param[in] ssid The SSID (Service Set Identifier) of the persistent group owner
6380 * @param[in] user_data The user data passed from the request function
6381 * @return @c true to continue with the next iteration of the loop, \n
6382 * @c false to break out of the loop
6383 * @pre wifi_direct_foreach_persistent_groups() will invoke this callback.
6384 * @see wifi_direct_foreach_persistent_groups()
6386 typedef bool(*wifi_direct_persistent_group_cb)(const char *mac_address, const char *ssid, void *user_data);
6390 * @brief Gets the persistent groups.
6393 * @privilege http://tizen.org/privilege/wifidirect
6394 * @param[in] callback The callback function to invoke
6395 * @param[in] user_data The user data to be passed to the callback function
6396 * @return @c 0 on success,
6397 * otherwise a negative error value
6398 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6399 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6400 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6401 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6402 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6403 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6404 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6405 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6406 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6407 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
6408 * @post wifi_direct_persistent_group_cb() will be called.
6409 * @see wifi_direct_initialize()
6410 * @see wifi_direct_persistent_group_cb()
6413 * Here is an example of the usage:
6415 * #include <stdio.h>
6416 * #include <wifi_direct.h>
6419 * bool callback(const char *mac_address,
6424 * printf("mac = %s\n", mac_address);
6427 * printf("ssid = %s\n", ssid);
6432 * int function(void)
6436 * ret = wifi_direct_foreach_persistent_groups(callback, NULL);
6438 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6439 * printf("Failed to set callback to get persistent groups\n");
6448 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6449 * wifi_direct_activate(); // Activate Wi-Fi Direct
6455 * // App must clean up Wi-Fi Direct before exiting
6457 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6458 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6463 int wifi_direct_foreach_persistent_groups(wifi_direct_persistent_group_cb callback, void *user_data);
6467 * @brief Removes a persistent group.
6470 * @privilege http://tizen.org/privilege/wifidirect
6471 * @param[in] mac_address The MAC address of the persistent group owner
6472 * @param[in] ssid The SSID (Service Set Identifier) of the persistent group owner
6473 * @return @c 0 on success,
6474 * otherwise a negative error value
6475 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6476 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6477 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6478 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6479 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6480 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6481 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6482 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6483 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6484 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
6485 * @see wifi_direct_initialize()
6486 * @see wifi_direct_foreach_persistent_groups()
6489 * Here is an example of the usage:
6491 * #include <stdio.h>
6492 * #include <wifi_direct.h>
6495 * int function(void)
6499 * char *ssid = NULL;
6501 * printf("Input MAC\n");
6502 * scanf("%18ms", &mac);
6504 * printf("Input SSID\n");
6505 * scanf("%33ms", &ssid);
6507 * ret = wifi_direct_remove_persistent_group(mac, ssid);
6509 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6510 * printf("Failed to remove persistent group\n");
6514 * printf("persistent group with MAC (%s) is removed\n", mac);
6522 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6523 * wifi_direct_activate(); // Activate Wi-Fi Direct
6529 * // App must clean up Wi-Fi Direct before exiting
6531 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6532 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6537 int wifi_direct_remove_persistent_group(char *mac_address, const char *ssid);
6541 * @brief Starts wifi direct service discovery.
6544 * @privilege http://tizen.org/privilege/wifidirect
6545 * @param[in] mac_address The MAC address of servicing device. A broadcast \n
6546 * will be sent when MAC is SET to ZERO
6547 * @param[in] service_type Describes the type of service
6548 * @return @c 0 on success,
6549 * otherwise a negative error value
6550 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6551 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6552 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6553 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6554 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6555 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6556 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6557 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6558 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6559 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
6560 * @post wifi_direct_set_service_state_changed_cb() will be invoked.
6561 * @see wifi_direct_activate()
6562 * @see wifi_direct_set_service_state_changed_cb()
6565 * Here is an example of the usage:
6567 * #include <stdio.h>
6568 * #include <wifi_direct.h>
6570 * void callback(int error_code,
6571 * wifi_direct_service_discovery_state_e discovery_state,
6572 * wifi_direct_service_type_e service_type,
6573 * void *response_data, const char * mac_address,
6576 * switch (discovery_state) {
6577 * case WIFI_DIRECT_SERVICE_DISCOVERY_STARTED:
6578 * printf("Service discovery started\n");
6581 * case WIFI_DIRECT_SERVICE_DISCOVERY_FINISHED:
6582 * printf("Service discovery finished\n");
6585 * case WIFI_DIRECT_SERVICE_DISCOVERY_FOUND:
6586 * printf("Service discovery found\n");
6591 * int function(void)
6595 * wifi_direct_service_type_e type = WIFI_DIRECT_SERVICE_TYPE_ALL;
6597 * printf("Input service type\n");
6598 * scanf("%1d", &option);
6600 * printf("1. WIFI_DIRECT_SERVICE_TYPE_ALL\n");
6601 * printf("2. WIFI_DIRECT_SERVICE_TYPE_BONJOUR\n");
6602 * printf("3. WIFI_DIRECT_SERVICE_TYPE_UPNP\n");
6603 * printf("4. WIFI_DIRECT_SERVICE_TYPE_BT_ADDR\n");
6604 * printf("5. WIFI_DIRECT_SERVICE_TYPE_CONTACT_INFO\n");
6608 * type = WIFI_DIRECT_SERVICE_TYPE_ALL;
6612 * type = WIFI_DIRECT_SERVICE_TYPE_BONJOUR;
6616 * type = WIFI_DIRECT_SERVICE_TYPE_UPNP;
6620 * type = WIFI_DIRECT_SERVICE_TYPE_BT_ADDR;
6624 * type = WIFI_DIRECT_SERVICE_TYPE_CONTACT_INFO;
6628 * ret = wifi_direct_start_service_discovery(NULL, type); // start broadcast service discovery
6630 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6631 * printf("Failed to start service discovery\n");
6640 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6641 * wifi_direct_set_service_state_changed_cb(callback, NULL);
6642 * wifi_direct_activate(); // Activate Wi-Fi Direct
6648 * // App must clean up Wi-Fi Direct before exiting
6650 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6651 * wifi_direct_unset_service_state_changed_cb();
6652 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6657 int wifi_direct_start_service_discovery(char *mac_address, wifi_direct_service_type_e service_type);
6661 * @brief Cancels an ongoing wifi direct service discovery.
6664 * @privilege http://tizen.org/privilege/wifidirect
6665 * @param[in] mac_address The MAC address of servicing device. A broadcast \n
6666 * will be sent when MAC is SET to ZERO
6667 * @param[in] service_type Describes the type of service
6668 * @return @c 0 on success,
6669 * otherwise a negative error value
6670 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6671 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6672 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6673 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6674 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6675 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6676 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6677 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6678 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6679 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
6680 * @see wifi_direct_activate()
6683 * Here is an example of the usage:
6685 * #include <stdio.h>
6686 * #include <wifi_direct.h>
6688 * void callback(int error_code,
6689 * wifi_direct_service_discovery_state_e discovery_state,
6690 * wifi_direct_service_type_e service_type,
6691 * void *response_data, const char * mac_address,
6694 * switch (discovery_state) {
6695 * case WIFI_DIRECT_SERVICE_DISCOVERY_STARTED:
6696 * printf("Service discovery started\n");
6699 * case WIFI_DIRECT_SERVICE_DISCOVERY_FINISHED:
6700 * printf("Service discovery finished\n");
6703 * case WIFI_DIRECT_SERVICE_DISCOVERY_FOUND:
6704 * printf("Service discovery found\n");
6709 * int function(void)
6713 * ret = wifi_direct_cancel_service_discovery(NULL,
6714 * WIFI_DIRECT_SERVICE_TYPE_ALL); // cancel the ongoing service discovery
6716 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6717 * printf("Failed to cancel service discovery\n");
6726 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6727 * wifi_direct_set_service_state_changed_cb(callback, NULL);
6728 * wifi_direct_activate(); // Activate Wi-Fi Direct
6730 * wifi_direct_start_service_discovery(NULL,
6731 * WIFI_DIRECT_SERVICE_TYPE); // start broadcast service discovery
6737 * // App must clean up Wi-Fi Direct before exiting
6739 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6740 * wifi_direct_unset_service_state_changed_cb();
6741 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6746 int wifi_direct_cancel_service_discovery(char *mac_address, wifi_direct_service_type_e service_type);
6750 * @brief Registers for a service using Wi-Fi Direct Service Discovery.
6753 * @privilege http://tizen.org/privilege/wifidirect
6754 * @param[in] service_type Describes the type of service.
6755 * @param[in] info1 Describes the information of service. It is service-specific
6756 * @param[in] info2 Describes the information of service. It is service-specific
6757 * @param[out] service_id A Service ID will be assigned to service getting registered
6758 * @return @c 0 on success,
6759 * otherwise a negative error value
6760 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6761 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6762 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6763 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6764 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6765 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6766 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6767 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6768 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6769 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
6770 * @see wifi_direct_activate()
6773 * Here is an example of the usage:
6775 * #include <stdio.h>
6776 * #include <wifi_direct.h>
6778 * void callback(int error_code,
6779 * wifi_direct_service_discovery_state_e discovery_state,
6780 * wifi_direct_service_type_e service_type,
6781 * void *response_data, const char * mac_address,
6784 * switch (discovery_state) {
6785 * case WIFI_DIRECT_SERVICE_DISCOVERY_STARTED:
6786 * printf("Service discovery started\n");
6789 * case WIFI_DIRECT_SERVICE_DISCOVERY_FINISHED:
6790 * printf("Service discovery finished\n");
6793 * case WIFI_DIRECT_SERVICE_DISCOVERY_FOUND:
6794 * printf("Service discovery found\n");
6799 * int function(void)
6805 * wifi_direct_service_type_e type = WIFI_DIRECT_SERVICE_TYPE_ALL;
6807 * printf("Input service type\n");
6808 * scanf("%1d", &option);
6810 * printf("1. WIFI_DIRECT_SERVICE_TYPE_ALL\n");
6811 * printf("2. WIFI_DIRECT_SERVICE_TYPE_BONJOUR\n");
6812 * printf("3. WIFI_DIRECT_SERVICE_TYPE_UPNP\n");
6813 * printf("4. WIFI_DIRECT_SERVICE_TYPE_BT_ADDR\n");
6814 * printf("5. WIFI_DIRECT_SERVICE_TYPE_CONTACT_INFO\n");
6818 * type = WIFI_DIRECT_SERVICE_TYPE_ALL;
6822 * type = WIFI_DIRECT_SERVICE_TYPE_BONJOUR;
6824 * printf("Enter the info 1\n");
6825 * scanf("%50ms", &info1);
6827 * printf("Enter the info 2\n");
6828 * scanf("%50ms", &info2);
6832 * type = WIFI_DIRECT_SERVICE_TYPE_UPNP;
6834 * printf("Enter the info 1\n");
6835 * scanf("%50ms", &info1);
6837 * printf("Enter the info 2\n");
6838 * scanf("%50ms", &info2);
6842 * type = WIFI_DIRECT_SERVICE_TYPE_BT_ADDR;
6846 * type = WIFI_DIRECT_SERVICE_TYPE_CONTACT_INFO;
6848 * printf("Enter the info 1\n");
6849 * scanf("%50ms", &info1);
6853 * ret = wifi_direct_register_service(type, info1, info2, &option);
6855 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6856 * printf("Failed to start service discovery\n");
6860 * wifi_direct_start_service_discovery(NULL, type);
6869 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6870 * wifi_direct_set_service_state_changed_cb(callback, NULL);
6871 * wifi_direct_activate(); // Activate Wi-Fi Direct
6877 * // App must clean up Wi-Fi Direct before exiting
6879 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6880 * wifi_direct_unset_service_state_changed_cb();
6881 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6886 int wifi_direct_register_service(wifi_direct_service_type_e service_type, char *info1, char *info2, unsigned int *service_id);
6890 * @brief Deregisters for a service used for Wi-Fi Direct Service Discovery.
6893 * @privilege http://tizen.org/privilege/wifidirect
6894 * @param[in] service_id A Service ID for which service has to be deregistered
6895 * @return @c 0 on success,
6896 * otherwise a negative error value
6897 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6898 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6899 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6900 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6901 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6902 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6903 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6904 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6905 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6906 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
6907 * @see wifi_direct_activate()
6910 * Here is an example of the usage:
6912 * #include <stdio.h>
6913 * #include <wifi_direct.h>
6916 * int function(void)
6921 * printf("Enter the service id\n");
6922 * scanf("%5d", &input);
6924 * ret = wifi_direct_deregister_service(input);
6926 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6927 * printf("Failed to deregister service\n");
6936 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6937 * wifi_direct_activate(); // Activate Wi-Fi Direct
6943 * // App must clean up Wi-Fi Direct before exiting
6945 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
6946 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
6951 int wifi_direct_deregister_service(unsigned int service_id);
6955 * @brief Initializes OR Deintializes the WiFi Direct Display (MIRACAST) service.
6958 * @privilege http://tizen.org/privilege/wifidirect
6959 * @param[in] enable Enables/Disables Service based on the value TRUE/FALSE
6960 * @return @c 0 on success,
6961 * otherwise a negative error value
6962 * @retval #WIFI_DIRECT_ERROR_NONE Successful
6963 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
6964 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
6965 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
6966 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
6967 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
6968 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
6969 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
6970 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
6971 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
6972 * @see wifi_direct_activate()
6975 * Here is an example of the usage:
6977 * #include <stdio.h>
6978 * #include <wifi_direct.h>
6981 * int function(void)
6985 * ret = wifi_direct_init_miracast(true);
6987 * if (ret != WIFI_DIRECT_ERROR_NONE) {
6988 * printf("Failed to init miracast\n");
6992 * printf("init miracast success\n");
6998 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
6999 * wifi_direct_activate(); // Activate Wi-Fi Direct
7005 * // App must clean up Wi-Fi Direct before exiting
7007 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7008 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7013 int wifi_direct_init_miracast(bool enable);
7017 * @brief Gets the information of a discovered peer.
7020 * @privilege http://tizen.org/privilege/wifidirect
7021 * @param[in] mac_address The MAC address of peer to get
7022 * @param[out] peer_info The peer information to be passed
7023 * @return @c 0 on success,
7024 * otherwise a negative error value
7025 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7026 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7027 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7028 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7029 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7030 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7031 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7032 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7033 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7034 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
7035 * @see wifi_direct_activate()
7036 * @see wifi_direct_foreach_discovered_peers()
7039 * Here is an example of the usage:
7041 * #include <stdio.h>
7042 * #include <wifi_direct.h>
7045 * int function(void)
7048 * char mac[19] = {0, };
7049 * wifi_direct_discovered_peer_info_s *peer_info;
7051 * printf("Input peer MAC address\n");
7052 * read(stdin, mac, 18);
7054 * ret = wifi_direct_get_peer_info(mac, &peer_info);
7056 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7057 * printf("Failed to get peer info\n");
7061 * printf("get peer info success\n");
7067 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7068 * wifi_direct_activate(); // Activate Wi-Fi Direct
7074 * // App must clean up Wi-Fi Direct before exiting
7076 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7077 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7082 int wifi_direct_get_peer_info(char *mac_address, wifi_direct_discovered_peer_info_s **peer_info);
7086 * @brief Enables Wi-Fi Display (WFD) functionality and initialize the various variables required for WFD.
7087 * @details Starts listening in only assigned channel. Device will be discoverable
7088 * only in assigned listen channel.
7091 * @privilege http://tizen.org/privilege/wifidirect
7092 * @return @c 0 on success,
7093 * otherwise a negative error value
7094 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7095 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7096 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7097 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7098 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7099 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7100 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7101 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7102 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate()
7103 * @see wifi_direct_activate()
7104 * @see wifi_direct_deinit_display()
7105 * @see wifi_direct_set_display()
7108 * Here is an example of the usage:
7110 * #include <stdio.h>
7111 * #include <wifi_direct.h>
7114 * int function(void)
7118 * ret = wifi_direct_init_display();
7120 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7121 * printf("Failed to init display\n");
7125 * printf("init display success\n");
7131 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7132 * wifi_direct_activate(); // Activate Wi-Fi Direct
7138 * // App must clean up Wi-Fi Direct before exiting
7140 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7141 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7146 int wifi_direct_init_display(void);
7150 * @brief Disables Wi-Fi Display functionality & disables the support of WFD Information Element (IE).
7153 * @privilege http://tizen.org/privilege/wifidirect
7154 * @return @c 0 on success,
7155 * otherwise a negative error value
7156 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7157 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7158 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7159 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7160 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7161 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7162 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7163 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7164 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate()
7165 * and Wi-Fi Display must be enabled by wifi_direct_init_display().
7166 * @see wifi_direct_activate()
7167 * @see wifi_direct_init_display()
7168 * @see wifi_direct_set_display()
7171 * Here is an example of the usage:
7173 * #include <stdio.h>
7174 * #include <wifi_direct.h>
7177 * int function(void)
7181 * wifi_direct_init_display();
7183 * ret = wifi_direct_deinit_display();
7185 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7186 * printf("Failed to deinit display\n");
7190 * printf("deinit display success\n");
7196 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7197 * wifi_direct_activate(); // Activate Wi-Fi Direct
7203 * // App must clean up Wi-Fi Direct before exiting
7205 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7206 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7211 int wifi_direct_deinit_display(void);
7215 * @brief Sets the Wi-Fi Display parameters for the WFD IE of local device.
7218 * @privilege http://tizen.org/privilege/wifidirect
7219 * @param[in] type WFD Device Type: define the Role of WFD device like source or sink
7220 * @param[in] port Specifies Session Management Control Port number. It should be 2 bytes (0~65535)
7221 * @param[in] hdcp CP support bit: (@c 1 = enable the hdcp support, @c 0 = disable the hdcp support)
7222 * @return @c 0 on success,
7223 * otherwise a negative error value
7224 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7225 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7226 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7227 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7228 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7229 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7230 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7231 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7232 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7233 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate()
7234 * and Wi-Fi Display must be enabled by wifi_direct_init_display().
7235 * @see wifi_direct_activate()
7236 * @see wifi_direct_init_display()
7237 * @see wifi_direct_deinit_display()
7240 * Here is an example of the usage:
7242 * #include <stdio.h>
7243 * #include <wifi_direct.h>
7246 * int function(void)
7250 * ret = wifi_direct_set_display(WIFI_DIRECT_DISPLAY_SOURCE, 7236, 1);
7252 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7253 * printf("Failed to set display property\n");
7257 * printf("set display param success\n");
7263 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7264 * wifi_direct_activate(); // Activate Wi-Fi Direct
7270 * // App must clean up Wi-Fi Direct before exiting
7272 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7273 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7278 int wifi_direct_set_display(wifi_direct_display_type_e type, int port, int hdcp);
7282 * @brief Sets the Wi-Fi Display Session Availability.
7285 * @privilege http://tizen.org/privilege/wifidirect
7286 * @param[in] availability Wi-Fi Display Session Availability
7287 * @return @c 0 on success,
7288 * otherwise a negative error value
7289 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7290 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7291 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7292 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7293 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7294 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7295 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7296 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7297 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7298 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate()
7299 * and enable Wi-Fi Display by wifi_direct_init_display().
7300 * @see wifi_direct_activate()
7301 * @see wifi_direct_init_display()
7302 * @see wifi_direct_deinit_display()
7305 * Here is an example of the usage:
7307 * #include <stdio.h>
7308 * #include <wifi_direct.h>
7311 * int function(void)
7316 * printf("Input the Wi-FI Display availability\n");
7317 * scanf("%1d", &availability);
7319 * ret = wifi_direct_set_display_availability(availability);
7321 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7322 * printf("Failed to set display availability\n");
7326 * printf("set display availability success\n");
7332 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7333 * wifi_direct_activate(); // Activate Wi-Fi Direct
7339 * // App must clean up Wi-Fi Direct before exiting
7341 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7342 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7347 int wifi_direct_set_display_availability(bool availability);
7351 * @brief Gets the Wi-Fi Display parameters for the WFD IE of local device.
7354 * @privilege http://tizen.org/privilege/wifidirect
7355 * @param[out] type WFD device type: role of WFD device like source or sink
7356 * @param[out] port Session management control port number, it will be of 2 bytes (0~65535)
7357 * @param[out] hdcp CP support bit: (@c 1 = hdcp support is enabled, @c 0 = hdcp support is disabled)
7358 * @return @c 0 on success,
7359 * otherwise a negative error value
7360 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7361 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7362 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7363 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7364 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7365 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7366 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7367 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7368 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7369 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate()
7370 * and enable Wi-Fi Display by wifi_direct_init_display().
7371 * @see wifi_direct_activate()
7372 * @see wifi_direct_init_display()
7373 * @see wifi_direct_deinit_display()
7376 * Here is an example of the usage:
7378 * #include <stdio.h>
7379 * #include <wifi_direct.h>
7382 * int function(void)
7385 * wifi_direct_display_type_e type;
7389 * ret = wifi_direct_get_display(&type, &port, &hdcp);
7391 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7392 * printf("Failed to get display property\n");
7396 * printf("get display param success [type:%d], [port:%d], [hdcp:%d]\n", type, port, hdcp);
7402 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7403 * wifi_direct_activate(); // Activate Wi-Fi Direct
7409 * // App must clean up Wi-Fi Direct before exiting
7411 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7412 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7417 int wifi_direct_get_display(wifi_direct_display_type_e *type, int *port, int *hdcp);
7421 * @brief Gets the Wi-Fi Display Session Availability.
7424 * @privilege http://tizen.org/privilege/wifidirect
7425 * @param[out] availability Wi-Fi display session availability
7426 * @return @c 0 on success,
7427 * otherwise a negative error value
7428 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7429 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7430 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7431 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7432 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7433 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7434 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7435 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7436 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7437 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate()
7438 * and enable Wi-Fi Display by wifi_direct_init_display().
7439 * @see wifi_direct_activate()
7440 * @see wifi_direct_init_display()
7441 * @see wifi_direct_deinit_display()
7444 * Here is an example of the usage:
7446 * #include <stdio.h>
7447 * #include <wifi_direct.h>
7450 * int function(void)
7455 * ret = wifi_direct_get_display_availability(&availability);
7457 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7458 * printf("Failed to get display availability\n");
7462 * printf("get display availability success [%d]\n", availability);
7468 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7469 * wifi_direct_activate(); // Activate Wi-Fi Direct
7475 * // App must clean up Wi-Fi Direct before exiting
7477 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7478 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7483 int wifi_direct_get_display_availability(bool *availability);
7487 * @brief Gets the information of a peer's Wi-Fi Display device type.
7490 * @privilege http://tizen.org/privilege/wifidirect
7491 * @param[in] mac_address MAC Address of the PEER
7492 * @param[out] type The information of a peer's Wi-Fi Display device type
7493 * if there's Wi-Fi Direct information, this will be NULL
7494 * @return @c 0 on success,
7495 * otherwise a negative error value
7496 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7497 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7498 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7499 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7500 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7501 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7502 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7503 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7504 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7505 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
7506 * @see wifi_direct_activate()
7507 * @see wifi_direct_foreach_discovered_peers()
7510 * Here is an example of the usage:
7512 * #include <stdio.h>
7513 * #include <wifi_direct.h>
7516 * int function(void)
7520 * wifi_direct_display_type_e type;
7522 * printf("Input the peer mac\n");
7523 * scanf("%18ms", &mac);
7525 * ret = wifi_direct_get_peer_display_type(mac, &type);
7527 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7528 * printf("Failed to get peer display type\n");
7532 * printf("peer display type = %d\n", type);
7539 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7540 * wifi_direct_activate(); // Activate Wi-Fi Direct
7546 * // App must clean up Wi-Fi Direct before exiting
7548 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7549 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7554 int wifi_direct_get_peer_display_type(char *mac_address, wifi_direct_display_type_e *type);
7558 * @brief Gets the information of a peer's Wi-Fi Display session availability.
7561 * @privilege http://tizen.org/privilege/wifidirect
7562 * @param[in] mac_address MAC Address of the PEER
7563 * @param[out] availability The information of a peer's Wi-Fi Display session availability
7564 * if there's Wi-Fi Direct information, this will be NULL
7565 * @return @c 0 on success,
7566 * otherwise a negative error value
7567 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7568 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7569 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7570 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7571 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7572 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7573 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7574 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7575 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7576 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
7577 * @see wifi_direct_activate()
7578 * @see wifi_direct_foreach_discovered_peers()
7581 * Here is an example of the usage:
7583 * #include <stdio.h>
7584 * #include <wifi_direct.h>
7587 * int function(void)
7590 * bool availability;
7593 * printf("Input the peer mac\n");
7594 * scanf("%18ms", &mac);
7596 * ret = wifi_direct_get_peer_display_availability(mac, &availability);
7598 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7599 * printf("Failed to get peer display availability\n");
7603 * printf("peer display availability = %s\n", availability?"yes":"no");
7610 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7611 * wifi_direct_activate(); // Activate Wi-Fi Direct
7617 * // App must clean up Wi-Fi Direct before exiting
7619 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7620 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7625 int wifi_direct_get_peer_display_availability(char *mac_address, bool *availability);
7629 * @brief Gets the information of a peer's Wi-Fi Display HDCP support.
7632 * @privilege http://tizen.org/privilege/wifidirect
7633 * @param[in] mac_address MAC Address of the PEER
7634 * @param[out] hdcp The information of a peer's Wi-Fi Display HDCP support
7635 * if there's Wi-Fi Direct information, this will be NULL
7636 * @return @c 0 on success,
7637 * otherwise a negative error value
7638 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7639 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7640 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7641 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7642 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7643 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7644 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7645 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7646 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7647 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
7648 * @see wifi_direct_activate()
7649 * @see wifi_direct_foreach_discovered_peers()
7652 * Here is an example of the usage:
7654 * #include <stdio.h>
7655 * #include <wifi_direct.h>
7658 * int function(void)
7664 * printf("Input the peer mac\n");
7665 * scanf("%18ms", &mac);
7667 * ret = wifi_direct_get_peer_display_hdcp(mac, &hdcp);
7669 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7670 * printf("Failed to get peer display hdcp\n");
7674 * printf("peer display hdcp = %d\n", hdcp);
7681 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7682 * wifi_direct_activate(); // Activate Wi-Fi Direct
7688 * // App must clean up Wi-Fi Direct before exiting
7690 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7691 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7696 int wifi_direct_get_peer_display_hdcp(char *mac_address, int *hdcp);
7700 * @brief Gets the information of a peer's Wi-Fi Display RTSP control port.
7703 * @privilege http://tizen.org/privilege/wifidirect
7704 * @param[in] mac_address MAC Address of the PEER
7705 * @param[out] port The information of a peer's Wi-Fi Display RTSP control port
7706 * if there's Wi-Fi Direct information, this will be NULL
7707 * @return @c 0 on success,
7708 * otherwise a negative error value
7709 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7710 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7711 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7712 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7713 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7714 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7715 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7716 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7717 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7718 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
7719 * @see wifi_direct_activate()
7720 * @see wifi_direct_foreach_discovered_peers()
7723 * Here is an example of the usage:
7725 * #include <stdio.h>
7726 * #include <wifi_direct.h>
7729 * int function(void)
7735 * printf("Input the peer mac\n");
7736 * scanf("%18ms", &mac);
7738 * ret = wifi_direct_get_peer_display_port(mac, &port);
7740 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7741 * printf("Failed to get peer display port\n");
7745 * printf("peer display port = %d\n", port);
7752 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7753 * wifi_direct_activate(); // Activate Wi-Fi Direct
7759 * // App must clean up Wi-Fi Direct before exiting
7761 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7762 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7767 int wifi_direct_get_peer_display_port(char *mac_address, int *port);
7771 * @brief Gets the information of a peer's Wi-Fi Display max throughput.
7774 * @privilege http://tizen.org/privilege/wifidirect
7775 * @param[in] mac_address MAC Address of the PEER
7776 * @param[out] throughput The information of a peer's Wi-Fi Display max throughput (Mbps)
7777 * if there's Wi-Fi Direct information, this will be NULL
7778 * @return @c 0 on success,
7779 * otherwise a negative error value
7780 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7781 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7782 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7783 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7784 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7785 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7786 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7787 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7788 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7789 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
7790 * @see wifi_direct_activate()
7791 * @see wifi_direct_foreach_discovered_peers()
7794 * Here is an example of the usage:
7796 * #include <stdio.h>
7797 * #include <wifi_direct.h>
7800 * int function(void)
7806 * printf("Input the peer mac\n");
7807 * scanf("%18ms", &mac);
7809 * ret = wifi_direct_get_peer_display_throughput(mac, &tput);
7811 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7812 * printf("Failed to get peer display throughput\n");
7816 * printf("peer display throughput = %d\n", tput);
7823 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7824 * wifi_direct_activate(); // Activate Wi-Fi Direct
7830 * // App must clean up Wi-Fi Direct before exiting
7832 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7833 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7838 int wifi_direct_get_peer_display_throughput(char *mac_address, int *throughput);
7842 * @brief Enables / Disables automatic group removal feature when all peers are disconnected.
7845 * @privilege http://tizen.org/privilege/wifidirect
7846 * @param[in] enable Enables/Disables Group Removal feature based on the value TRUE/FALSE
7847 * @return @c 0 on success,
7848 * otherwise a negative error value
7849 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7850 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7851 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7852 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7853 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7854 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7855 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7856 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
7857 * @post wifi_direct_connection_state_changed_cb() will be invoked with
7858 * #WIFI_DIRECT_GROUP_DESTROYED when there's no connected Group Client
7859 * if device is Group Owner and this feature is enabled.
7860 * @see wifi_direct_activate()
7861 * @see wifi_direct_create_group()
7862 * @see wifi_direct_connection_state_changed_cb()
7865 * Here is an example of the usage:
7867 * #include <stdio.h>
7868 * #include <wifi_direct.h>
7871 * int function(void)
7875 * ret = wifi_direct_set_auto_group_removal(true); // Enable auto group removal
7877 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7878 * printf("Failed to set auto group removal\n");
7882 * printf("set auto group removal success\n");
7888 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7889 * wifi_direct_activate(); // Activate Wi-Fi Direct
7895 * // App must clean up Wi-Fi Direct before exiting
7897 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7898 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7903 int wifi_direct_set_auto_group_removal(bool enable);
7907 * @brief Sets the timer which is used to expire the connection session.
7910 * @privilege http://tizen.org/privilege/wifidirect
7911 * @param[in] seconds Set the connection session timer value in seconds
7912 * @return @c 0 on success,
7913 * otherwise a negative error value
7914 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7915 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7916 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7917 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7918 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7919 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7920 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7921 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7922 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7923 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
7924 * @see wifi_direct_activate()
7927 * Here is an example of the usage:
7929 * #include <stdio.h>
7930 * #include <wifi_direct.h>
7933 * int function(void)
7936 * int session_timeout;
7938 * printf("Input the time for session timer\n");
7939 * scanf("%2d", &session_timeout);
7941 * ret = wifi_direct_set_session_timer(session_timeout); // set session timer
7943 * if (ret != WIFI_DIRECT_ERROR_NONE) {
7944 * printf("Failed to set session timer\n");
7948 * printf("set session timer success\n");
7954 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
7955 * wifi_direct_activate(); // Activate Wi-Fi Direct
7961 * // App must clean up Wi-Fi Direct before exiting
7963 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
7964 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
7969 int wifi_direct_set_session_timer(int seconds);
7973 * @brief Gets the timer which is used to expire the connection session.
7976 * @privilege http://tizen.org/privilege/wifidirect
7977 * @param[out] seconds Connection session timer value
7978 * @return @c 0 on success,
7979 * otherwise a negative error value
7980 * @retval #WIFI_DIRECT_ERROR_NONE Successful
7981 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
7982 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
7983 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
7984 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
7985 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
7986 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
7987 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
7988 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
7989 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
7990 * @see wifi_direct_activate()
7993 * Here is an example of the usage:
7995 * #include <stdio.h>
7996 * #include <wifi_direct.h>
7999 * int function(void)
8002 * int session_timeout;
8004 * ret = wifi_direct_get_session_timer(&session_timeout); // get session timer
8006 * if (ret != WIFI_DIRECT_ERROR_NONE) {
8007 * printf("Failed to get session timer\n");
8011 * printf("session timer = %d\n", session_timeout);
8017 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
8018 * wifi_direct_activate(); // Activate Wi-Fi Direct
8024 * // App must clean up Wi-Fi Direct before exiting
8026 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
8027 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
8032 int wifi_direct_get_session_timer(int *seconds);
8036 * @brief Gets the information of a peer's RSSI value.
8039 * @privilege http://tizen.org/privilege/wifidirect
8040 * @param[in] mac_address MAC Address of the peer device
8041 * @param[out] rssi RSSI value of the peer device
8042 * @return @c 0 on success,
8043 * otherwise a negative error value
8044 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8045 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
8046 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8047 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8048 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8049 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8050 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8051 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8052 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8053 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
8054 * @see wifi_direct_activate()
8057 * Here is an example of the usage:
8059 * #include <stdio.h>
8060 * #include <wifi_direct.h>
8063 * int function(void)
8069 * printf("Input the peer mac\n");
8070 * scanf("%18ms", &mac);
8072 * ret = wifi_direct_get_peer_rssi(mac, &rssi); // get peer rssi
8074 * if (ret != WIFI_DIRECT_ERROR_NONE) {
8075 * printf("Failed to get peer rssi\n");
8079 * printf("peer rssi = %d\n", rssi);
8086 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
8087 * wifi_direct_activate(); // Activate Wi-Fi Direct
8093 * // App must clean up Wi-Fi Direct before exiting
8095 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
8096 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
8101 int wifi_direct_get_peer_rssi(char *mac_address, int *rssi);
8105 * @brief Adds the Wi-Fi Vendor Specific Information Element (VSIE) to specific frame type.
8108 * @privilege http://tizen.org/privilege/wifidirect
8109 * @remarks @a vsie_str for @a frame_id will be in effect until Wi-Fi Direct is deactivated.
8110 * @param[in] frame_id frame ID for setting VSIE
8111 * @param[in] vsie_str VSIE data
8112 * @return @c 0 on success,
8113 * otherwise a negative error value
8114 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8115 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
8116 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8117 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8118 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8119 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8120 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8121 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8122 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8123 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
8124 * @see wifi_direct_activate()
8125 * @see wifi_direct_remove_vsie()
8126 * @see wifi_direct_get_vsie()
8129 * Here is an example of the usage:
8131 * #include <stdio.h>
8132 * #include <wifi_direct.h>
8135 * int function(void)
8138 * char *vsie = NULL;
8139 * unsigned int frame_id;
8141 * printf("Input the frame id\n");
8142 * scanf("%2u", &frame_id);
8144 * printf("Input the vsie\n");
8145 * scanf("%100ms", &vsie);
8147 * ret = wifi_direct_add_vsie(frame_id, vsie); // add vsie
8149 * if (ret != WIFI_DIRECT_ERROR_NONE) {
8150 * printf("Failed to add vsie\n");
8154 * printf("vsie added success");
8161 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
8162 * wifi_direct_activate(); // Activate Wi-Fi Direct
8168 * // App must clean up Wi-Fi Direct before exiting
8170 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
8171 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
8176 int wifi_direct_add_vsie(wifi_direct_vsie_frames_e frame_id, const char *vsie_str);
8180 * @brief Gets the Wi-Fi Vendor Specific Information Elements (VSIE) from specific frame.
8183 * @privilege http://tizen.org/privilege/wifidirect
8184 * @remarks @a vsie_str must be released with free().
8185 * @param[in] frame_id frame ID for setting VSIE
8186 * @param[out] vsie_str VSIE data
8187 * @return @c 0 on success,
8188 * otherwise a negative error value
8189 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8190 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
8191 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8192 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8193 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8194 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8195 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8196 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8197 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8198 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate()
8199 * and set VSIE for specific frame by wifi_direct_add_vsie().
8200 * @see wifi_direct_activate()
8201 * @see wifi_direct_add_vsie()
8202 * @see wifi_direct_remove_vsie()
8205 * Here is an example of the usage:
8207 * #include <stdio.h>
8208 * #include <wifi_direct.h>
8211 * int function(void)
8214 * char *vsie = NULL;
8215 * unsigned int frame_id;
8217 * printf("Input the frame id\n");
8218 * scanf("%2u", &frame_id);
8220 * ret = wifi_direct_get_vsie(frame_id, &vsie); // get vsie
8222 * if (ret != WIFI_DIRECT_ERROR_NONE) {
8223 * printf("Failed to get vsie\n");
8227 * printf("vsie = %s\n", vsie);
8234 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
8235 * wifi_direct_activate(); // Activate Wi-Fi Direct
8241 * // App must clean up Wi-Fi Direct before exiting
8243 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
8244 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
8249 int wifi_direct_get_vsie(wifi_direct_vsie_frames_e frame_id, char **vsie_str);
8253 * @brief Removes the Wi-Fi Vendor Specific Information Element (VSIE) from specific frame.
8256 * @privilege http://tizen.org/privilege/wifidirect
8257 * @remarks @a vsie_str for @a frame_id will be in effect until Wi-Fi Direct is deactivated.
8258 * @param[in] frame_id frame ID for removing VSIE
8259 * @param[in] vsie_str VSIE data
8260 * @return @c 0 on success,
8261 * otherwise a negative error value
8262 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8263 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
8264 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8265 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8266 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8267 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8268 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8269 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8270 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8271 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate()
8272 * and set VSIE for specific frame by wifi_direct_add_vsie().
8273 * @see wifi_direct_activate()
8274 * @see wifi_direct_add_vsie()
8275 * @see wifi_direct_get_vsie()
8278 * Here is an example of the usage:
8280 * #include <stdio.h>
8281 * #include <wifi_direct.h>
8284 * int function(void)
8287 * char *vsie = NULL;
8288 * unsigned int frame_id;
8290 * printf("Input the frame id\n");
8291 * scanf("%2u", &frame_id);
8293 * printf("Input the vsie\n");
8294 * scanf("%100ms", &vsie);
8296 * ret = wifi_direct_remove_vsie(frame_id, vsie); // remove vsie
8298 * if (ret != WIFI_DIRECT_ERROR_NONE) {
8299 * printf("Failed to remove vsie\n");
8303 * printf("vsie removed success\n");
8310 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
8311 * wifi_direct_activate(); // Activate Wi-Fi Direct
8317 * // App must clean up Wi-Fi Direct before exiting
8319 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
8320 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
8325 int wifi_direct_remove_vsie(wifi_direct_vsie_frames_e frame_id, const char *vsie_str);
8329 * @brief Gets the information of peer devices which is in the connecting state.
8332 * @privilege http://tizen.org/privilege/wifidirect
8333 * @remarks @a peer_info must be released with free().
8334 * @param[out] peer_info connecting peer device data
8335 * @return @c 0 on success,
8336 * otherwise a negative error value
8337 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8338 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
8339 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8340 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8341 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8342 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8343 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8344 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8345 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8346 * @pre Wi-Fi Direct service must be connecting state by wifi_direct_connect()
8347 * or by receiving connection request from p2p peer device.
8348 * @see wifi_direct_activate()
8349 * @see wifi_direct_connect()
8352 * Here is an example of the usage:
8354 * #include <stdio.h>
8355 * #include <wifi_direct.h>
8358 * bool device_selected = false;
8360 * void peers_cb(wifi_direct_discovered_peer_info_s* peer,
8363 * if (peer && !device_selected) {
8364 * printf("peer device=%s MAC=%s\n", peer->device_name, peer->mac_address);
8366 * device_selected = true;
8368 * wifi_direct_connect(peer->mac_address); // Connect to the first discovered peer
8372 * int function(void)
8375 * wifi_direct_discovered_peer_info_s *peer = NULL;
8377 * ret = wifi_direct_get_connecting_peer_info(&peer);
8379 * if (ret != WIFI_DIRECT_ERROR_NONE) {
8380 * printf("Failed to get connecting peer info\n");
8384 * printf("peer device name (%s) mac (%s)\n", peer->device_name,
8385 * peer->mac_address);
8389 * void callback_2(int error_code,
8390 * wifi_direct_connection_state_e state,
8391 * const char *mac, void *user_data)
8394 * case WIFI_DIRECT_CONNECTION_IN_PROGRESS:
8395 * printf("Connection in progress\n");
8397 * function(); // get the connecting peer info
8401 * case WIFI_DIRECT_CONNECTON_RSP:
8402 * printf("Connected\n");
8405 * case WIFI_DIRECT_DISCONNECTION_IND:
8406 * printf("Disconnection IND\n");
8409 * case WIFI_DIRECT_DISCONNECTION_RSP;
8410 * printf("Disconnected\n");
8415 * void callback_1(int error_code,
8416 * wifi_direct_discovery_state_e discovery_state,
8419 * switch(discovery_state) {
8420 * case WIFI_DIRECT_DISCOVERY_STARTED:
8421 * printf("Discovery started\n");
8424 * case WIFI_DIRECT_ONLY_LISTEN_STARTED:
8425 * printf("listen started\n");
8428 * case WIFI_DIRECT_DISCOVERY_FINISHED:
8429 * printf("Discovery finished\n");
8431 * wifi_direct_foreach_discovered_peers(peers_cb,
8432 * NULL); // Get discovered peer
8435 * case WIFI_DIRECT_DISCOVERY_FOUND:
8436 * printf("peer devices found\n");
8439 * case WIFI_DIRECT_DISCOVERY_LOST:
8440 * printf("Discovery lost\n");
8450 * wifi_direct_initialize(); // Initialize Wi-Fi Direct
8451 * wifi_direct_set_discovery_state_changed_cb(callback_1, NULL); // Register callback 1
8452 * wifi_direct_set_connection_state_changed_cb(callback_2, NULL); // Register callback 2
8454 * wifi_direct_activate(); // Activate Wi-Fi Direct
8455 * wifi_direct_start_discovery(TRUE, 15); // Start discovery
8459 * // App must clean up Wi-Fi Direct before exiting
8461 * wifi_direct_deactivate(); // Deactivate Wi-Fi Direct
8462 * wifi_direct_unset_discovery_state_changed_cb(); // Deregister callback
8463 * wifi_direct_deinitialize(); // Deinitialize Wi-Fi Direct
8468 int wifi_direct_get_connecting_peer_info(wifi_direct_discovered_peer_info_s **peer_info);
8471 * @brief Gets the vendor specific information element (VSIE) of a peer.
8474 * @privilege http://tizen.org/privilege/wifidirect
8475 * @remarks @a vsie must be released with free().
8476 * @param[in] mac_address MAC Address of the PEER
8477 * @param[out] vsie The vendor specific information element (VSIE) of peer
8478 * if Wi-Fi Direct information is available, else it will be NULL.
8479 * @return @c 0 on success,
8480 * otherwise a negative error value
8481 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8482 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
8483 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8484 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8485 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8486 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8487 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8488 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8489 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8490 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
8491 * @see wifi_direct_activate()
8492 * @see wifi_direct_foreach_discovered_peers()
8494 int wifi_direct_get_peer_vsie(char *mac_address, char **vsie);
8497 * @brief Sets the advertizing WPS (Wi-Fi Protected Setup) type.
8500 * @privilege http://tizen.org/privilege/wifidirect
8501 * @param[in] type The type of WPS. composition of #wifi_direct_config_method_type_e
8502 * for example #WIFI_DIRECT_CONFIG_METHOD_PBC|#WIFI_DIRECT_CONFIG_METHOD_PIN_DISPLAY
8503 * Use #WIFI_DIRECT_CONFIG_METHOD_DEFAULT to reset to default value
8504 * @return 0 on success, otherwise a negative error value
8505 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8506 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
8507 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8508 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8509 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8510 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8511 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8512 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8513 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8514 * @pre Wi-Fi Direct service must be initialized by wifi_direct_activate().
8515 * @see wifi_direct_initialize()
8517 int wifi_direct_set_wps_config_method(int type);
8520 * @brief Gets the advertizing WPS (Wi-Fi Protected Setup) type.
8523 * @privilege http://tizen.org/privilege/wifidirect
8524 * @param[out] type The type of WPS. composition of #wifi_direct_config_method_type_e
8525 * @return 0 on success, otherwise a negative error value
8526 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8527 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
8528 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8529 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8530 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8531 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8532 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8533 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8534 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8535 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
8536 * @pre Wi-Fi Direct service must be activated by wifi_direct_activate().
8537 * @see wifi_direct_initialize()
8539 int wifi_direct_get_wps_config_method(int *type);
8542 * @brief Removes a persistent device.
8545 * @privilege http://tizen.org/privilege/wifidirect
8546 * @param[in] mac_address The MAC address of the persistent group owner
8547 * @return 0 on success, otherwise a negative error value
8548 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8549 * @retval #WIFI_DIRECT_ERROR_INVALID_PARAMETER Invalid parameter
8550 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8551 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8552 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8553 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8554 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8555 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8556 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8557 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
8558 * @see wifi_direct_initialize()
8560 int wifi_direct_remove_persistent_device(char *mac_address);
8563 * @brief Removes all persistent devices.
8566 * @privilege http://tizen.org/privilege/wifidirect
8567 * @return 0 on success, otherwise a negative error value
8568 * @retval #WIFI_DIRECT_ERROR_NONE Successful
8569 * @retval #WIFI_DIRECT_ERROR_OPERATION_FAILED Operation failed
8570 * @retval #WIFI_DIRECT_ERROR_COMMUNICATION_FAILED Communication failed
8571 * @retval #WIFI_DIRECT_ERROR_PERMISSION_DENIED Permission denied
8572 * @retval #WIFI_DIRECT_ERROR_NOT_PERMITTED Operation not permitted
8573 * @retval #WIFI_DIRECT_ERROR_NOT_SUPPORTED Not supported
8574 * @retval #WIFI_DIRECT_ERROR_NOT_INITIALIZED Not initialized
8575 * @retval #WIFI_DIRECT_ERROR_RESOURCE_BUSY Device or resource busy
8576 * @pre Wi-Fi Direct service must be initialized by wifi_direct_initialize().
8577 * @see wifi_direct_initialize()
8579 int wifi_direct_remove_all_persistent_devices(void);
8588 #endif /* __TIZEN_NET_WIFI_DIRECT_H__ */