restriction.h

/*
 * Copyright (c) 2000-2017 Samsung Electronics Co., Ltd All Rights Reserved
 *
 * PROPRIETARY/CONFIDENTIAL
 *
 * This software is the confidential and proprietary information of
 * SAMSUNG ELECTRONICS ("Confidential Information").
 * You shall not disclose such Confidential Information and shall
 * use it only in accordance with the terms of the license agreement
 * you entered into with SAMSUNG ELECTRONICS.
 * SAMSUNG make no representations or warranties about the suitability
 * of the software, either express or implied, including but not
 * limited to the implied warranties of merchantability, fitness for
 * a particular purpose, or non-infringement.
 * SAMSUNG shall not be liable for any damages suffered by licensee as
 * a result of using, modifying or distributing this software or its derivatives.
 */

#ifndef LIBMDM_MDM_RESTRICTION_H
#define LIBMDM_MDM_RESTRICTION_H

#include <stdbool.h>
#include "mdm_client_type.h"

#ifdef __cplusplus
extern "C" {
#endif


typedef enum {
    MDM_POLICY_LOC_SETTING_NETWORK = 0x10, 
    MDM_POLICY_LOC_SETTING_GPS     = 0x20  
} status_t;

typedef enum {
    MDM_POLICY_LOC_NOTI_ALLOW      = 0x00, 
    MDM_POLICY_LOC_NOTI_RESTRICTED = 0x01  
} noti_t;

typedef enum {
    KNOX_MDM_NOTIFICATION_ANY         = 0, 
    KNOX_MDM_NOTIFICATION_POPUP       = 1, 
    KNOX_MDM_NOTIFICATION_BADGES      = 2, 
    KNOX_MDM_NOTIFICATION_LOCK_SCREEN = 3, 
    KNOX_MDM_NOTIFICATION_EXTERNAL    = 4  
} knox_mdm_notification_type_e;

typedef enum {
    KNOX_MDM_NOTIFICATION_LEVEL_ALL_CONTENT       = 1, 
    KNOX_MDM_NOTIFICATION_LEVEL_NO_SENSITIVE_DATA = 2, 
    KNOX_MDM_NOTIFICATION_LEVEL_ALL_HIDE          = 3, 
} knox_mdm_notification_level_e;

typedef struct {
    char *                        package_name; 
    knox_mdm_notification_type_e  type;         
    knox_mdm_notification_level_e level;        
} knox_mdm_notification_item;

typedef enum {
    KNOX_MDM_POWER_SAVING_MODE_NORMAL = 0, 
    KNOX_MDM_POWER_SAVING_MODE_ULTRA,      
    KNOX_MDM_POWER_SAVING_MODE_LAST        
} knox_mdm_power_saving_mode_t;

mdm_data_t *mdm_get_all_location_providers(void);

mdm_result_t mdm_get_location_provider_state(char *p_provider, mdm_status_t *p_status);

mdm_result_t mdm_set_location_provider_state(const char *p_provider, mdm_status_t enable);

/*
 * @brief API to check whether background data is enabled or not.
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether background usage of data is allowed or not. The default value is true..
 * @code{.c}
    mdm_status_t status = mdm_get_allow_background_data();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_background_data
 *
 */
mdm_status_t mdm_get_allow_background_data(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to check whether the backup is enabled or not.
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin could check whether backup is allowed or not.The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_backup();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_backup
 *
 */
mdm_status_t mdm_get_allow_backup(void);

mdm_status_t mdm_get_allow_bluetooth_tethering(void);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_status_t mdm_get_allow_cellular_data(void);

/*
 * @brief API to check whether clipboard is enabled or not
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether cut, copy, paste operation is allowed or not. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_clipboard();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_clipboard
 *
 */
mdm_status_t mdm_get_allow_clipboard(void);

mdm_status_t mdm_get_allow_factory_reset(void);

#ifndef MDM_FOR_SOLIS_PROF

mdm_status_t mdm_get_allow_home_key(void);

/*
 * @brief API to check whether the microphone capability is enabled or not
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether Microphone capability is enabled or not and take appropriate action based on enterprise
 policy. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_mock_location();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_mock_location
 *
 */
mdm_status_t mdm_get_allow_mock_location(void);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_status_t mdm_get_allow_nfc(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to check if non-market application installation is allowed or not allowed
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether non-market application installation is allowed on device or not. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_nonmarket_app();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_nonmarket_app
 *
 */
mdm_status_t mdm_get_allow_nonmarket_app(void);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_status_t mdm_get_allow_screen_capture(void);

mdm_status_t mdm_get_allow_settings_changes(void);

mdm_status_t mdm_get_allow_usb_debugging(void);

/*
 * @brief API to check if the end user is allowed to change the USB debugging state.
 *
 * @since_mdm 2.2.0
 *
 * @since_tizen 3.0.0.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Use this API to check if end users are allowed to access developer mode (USB debugging) on the device.
 *
 * @code{.c}
    mdm_status_t status = knox_mdm_get_allow_usb_debugging_change();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @retval #MDM_RESTRICTED    End users are blocked from changing the USB debugging state.
 * @retval #MDM_ALLOWED       End users are allowed to change the USB debugging state.
 * @retval #MDM_STATUS_ERROR  general error
 *
 * @see knox_mdm_set_allow_usb_debugging_change
 */
mdm_status_t knox_mdm_get_allow_usb_debugging_change(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to check whether Samsung USB Kies is enabled or not
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether device detection from Samsung Kies is allowed or not. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_usb_kies();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_usb_kies_availability
 *
 */
mdm_status_t mdm_get_allow_usb_kies(void);

/*
 * @brief API to check whether the USB Mass Storage is enabled or not
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin could can check that whether device can act as USB mass storage or not. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_usb_mass_storage();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_usb_mass_storage
 *
 */
mdm_status_t mdm_get_allow_usb_mass_storage(void);

#endif /* MDM_FOR_SOLIS_PROF */

/*
 * @brief API to check whether USB media player is enabled or not
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether USB media player is allowed or not. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_usb_media_player();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_usb_media_player_availability
 *
 */
mdm_status_t mdm_get_allow_usb_media_player(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to check whether USB tethering is enabled or not
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether the device can share its network data via USB or not. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_usb_tethering();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_usb_tethering
 *
 */
mdm_status_t mdm_get_allow_usb_tethering(void);

/*
 * @brief API to check whether Wi-Fi tethering is enabled or not
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether device can share its network data via Wi-Fi or not. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_wifi_tethering();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_wifi_tethering
 *
 */
mdm_status_t mdm_get_allow_wifi_tethering(void);

/*
 * @brief API to check if native VPN functionality is allowed or disallowed
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether user can use native VPN functionality on device or not. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_vpn();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_vpn
 *
 */
mdm_status_t mdm_get_allow_vpn(void);

/*
 * @brief API to check whether the USB Host Storage is enabled or not
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check whether the device can act as USB host storage or not. The default value is true.
 * @code{.c}
    mdm_status_t status = mdm_get_allow_usb_host_storage();
    if (status == MDM_STATUS_ERROR) {
        // function error
    } else {
        // function success
        printf ("status: %d", status);
    }
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see mdm_set_allow_usb_host_storage
 *
 */
mdm_status_t mdm_get_allow_usb_host_storage(void);

/*
 * @brief API to allow or disallow installation of non market application on device
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin could set this policy to disallow installation of non market application on device.
 * If it set to false,non market application functionality will be disabled and user will not be able to turn it on
 until the admin enables it again.
 * If it set to true, non market application UI control will be enabled. Enable won't really enable the functionality,
 it just enables corresponding UI setting for user change
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_nonmarket_apps(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]   value
 *                  #MDM_ALLOWED        = 0,
 *                  #MDM_RESTRICTED     = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_nonmarket_apps
 *
 */
mdm_result_t mdm_set_allow_nonmarket_apps(mdm_status_t value);

#endif /* MDM_FOR_SOLIS_PROF */

/*
 * @brief API to enable or disable background data
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this policy to disallow any background data usage.
 * This action blocks any kind of syncing to a server. If it is set to false,
 * background data functionality will be disabled and user will not be able to turn it on until the admin enables it again.
 * If it set to true, background data UI control will be enabled.
 * Enable won't really enable the functionality, it just enables corresponding UI setting for user change.
 *
 * @remark
 * Background data restriction #mdm_status_t is written to #MDM_POLICY_ON_BG_SYNC notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_background_data(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]   value
 *                  #MDM_ALLOWED        = 0,
 *                  #MDM_RESTRICTED     = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_background_data
 *
 */
mdm_result_t mdm_set_allow_background_data(mdm_status_t value);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to enable or disable the backup
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this policy to disallow backup. User will not be allowed to backup his data on the server
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_backup(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       value
 *                      #MDM_ALLOWED    = 0,
 *                      #MDM_RESTRICTED = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_backup
 *
 */
mdm_result_t mdm_set_allow_backup(mdm_status_t value);

mdm_result_t mdm_set_allow_bluetooth_tethering(mdm_status_t value);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_result_t mdm_set_allow_cellular_data(mdm_status_t value);

#ifndef MDM_FOR_SOLIS_PROF

mdm_result_t mdm_set_allow_clipboard(mdm_status_t value);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_result_t mdm_set_allow_factory_reset(mdm_status_t value);

#ifndef MDM_FOR_SOLIS_PROF

mdm_result_t mdm_set_allow_home_key(mdm_status_t value);

/*
 * @brief API to enable or disable mock locations
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin could set this policy to mock its location. If set to true, the device can change its actual longtitude and
 latitude of the device and GPS applications will show the fake location set instead of actual location
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_mock_location(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       value
 *                      MDM_ALLOWED     = 0,
 *                      MDM_RESTRICTED  = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_mock_location
 *
 */
mdm_result_t mdm_set_allow_mock_location(mdm_status_t value);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_result_t mdm_set_allow_nfc(mdm_status_t value);

mdm_result_t mdm_set_allow_screen_capture(mdm_status_t value);

mdm_result_t mdm_set_allow_settings_changes(mdm_status_t value);

mdm_result_t mdm_set_allow_usb_debugging(mdm_status_t value);

/*
 * @brief API to allow the end users to make changes to the USB debugging state.
 *
 * @since_mdm 2.2.0
 *
 * @since_tizen 3.0.0.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Use this API to allow or restrict end users from enabling developer mode (USB debugging).
 * Restricting access to USB debugging prevents the extraction of vital information (eg. Logs) from the device.
 *
 * @remark
 * Restriction of changing USB debugging state #mdm_status_t is written to #MDM_POLICY_ON_USB_DEBUGGING_CHANGE notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @code{.c}
    mdm_result_t ret = knox_mdm_set_allow_usb_debugging_change(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]   status #MDM_ALLOWED  – Allows the end user to change the USB debugging state.
 *                  \n #MDM_RESTRICTED – Restricts the end user from changing the USB debugging state.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS upon successful configuration of end user permission to access USB debugging, or an error
 code from the values listed below upon failure.
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application doesn’t have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see knox_mdm_get_allow_usb_debugging_change
 */
mdm_result_t knox_mdm_set_allow_usb_debugging_change(mdm_status_t status);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to enable or disable Samsung Kies
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin could set this policy to disallow device detection from Samsung Kies
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_usb_kies_availability(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @remark
 * Samsung Kies restriction #mdm_status_t is written to #MDM_POLICY_ON_USB_KIES notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       value
 *                      MDM_ALLOWED     = 0,
 *                      MDM_RESTRICTED  = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_usb_kies
 *
 */
mdm_result_t mdm_set_allow_usb_kies_availability(mdm_status_t value);

/*
 * @brief API to enable or disable the USB Mass Storage
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin could set this policy to block USB access. This will block any kind of browsing device directory through sdb.
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_usb_mass_storage(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       value
 *                      MDM_ALLOWED     = 0,
 *                      MDM_RESTRICTED  = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_usb_mass_storage
 *
 */
mdm_result_t mdm_set_allow_usb_mass_storage(mdm_status_t value);

#endif /* MDM_FOR_SOLIS_PROF */

/*
 * @brief API to enable or disable USB media player
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this policy to disallow USB media player for device
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_usb_media_player_availability(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @remark
 * USB media player restriction #mdm_status_t is written to #MDM_POLICY_ON_MTP notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       value
 *                      MDM_ALLOWED     = 0,
 *                      MDM_RESTRICTED  = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_usb_media_player
 *
 */
mdm_result_t mdm_set_allow_usb_media_player_availability(mdm_status_t value);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to enable or disable USB tethering
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this policy to prevents the device from being able to share its carrier data connection with other
 * devices around it through USB connection.
 * If it set to false,USB tethering functionality will be disabled
 * and user will not be able to turn it on until the admin enables it again.
 * If it set to true, USB tethering UI control will be enabled.
 * Enable won't really enable the functionality and it just enables corresponding UI setting for user change
 *
 * @remark
 * USB tethering restriction #mdm_status_t is written to #MDM_POLICY_ON_USB_TETHERING notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_usb_tethering(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       value
 *                      MDM_ALLOWED     = 0,
 *                      MDM_RESTRICTED  = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_usb_tethering
 *
 */
mdm_result_t mdm_set_allow_usb_tethering(mdm_status_t value);

/*
 * @brief API to enable or disable Wi-Fi tethering
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this policy to prevents the device from being able to share its carrier data connection with other
 devices around it through Wi-Fi.
 * If it set to false, Wi-Fi tethering functionality will be disabled and user will not be able to turn it on until the
 admin enables it again.
 * If it set to true, Wi-Fi tethering UI control will be enabled. Enable won't really enable the functionality and it
 just enables corresponding UI setting for user change
 *
 * @remark
 * Restriction of WiFi tethering #wifi_noti_t is written to #MDM_POLICY_ON_WIFI_TETHERING notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_wifi_tethering(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       value
 *                      MDM_ALLOWED     = 0,
 *                      MDM_RESTRICTED  = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_wifi_tethering
 *
 */
mdm_result_t mdm_set_allow_wifi_tethering(mdm_status_t value);

/*
 * @brief API to allow or disallow the user ability to use native VPN functionality
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this policy to disallow native VPN functionality on the device.
 * If set to false, user will not be able establish VPN sessions and the UI for using VPN through Settings application
 will be in accessible
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_vpn(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       value
 *                      MDM_ALLOWED     = 0,
 *                      MDM_RESTRICTED  = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_vpn
 *
 */
mdm_result_t mdm_set_allow_vpn(mdm_status_t value);

/*
 * @brief API to enable or disable the USB Host Storage
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @par Usage:
 * Admin can set this policy to block USB host access. This will block any kind of browsing device directory through
 sdb.
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @code{.c}
    mdm_result_t ret = mdm_set_allow_usb_host_storage(MDM_RESTRICTED);
    if (ret != MDM_RESULT_SUCCESS) {
        // function error
    } else {
        // function success
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       value
 *                      MDM_ALLOWED     = 0,
 *                      MDM_RESTRICTED  = 1,
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_allow_usb_host_storage
 *
 */
mdm_result_t mdm_set_allow_usb_host_storage(mdm_status_t value);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_status_t mdm_is_firmware_recovery_allowed(void);

mdm_result_t mdm_allow_firmware_recovery(bool enabled);

mdm_status_t mdm_is_power_off_allowed(void);

mdm_result_t mdm_allow_power_off(bool enabled);

#ifndef MDM_FOR_SOLIS_PROF

mdm_status_t mdm_is_stop_system_app_allowed(void);

mdm_result_t mdm_allow_stop_system_app(bool enabled);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_status_t mdm_get_allow_license_activation(void);

mdm_result_t mdm_set_allow_license_activation(mdm_status_t is_blocked);

mdm_result_t knox_mdm_set_allow_firmware_update(mdm_status_t value);

mdm_status_t knox_mdm_get_allow_firmware_update(void);

/*
 * This is deprecated function. DO NOT USE THEM!!!
 * Left for compatibility reason
 */
mdm_status_t mdm_get_allow_firmware_update(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to get the enabled or disabled state of a given default restriction policy
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to get the enabled or disabled state of a pre-condition policies. Currently available policies
 are sdb and app_mgr.
 * @code{.c}
    mdm_status_t state = 0;
    mdm_result_t ret = mdm_get_default_restriction("app_mgr", &state);
    if (ret != MDM_RESULT_SUCCESS) {
        // failed getting policy state
    } else {
        // success getting policy state
        printf ("state: %d", state);
    }
 *
 * @endcode
 *
 * @param[in]       target      The case sensitive default restriction name. Sample values are sdb, app_mgr.
 * @param[in]       p_status    Get information of location.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see mdm_set_default_restriction
 *
 */
mdm_result_t mdm_get_default_restriction(const char *target, mdm_status_t *p_status);

/*
 * @brief API to enable or disable a given default restriction policy
 *
 * @since_mdm 1.0.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can use this API to enable or disable a default restriction policy.
 * If it set to RESTRICTED, relevant functionality will be disabled and user will not be able to access until the admin
 enables it again.
 * if it set to ALLOWED, relevant functionality will be enabled.
 * Currently avaiable policies are sdb and app_mgr.
 * @code{.c}
    mdm_result_t ret = mdm_set_default_restriction(MDM_RESTRICTED, "app_mgr");
    if (ret != MDM_RESULT_SUCCESS) {
        // failed
    } else {
        // success
        printf ("state: %d", state);
    }
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in]       enable  True to enable the location provider, false to disable the provider
 * @param[in]       target  The case sensitive default restriction name. Sample values are sdb, app_mgr.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see mdm_get_location_provider_state
 *
 */
mdm_result_t mdm_set_default_restriction(mdm_status_t enabled, const char *target);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_result_t knox_mdm_add_notification_white_list(const char *                        package_name,
                                                  const knox_mdm_notification_type_e  noti_type,
                                                  const knox_mdm_notification_level_e noti_level);

mdm_result_t knox_mdm_delete_notification_white_list(const char *package_name, const knox_mdm_notification_type_e type);

mdm_result_t knox_mdm_clear_notification_white_list(void);

mdm_data_t *knox_mdm_get_notification_white_list(bool all_admin);

mdm_result_t knox_mdm_add_notification_black_list(const char *package_name, const knox_mdm_notification_type_e type,
                                                  const knox_mdm_notification_level_e level);

mdm_result_t knox_mdm_delete_notification_black_list(const char *package_name, const knox_mdm_notification_type_e type);

mdm_result_t knox_mdm_clear_notification_black_list(void);

mdm_data_t *knox_mdm_get_notification_black_list(bool all_admin);

mdm_result_t knox_mdm_set_allow_power_saving_mode(knox_mdm_power_saving_mode_t mode, mdm_status_t allow);

mdm_status_t knox_mdm_get_allow_power_saving_mode(knox_mdm_power_saving_mode_t mode);

/*
 * @brief API to set the end users' permission to change power saving mode.
 *
 * @since_mdm 2.2.0
 *
 * @since_tizen 3.0.0.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * The admin could set this policy to block the end user from changing power saving mode:
 * \n • If set to MDM_RESTRICTED, the end user isn’t allowed to change power saving mode.
 * \n • If it set to MDM_ALLOWED, the end user is allowed to change power saving mode.
 * By default all power saving modes are allowed. When power saving mode change is restricted,
 * the end user will be unable to enter any power saving mode other than what they are currently on.
 * The end user will also be unable to exit power saving mote.
 * \n\n Note — this API takes priority over knox_mdm_set_allow_power_saving_mode.
 *
 * @remark
 * Restriction of changing power saving mode #mdm_status_t is written to #MDM_POLICY_ON_POWER_SAVING_MODE notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @code{.c}
    mdm_result_t ret = mdm_get_service();

    if ( ret == MDM_RESULT_SUCCESS) {
        ret = knox_mdm_set_allow_power_saving_mode_change(MDM_RESTRICTED);

        if (ret == MDM_RESULT_SUCCESS) {
            // function success
        } else {
            // function error
        }
    }
    mdm_release_service();
 *
 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @param[in] allow When set to #MDM_ALLOWED, specified power saving mode is allowed. When set to #MDM_RESTRICTED
 *                  specified power saving mode is disabled.
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @par Permission:
 * Usage of this API is restricted to registered clients only.
 *
 * @see knox_mdm_get_allow_power_saving_mode, knox_mdm_set_allow_power_saving_mode,
        knox_mdm_get_allow_power_saving_mode_change
 */
mdm_result_t knox_mdm_set_allow_power_saving_mode_change(mdm_status_t allow);

/*
 * @brief API to check if the end user has permission to change power saving mode.
 *
 * @since_mdm 2.2.0
 *
 * @since_tizen 3.0.0.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Use this API to check if end users can change power saving mode or not. The default value is allowed.
 *
 * @code{.c}
    mdm_result_t ret = mdm_get_service();

    if ( ret == MDM_RESULT_SUCCESS) {
        mdm_status_t status = knox_mdm_get_allow_power_saving_mode_change();
        if (status == MDM_STATUS_ERROR) {
            // function error
        } else {
            // function success
            if ( status == MDM_ALLOWED ) {
                // power saving mode change is allowed
            } else {
                // power saving mode change is restricted
            }
        }
    }
    mdm_release_service();
 *
 * @endcode
 *
 * @return #mdm_status_t : Current mode of operation: one of #MDM_ALLOWED or #MDM_RESTRICTED
 *
 * @see knox_mdm_set_allow_power_saving_mode, knox_mdm_set_allow_power_saving_mode_change,
        knox_mdm_get_allow_power_saving_mode
 *
 */
mdm_status_t knox_mdm_get_allow_power_saving_mode_change(void);

/*
 * @brief Function blocks end users from changing airplane mode settings.
 *
 * @since_mdm 2.2.0
 *
 * @since_tizen 3.0.0.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * The admin can use this API to block end users from modifying data airplane mode settings.
 *
 * @remark
 * Changing airplane mode restriction is written to #MDM_POLICY_ON_AIRPLANE_CHANGE notification file.
 * You can register a callback for this event using #mdm_register_policy_receiver.
 *
 * @code{.c}
    mdm_result_t result = knox_mdm_set_allow_airplane_mode_change(MDM_RESTRICTED);
    if(result == MDM_RESULT_SUCCESS) {
        // Success
        ...
    } else {
        // Error
        ...
    }
 * @endcode
 *
 * @param[in] status #MDM_RESTRICTED blocks end users from modifying airplane mode settings.
 *                \n #MDM_ALLOWED allows end users to modify airplane mode settings.
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.restriction
 *
 * @return #mdm_result_t : MDM_RESULT_SUCCESS on success, an error code on error
 *
 * @retval #MDM_RESULT_SUCCESS Successful
 * @retval #MDM_RESULT_FAIL General failure
 * @retval #MDM_RESULT_NOT_SUPPORTED Not supported
 * @retval #MDM_RESULT_INVALID_PARAM Invalid parameter
 * @retval #MDM_RESULT_ACCESS_DENIED The application does not have the privilege to call this function.
 *
 * @see knox_mdm_get_allow_airplane_mode_change
 */
mdm_result_t knox_mdm_set_allow_airplane_mode_change(const mdm_status_t status);

/*
 * @brief Function to check if the end user is allowed to make changes to airplane mode settings.
 *
 * @since_mdm 2.2.0
 *
 * @since_tizen 3.0.0.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Use this API to check if the end user is allowed to modify airplane mode settings.
 *
 * @code{.c}
    mdm_status_t status = knox_mdm_get_allow_airplane_mode_change();
    if(result == MDM_RESTRICTED) {
        // Changes are blocked
        ...
    } else if(result == MDM_ALLOWED) {
        // Changes are allowed
        ...
    }
    else
    {
        // ERROR
        ...
    }
 * @endcode
 *
 * @return #mdm_status_t : The current prevention status.
 *
 * @retval #MDM_RESTRICTED      The end user is restricted from modifying airplane mode settings.
 * @retval #MDM_ALLOWED         The end user is allowed to modify airplane mode settings.
 * @retval #MDM_STATUS_ERROR    On any error.
 *
 * @see knox_mdm_set_allow_airplane_mode_change
 */
mdm_status_t knox_mdm_get_allow_airplane_mode_change(void);

mdm_result_t knox_mdm_set_allow_airplane_mode(const mdm_status_t status);

mdm_status_t knox_mdm_get_allow_airplane_mode(void);

#ifdef __cplusplus
}
#endif

#endif //LIBMDM_MDM_RESTRICTION_H