device_inventory.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_DEVICE_INVENTORY_H
#define LIBMDM_MDM_DEVICE_INVENTORY_H

#include "mdm_client_type.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef enum {
    MDM_SIM_STATUS_ERROR              = -1,   
    MDM_SIM_STATUS_CARD_ERROR         = 0x00, 
    MDM_SIM_STATUS_CARD_NOT_PRESENT   = 0x01, 
    MDM_SIM_STATUS_SIM_INITIALIZING   = 0x02, 
    MDM_SIM_STATUS_SIM_INIT_COMPLETED = 0x03, 
    MDM_SIM_STATUS_SIM_PIN_REQUIRED   = 0x04, 
    MDM_SIM_STATUS_SIM_PUK_REQUIRED   = 0x05, 
    MDM_SIM_STATUS_CARD_BLOCKED =
        0x06, 
    MDM_SIM_STATUS_SIM_NCK_REQUIRED  = 0x07, 
    MDM_SIM_STATUS_SIM_NSCK_REQUIRED = 0x08, 
    MDM_SIM_STATUS_SIM_SPCK_REQUIRED = 0x09, 
    MDM_SIM_STATUS_SIM_CCK_REQUIRED  = 0x0a, 
    MDM_SIM_STATUS_CARD_REMOVED      = 0x0b, 
    MDM_SIM_STATUS_SIM_LOCK_REQUIRED = 0x0c  
} mdm_sim_status_t;

typedef enum {
    MDM_NETWORK_SERVICE_ERR = -1,             
    MDM_NETWORK_SERVICE_NO_SRV,               
    MDM_NETWORK_SERVICE_GSM,                  
    MDM_NETWORK_SERVICE_GPRS,                 
    MDM_NETWORK_SERVICE_EGPRS,                
    MDM_NETWORK_SERVICE_PCS1900,              
    MDM_NETWORK_SERVICE_UMTS,                 
    MDM_NETWORK_SERVICE_GSM_AND_UMTS,         
    MDM_NETWORK_SERVICE_HSDPA,                
    MDM_NETWORK_SERVICE_IS95A,                
    MDM_NETWORK_SERVICE_IS95B,                
    MDM_NETWORK_SERVICE_CDMA_1X,              
    MDM_NETWORK_SERVICE_EVDO_REV_0,           
    MDM_NETWORK_SERVICE_1X_EVDO_REV_0_HYBRID, 
    MDM_NETWORK_SERVICE_EVDO_REV_A,           
    MDM_NETWORK_SERVICE_1X_EVDO_REV_A_HYBRID, 
    MDM_NETWORK_SERVICE_EVDO_REV_B,           
    MDM_NETWORK_SERVICE_1X_EVDO_REV_B_HYBRID, 
    MDM_NETWORK_SERVICE_EVDV,                 
    MDM_NETWORK_SERVICE_EHRPD,                
    MDM_NETWORK_SERVICE_LTE                   
} mdm_network_service_type_t;

#ifndef MDM_FOR_SOLIS_PROF

typedef enum mdm_sort_order_e {
    MDM_SORT_ORDER_ASCENDING = 0, 
    MDM_SORT_ORDER_DESCENDING     
} mdm_sort_order_t;

typedef enum mdm_history_parameter_e {
    MDM_HISTORY_PARAMETER_EVENT_START_DATE = 0,

    MDM_HISTORY_PARAMETER_EVENT_END_DATE,

    MDM_HISTORY_PARAMETER_EVENT_START_RECORD_ID,

    MDM_HISTORY_PARAMETER_EVENT_END_RECORD_ID,

    MDM_HISTORY_PARAMETER_EVENT_DIRECTION,

    MDM_HISTORY_PARAMETER_EVENT_DESTINATION_NUMBER,

    MDM_HISTORY_PARAMETER_EVENT_SLOT_ID,

    MDM_HISTORY_PARAMETER_EVENT_ROAMING_STATUS,
    MDM_HISTORY_PARAMETER_EVENT_TYPE,

    MDM_HISTORY_PARAMETER_EVENT_LAST
} mdm_history_parameter_t;

typedef enum mdm_direction_e {
    MDM_DIRECTION_INCOMING = 0, 
    MDM_DIRECTION_OUTGOING,     
} mdm_direction_t;

typedef enum mdm_roaming_status_e {
    MDM_ROAMING_STATUS_NOT_ACTIVE = 0, 
    MDM_ROAMING_STATUS_ACTIVE,         
} mdm_roaming_status_t;

typedef enum mdm_history_event_type_e {
    MDM_HISTORY_EVENT_TYPE_UNKNOWN = 0, 
    MDM_HISTORY_EVENT_TYPE_CALL,        
    MDM_HISTORY_EVENT_TYPE_SMS,         
    MDM_HISTORY_EVENT_TYPE_LAST         
} mdm_history_event_type_t;

typedef struct mdm_history_query_s {
    mdm_history_parameter_t parameter;
    union {
        int64_t date;

        uint64_t record_id;

        mdm_direction_t direction;

        const char *destination_number;

        const char *sim_id;

        mdm_roaming_status_t roaming_status;

        mdm_history_event_type_t type;
    };
} mdm_history_query_t;


typedef struct mdm_history_info_s {
    mdm_history_event_type_t type;
    union {
        struct {
            uint64_t             record_id;     
            mdm_direction_t      direction;     
            const char *         number;        
            time_t               timestamp;     
            const char *         slot_id;       
            const char *         imsi;          
            const char *         iccid;         
            const char *         imei;          
            const char *         sim_msisdn;    
            mdm_roaming_status_t roaming_state; 
            const char *         body;          
        } sms;
        struct {
            uint64_t             record_id;     
            mdm_direction_t      direction;     
            const char *         number;        
            time_t               timestamp;     
            const char *         slot_id;       
            const char *         imsi;          
            const char *         iccid;         
            const char *         imei;          
            const char *         sim_msisdn;    
            mdm_roaming_status_t roaming_state; 
            const char *         call_type;     
            int                  duration;      
        } call;
    };
} mdm_history_info_t;

typedef struct mdm_history_context_s mdm_history_context_t;

#endif /* MDM_FOR_SOLIS_PROF */

mdm_data_t *mdm_get_device_id(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to get the IMEI number for a specified SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the unique device ID for the specified SIM card.
 * For example, the IMEI for GSM and the MEID or ESN for CDMA phones.
 * Returns null if device ID is not available.
 *
 * @code{.c}

    mdm_data_t *lp_data = mdm_msim_get_imei("SIM2");
    if (lp_data) {
        char *device_id = (char *)lp_data->data;
        if(device_id != NULL) {
            printf("device id : %s", device_id);
        }

        // free after use
        mdm_free_data(lp_data);
     } else {
        // Failure or device ID is not available
     }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_data_t * : The unique device ID on success,
 *                        NULL on error or if the device ID is not available
 *
 * @see mdm_get_device_id
 */
mdm_data_t *mdm_msim_get_imei(const char *id);

#endif /* MDM_FOR_SOLIS_PROF */

MDM_DEPRECATED_API mdm_data_t *mdm_get_sim_serial_number(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to get the Integrated Circuit  Card ID (ICCID) of a specific SIM card in the device.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the Integrated Circuit Card ID (ICCID) of the SIM card identified by SIM card ID, if applicable.
 * Returns null if it is unavailable.
 *
 * @code{.c}

       mdm_data_t *lp_data = mdm_msim_get_sim_serial_number("SIM1");
       if (lp_data) {
               char *sim_iccid = (char *)lp_data->data;
               if(device_id != NULL) {
                       printf("sim serial number : %s", sim_iccid);
               }

               // free after use
               mdm_free_data(lp_data);
        } else {
               // Failure or SIM ICCID is not available
        }

 * @endcode
 *
 * @param[in]  id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_data_t * : The ICCID of the SIM card on success,
 *                        NULL on error or if the ICCID is not available
 *
 */
mdm_data_t *mdm_msim_get_sim_serial_number(const char *id);

#endif /* MDM_FOR_SOLIS_PROF */

MDM_DEPRECATED_API mdm_data_t *mdm_get_bluetooth_address(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_network_operator(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_network_operator_name(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_sim_operator_name(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_subscriber_number(void);

MDM_DEPRECATED_API mdm_network_service_type_t mdm_get_network_type(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to get SIM IDs.
 *
 * This API will return the SIM cards IDs (slots) in the same order as they are
 * on the device and as they are returned by other system API. If other API references SIM slots in any way,
 * it references them in the same order as this API. First slot referenced by other API corresponds to first
 * ID returned by mdm_msim_get_sim_ids() and last slot referenced by other API corresponds to the last ID returned by
 mdm_msim_get_sim_ids().
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * @code{.c}

    mdm_data_t *lp_data = NULL;
    lp_data = mdm_msim_get_sim_ids();
    if (lp_data && lp_data->data) {
        GList *sim_ids_list = g_list_first(lp_data->data);
        for(; sim_ids_list; sim_ids_list = g_list_next(sim_ids_list))
        {
            printf("sim id [%s]\n", sim_ids_list->data ? (char*)sim_ids_list->data : "(null)");
        }
        mdm_free_data(lp_data);
    }

 * @endcode
 *
 * @return #mdm_data_t * : The unique device ID on success,
 *                        NULL on error or if the device ID is not available
 */
mdm_data_t *mdm_msim_get_sim_ids(void);

#endif /* MDM_FOR_SOLIS_PROF */

MDM_DEPRECATED_API mdm_data_t *mdm_get_sim_operator(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to get the numeric name (MCC+MNC+Msin) of the SIM operator.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the MCC+MNC (mobile country code + mobile network code + station identification number)
 * of the SIM operator. Equals to 17 decimal digits.
 * @code{.c}

    mdm_data_t *lp_data = NULL;

    //use mdm_msim_get_sim_ids to get simid

    lp_data = mdm_msim_get_imsi(simid);
    if (lp_data) {
        char *imsi = (char *)lp_data->data;
        if(imsi != NULL) {
            printf("sim operator : %s", imsi);
        }

        // free after use
        mdm_free_data(lp_data);
    }

 * @endcode
 *
 * @param[in]  id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_data_t * :The numeric name (MCC+MNC+Msin) of the SIM imsi on success, NULL on error.
 *
 */
mdm_data_t *mdm_msim_get_imsi(const char *id);

#endif /* MDM_FOR_SOLIS_PROF */

MDM_DEPRECATED_API mdm_data_t *mdm_get_sim_country_iso(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to get the roaming state.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin may use this function to send a dbus request to telephony server and find out
 * if roaming is enabled or not.
 *
 * @code{.c}

    mdm_status_t status = -1;
    status = mdm_msim_get_sim_roaming_status("SIM1");
    if (status == MDM_TRUE) {
        // roaming enabled
    } else if (status == MDM_FALSE) {
        // roaming disabled
    } else {
        // error occured
    }

 * @endcode
 *
 * @param[in]  id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_status_t : Whether roaming is enabled
 *
 * @retval #MDM_TRUE Enabled
 * @retval #MDM_FALSE Disabled.
 *
 */
mdm_status_t mdm_msim_get_sim_roaming_status(const char *id);

#endif /* MDM_FOR_SOLIS_PROF */

mdm_sim_status_t mdm_get_sim_state(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_wifi_mac_address(void);

MDM_DEPRECATED_API mdm_status_t mdm_is_bluetooth_supported(void);

MDM_DEPRECATED_API mdm_status_t mdm_get_bluetooth_mode_status(void);

mdm_data_t *mdm_get_device_name(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_platform_version(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_total_capacity_internal(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_available_capacity_internal(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_total_capacity_external(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_available_capacity_external(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_model_name(void);

mdm_data_t *mdm_get_modem_firmware(void);

mdm_status_t mdm_is_device_secure(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_device_platform(void);

MDM_DEPRECATED_API mdm_data_t *mdm_get_device_maker(void);

mdm_status_t mdm_is_device_locked(void);

MDM_DEPRECATED_API mdm_result_t mdm_get_success_calls_count(int *count);

MDM_DEPRECATED_API mdm_result_t mdm_get_missed_calls_count(int *count);

MDM_DEPRECATED_API mdm_result_t mdm_get_rejected_calls_count(int *count);

MDM_DEPRECATED_API mdm_result_t mdm_get_blocked_calls_count(int *count);

MDM_DEPRECATED_API mdm_result_t mdm_reset_calls_count(void);

mdm_result_t mdm_enable_wifi_statistics(mdm_status_t status);

mdm_status_t mdm_is_wifi_statistics_enabled(void);

mdm_result_t mdm_enable_data_call_statistics(mdm_status_t status);

mdm_status_t mdm_is_data_call_statistics_enabled(void);

MDM_DEPRECATED_API mdm_result_t mdm_reset_data_usage(void);

MDM_DEPRECATED_API mdm_result_t mdm_get_bytes_sent_wifi(long long *bytes);

MDM_DEPRECATED_API mdm_result_t mdm_get_bytes_received_wifi(long long *bytes);

MDM_DEPRECATED_API mdm_result_t mdm_get_bytes_sent_network(long long *bytes);

MDM_DEPRECATED_API mdm_result_t mdm_get_bytes_received_network(long long *bytes);

mdm_result_t mdm_enable_sms_capture(mdm_status_t status);

mdm_status_t mdm_is_sms_capture_enabled(void);

mdm_data_t *mdm_get_inbound_sms_captured(void);

mdm_data_t *mdm_get_outbound_sms_captured(void);

mdm_result_t mdm_clear_sms_captured(void);

mdm_result_t mdm_enable_call_capture(mdm_status_t status);

mdm_status_t mdm_is_call_capture_enabled(void);

mdm_data_t *mdm_get_incoming_call_captured(void);

mdm_data_t *mdm_get_outgoing_call_captured(void);

mdm_result_t mdm_clear_call_captured(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to enable or disable SMS capture for a specific SIM card.
 *
 * @since_mdm 1.1.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 logging of SMS on device.
 * When logging is enabled, a direction ('From'/'To'), a phone number, message body and timestamp will be saved.
 *
 * @code{.c}

    mdm_result_t ret = mdm_msim_enable_sms_capture("SIM1", MDM_ENABLED);
    if (ret == MDM_RESULT_SUCCESS) {
        //Success
    }

 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.device
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[in] status #MDM_ENABLED to enable SMS logging, #MDM_DISABLED to disable it.
 *
 * @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_msim_is_sms_capture_enabled, mdm_msim_get_inbound_sms_captured,
 *      mdm_msim_outbound_sms_captured, mdm_msim_clear_sms_captured
 */
mdm_result_t mdm_msim_enable_sms_capture(const char *id, mdm_status_t status);

/*
 * @brief API to check whether SMS capture is enabled or disabled for specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to check whether SMS capture is enabled or disabled on device.
 *
 * @code{.c}

    mdm_status_t ret = mdm_is_sms_capture_enabled("SIM1");
    if (ret == MDM_ENABLED) {
        // SMS capture is enabled.
    }

 * @endcode
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_status_t : Whethercapturing SMS is enabled
 *
 * @retval #MDM_ENABLED Capturing SMS is enabled
 * @retval #MDM_DISABLED Capturing SMS is disabled
 * @retval #MDM_STATUS_ERROR Fail
 *
 * @see mdm_msim_enable_sms_capture, mdm_msim_get_inbound_sms_captured,
 *      mdm_msim_outbound_sms_captured, mdm_msim_clear_sms_captured
 */
mdm_status_t mdm_msim_is_sms_capture_enabled(const char *id);

/*
 * @brief API to retrieve the inbound SMSes captured for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the inbound SMSs captured for a specific SIM card.
 * SMS capture has to be enabled with mdm_msim_enable_sms_capture().
 * Each String entry in the list will be of the following format
 * "To:XXX - From:XXX - TimeStamp:XXX - Body:XXX - IMSI:XXX - ICCID:XXX - IMEI:XXX - Roaming State:XXX"
 *
 * @code{.c}

    mdm_data_t *mdm_data = mdm_msim_get_inbound_sms_captured("SIM1");
    if (mdm_data != NULL && mdm_data->ret == MDM_RESULT_SUCCESS) {

        GList *current = g_list_first((GList *) mdm_data->data);
        while (current && current->data) {
                char *captured = (char *) current->data;
                printf("%s\n", captured);
                current = g_list_next(current);
            }
    }
    mdm_free_data(mdm_data);

 * @endcode
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return A list of all inbound SMSs captured for a specific SIM card.
 * On error sets mdm_data_t::ret, only in case of memory allocation error may return NULL.
 *
 * @see mdm_msim_enable_sms_capture, mdm_msim_is_sms_capture_enabled,
 *      mdm_msim_outbound_sms_captured, mdm_msim_clear_sms_captured
 */
mdm_data_t *mdm_msim_get_inbound_sms_captured(const char *id);

/*
 * @brief API to retrieve the outbound SMSes captured for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the outbound SMSs captured for a specific SIM card.
 * SMS capture has to be enabled with mdm_msim_enable_sms_capture().
 * Each String entry in the list will be of the following format
 * "To:XXX - From:XXX - TimeStamp:XXX - Body:XXX - IMSI:XXX - ICCID:XXX - IMEI:XXX - Roaming State:XXX"
 *
 * @code{.c}

    mdm_data_t *mdm_data = mdm_msim_get_outbound_sms_captured("SIM1");
    if (mdm_data != NULL && mdm_data->ret == MDM_RESULT_SUCCESS) {

        GList *current = g_list_first((GList *) mdm_data->data);
        while (current && current->data) {
                char *captured = (char *) current->data;
                printf("%s\n", captured);
                current = g_list_next(current);
            }
    }
    mdm_free_data(mdm_data);

 * @endcode
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return A list of all outbound SMSs captured for a specific SIM card.
 * On error sets mdm_data_t::ret, only in case of memory allocation error may return NULL.
 *
 * @see mdm_msim_enable_sms_capture, mdm_msim_is_sms_capture_enabled,
 *      mdm_msim_inbound_sms_captured, mdm_msim_clear_sms_captured
 */
mdm_data_t *mdm_msim_get_outbound_sms_captured(const char *id);

/*
 * @brief API to clear the SMS logged for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to clear the SMS logged on device.
 *
 * @code{.c}

    mdm_result_t ret = mdm_clear_sms_captured("SIM1");
    if (ret == MDM_RESULT_SUCCESS) {
        // Succeeded
    }

 * @endcode
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.device
 *
 * @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_inbound_sms_captured, mdm_outbound_sms_captured
 */
mdm_result_t mdm_msim_clear_sms_captured(const char *id);

/*
 * @brief API to enable or disable call capture for a specific SIM card.
 *
 * @since_mdm 1.1.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 logging of calls for a specific SIM card.
 * When logging is enabled, a direction ('From'/'To'), a phone number, type (such as "Outgoing video call"),
 * duration of the call and timestamp will be saved. The audio <b>won't</b> be saved.
 *
 * @code{.c}

    mdm_result_t ret = mdm_msim_enable_call_capture("SIM1", MDM_ENABLED);
    if (ret == MDM_RESULT_SUCCESS) {
        // Success
    }

 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.device
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[in] status #MDM_ENABLED to enable call capture, #MDM_DISABLED to disable it.
 *
 * @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_msim_is_call_capture_enabled, mdm_msim_get_incoming_call_captured,
 *      mdm_msim_outgoing_call_captured, mdm_msim_clear_call_captured
 */
mdm_result_t mdm_msim_enable_call_capture(const char *id, mdm_status_t status);

/*
 * @brief API to check whether call capture is enabled or disabled for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to check whether the call capture is enabled or disabled for a specific SIM card.
 *
 * @code{.c}

    mdm_status_t ret = mdm_is_call_capture_enabled("SIM1");
    if (ret == MDM_ENABLED) {
        // Call capture is enabled.
    }

 * @endcode
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_status_t : Whether call capture is enalbed
 *
 * @retval #MDM_ENABLED Call capture is enabled
 * @retval #MDM_DISABLED Call capture is disabled
 * @retval #MDM_STATUS_ERROR Fail
 *
 * @see mdm_msim_enable_call_capture, mdm_msim_get_incoming_call_captured,
 *      mdm_msim_outgoing_call_captured, mdm_msim_clear_call_captured
 */
mdm_status_t mdm_msim_is_call_capture_enabled(const char *id);

/*
 * @brief API to retrieve the incoming calls capture log for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the incoming calls captured log for a specific SIM card.
 * Call capture has to be enabled with mdm_msim_enable_call_capture().
 * Each String entry in the list will be of the following format
 * "To:XXX - From:XXX - TimeStamp:XXX - Duration:XXX - Call type:XXX - IMSI:XXX - ICCID:XXX - IMEI:XXX - Roaming
 State:XXX"
 *
 * @code{.c}

    mdm_data_t *mdm_data = mdm_msim_get_incoming_call_captured("SIM1");
    if (mdm_data != NULL && mdm_data->ret == MDM_RESULT_SUCCESS) {

        GList *current = g_list_first((GList *) mdm_data->data);
        while (current && current->data) {
                char *captured = (char *) current->data;
                printf("%s\n", captured);
                current = g_list_next(current);
            }
    }
    mdm_free_data(mdm_data);

 * @endcode
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return A list of all incoming call capture logs for a specific SIM card.
 * On error sets mdm_data_t::ret, only in case of memory allocation error may return NULL.
 *
 * @see mdm_msim_enable_call_capture, mdm_msim_is_call_capture_enabled,
 *      mdm_msim_outgoing_call_captured, mdm_msim_clear_call_captured
 */
mdm_data_t *mdm_msim_get_incoming_call_captured(const char *id);

/*
 * @brief API to retrieve the outgoing calls capture log for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the outgoing calls captured log for a specific SIM card.
 * Call capture has to be enabled with mdm_msim_enable_call_capture().
 * Each String entry in the list will be of the following format
 * "To:XXX - From:XXX - TimeStamp:XXX - Duration:XXX - Call type:XXX - IMSI:XXX - ICCID:XXX - IMEI:XXX - Roaming
 State:XXX"
 *
 * @code{.c}

    mdm_data_t *mdm_data = mdm_msim_get_outgoing_call_captured("SIM1");
    if (mdm_data != NULL && mdm_data->ret == MDM_RESULT_SUCCESS) {

        GList *current = g_list_first((GList *) mdm_data->data);
        while (current && current->data) {
                char *captured = (char *) current->data;
                printf("%s\n", captured);
                current = g_list_next(current);
            }
    }
    mdm_free_data(mdm_data);

 * @endcode
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return A list of all outgoing call capture logs for a specific SIM card.
 * On error sets mdm_data_t::ret, only in case of memory allocation error may return NULL.
 *
 * @see mdm_msim_enable_call_capture, mdm_msim_is_call_capture_enabled,
 *      mdm_msim_incoming_call_captured, mdm_msim_clear_call_captured
 */
mdm_data_t *mdm_msim_get_outgoing_call_captured(const char *id);

/*
 * @brief API to clear the call capture logs for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to clear the call capture logs on device.
 *
 * @code{.c}

    mdm_result_t ret = mdm_clear_call_captured("SIM1");
    if (ret == MDM_RESULT_SUCCESS) {
        // Succeeded
    }

 * @endcode
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.device
 *
 * @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_incoming_call_captured, mdm_outgoing_call_captured
 */
mdm_result_t mdm_msim_clear_call_captured(const char *id);

#endif /* MDM_FOR_SOLIS_PROF */

MDM_DEPRECATED_API mdm_data_t *mdm_get_device_processor_type(void);

MDM_DEPRECATED_API mdm_result_t mdm_get_total_ram_memory(int *memory);

MDM_DEPRECATED_API mdm_result_t mdm_get_available_ram_memory(int *memory);

/*
 * @brief API to check if device was rooted by the user.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to check if the device is rooted.
 *
 * @code{.c}
         mdm_status_t ret = mdm_is_device_rooted();
         if (ret != MDM_STATUS_ERROR) {
              if (ret == MDM_TRUE) {
                    // Device is rooted
              } else {
                    // Device is not rooted
              }
         } else {
                // Failure
         }

 * @endcode
 *
 * @return #mdm_status_t : Whether the device is rooted
 *
 * @retval #MDM_TRUE Device is rooted
 * @retval #MDM_FALSE Device is not rooted
 * @retval #MDM_STATUS_ERROR Failure
 *
 */
mdm_status_t mdm_is_device_rooted(void);

mdm_data_t *mdm_get_device_serial_number(void);

#ifndef MDM_FOR_SOLIS_PROF

/*
 * @brief API to get the standardized (ISO) country code of the SIM provider.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the standardized (ISO) country code of the SIM provider.
 *
 * @code{.c}

    mdm_data_t *lp_data = NULL;
    lp_data = mdm_msim_get_sim_country_iso("SIM1");
    if (lp_data) {
        char *sim_mcc_iso = (char *)lp_data->data;
        if(sim_iso != NULL) {
            printf("sim country iso : %s", sim_mcc_iso);
        }

        // free after use
        mdm_free_data(lp_data);
    }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_data_t * :The standardized (ISO) country code of the SIM operator on success, NULL on error.
 *
 */
mdm_data_t *mdm_msim_get_sim_country_iso(const char *id);

/*
 * @brief API to get the status of the specific device SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the status of a device SIM card.
 *
 * @code{.c}

    mdm_sim_status_t sim_status = mdm_msim_get_sim_state("SIM1");
    if (sim_status != MDM_SIM_STATUS_ERROR) {
        // Failure
    } else {
        // Success
        // Use sim_status value
    }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_sim_status_t : The status of the device SIM card on success, MDM_SIM_STATUS_ERROR on failure.
 *
 * @retval #MDM_SIM_STATUS_ERROR                    Error
 * @retval #MDM_SIM_STATUS_CARD_ERROR               Bad card/On the fly SIM gone bad
 * @retval #MDM_SIM_STATUS_CARD_NOT_PRESENT         Card not present
 * @retval #MDM_SIM_STATUS_SIM_INITIALIZING         SIM is in Initializing state
 * @retval #MDM_SIM_STATUS_SIM_INIT_COMPLETED       SIM Initialization OK
 * @retval #MDM_SIM_STATUS_SIM_PIN_REQUIRED         PIN  required state
 * @retval #MDM_SIM_STATUS_SIM_PUK_REQUIRED         PUK required state
 * @retval #MDM_SIM_STATUS_CARD_BLOCKED             PIN/PUK blocked(permanently blocked- All the attempts for PIN/PUK
 failed)
 * @retval #MDM_SIM_STATUS_SIM_NCK_REQUIRED         Network Control Key required state
 * @retval #MDM_SIM_STATUS_SIM_NSCK_REQUIRED        Network Subset Control Key required state
 * @retval #MDM_SIM_STATUS_SIM_SPCK_REQUIRED        Service Provider Control Key required state
 * @retval #MDM_SIM_STATUS_SIM_CCK_REQUIRED         Corporate Control Key required state
 * @retval #MDM_SIM_STATUS_CARD_REMOVED             Card removed
 * @retval #MDM_SIM_STATUS_SIM_LOCK_REQUIRED        PH-SIM (Phone-SIM) locked state
 *
 * @see mdm_sim_status_t
 *
 */
mdm_sim_status_t mdm_msim_get_sim_state(const char *id);

/*
 * @brief API to get the radio technology (Network Type) that is currently being used on the device.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can check the radio technology (Network Type) that is currently being used on the device for data transmission.
 *
 * @code{.c}

    mdm_network_service_type_t network_type = MDM_NETWORK_SERVICE_ERR;

    network_type = mdm_msim_get_network_type("SIM1");
    if (network_type != MDM_NETWORK_SERVICE_ERR) {
          // Success
    } else {
          // Failure
    }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_network_service_type_t : network type on sucess, MDM_NETWORK_SERVICE_ERR on failure.
 *
 * @retval #MDM_NETWORK_SERVICE_ERR                     Error
 * @retval #MDM_NETWORK_SERVICE_NO_SRV                  No Service available
 * @retval #MDM_NETWORK_SERVICE_GSM                     GSM
 * @retval #MDM_NETWORK_SERVICE_GPRS                    GPRS
 * @retval #MDM_NETWORK_SERVICE_EGPRS                   EGPRS
 * @retval #MDM_NETWORK_SERVICE_PCS1900                 PCS1900
 * @retval #MDM_NETWORK_SERVICE_UMTS                    UMTS
 * @retval #MDM_NETWORK_SERVICE_GSM_AND_UMTS            GSM/UMTS
 * @retval #MDM_NETWORK_SERVICE_HSDPA                   HSDPA
 * @retval #MDM_NETWORK_SERVICE_IS95A                   IS95A
 * @retval #MDM_NETWORK_SERVICE_IS95B                   IS95B
 * @retval #MDM_NETWORK_SERVICE_CDMA_1X                 CDMA 1X
 * @retval #MDM_NETWORK_SERVICE_EVDO_REV_0              EV-DO rev0
 * @retval #MDM_NETWORK_SERVICE_1X_EVDO_REV_0_HYBRID    1X/EV-DO rev0
 * @retval #MDM_NETWORK_SERVICE_EVDO_REV_A              EV-DO revA
 * @retval #MDM_NETWORK_SERVICE_1X_EVDO_REV_A_HYBRID    1X/EV-DO revA
 * @retval #MDM_NETWORK_SERVICE_EVDO_REV_B              EV-DO revB
 * @retval #MDM_NETWORK_SERVICE_1X_EVDO_REV_B_HYBRID    1X/EV-DO revB
 * @retval #MDM_NETWORK_SERVICE_EVDV                    EV-DV
 * @retval #MDM_NETWORK_SERVICE_EHRPD                   EHRPD
 * @retval #MDM_NETWORK_SERVICE_LTE                     LTE
 *
 * @see mdm_msim_network_service_type_t
 *
 */
mdm_network_service_type_t mdm_msim_get_network_type(const char *id);


/*
 * @brief API to get phone number associated a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the phone number associated with the first line of the device. For example, the MSISDN for a GSM phone.
 * Returns null if it is unavailable.
 *
 * @code{.c}

    mdm_data_t *lp_data = mdm_msim_get_subscriber_number("SIM1");
    if (lp_data) {
        char *phone_number = (char *)lp_data->data;
        if(name != NULL) {
            printf("subscriber number : %s", phone_number);
        }

        // free after use
        mdm_free_data(lp_data);
    }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_data_t * : The phone number associated with the device on success,
 *                        NULL on error, or if the phone number is unavailable
 *
 */
mdm_data_t *mdm_msim_get_subscriber_number(const char *id);


/*
 * @brief API to get the Service Provider Name (SPN) if SIM is available on the device.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the Service Provider Name (SPN) if available.
 *
 * @note Some SIM types don't offer SPN.
 * Regarding the 3GPP specification, this value is optional.
 * If SPN is not stored on the SIM card this function will return NULL.
 *
 * @code{.c}

    mdm_data_t *lp_data = NULL;

    lp_data = mdm_msim_get_sim_operator_name("SIM1");
    if (lp_data && lp_data->data) {
        char *name = (char *)lp_data->data;
        if(name != NULL) {
            printf("SIM operator name: %s\n", name);
        } else {
            printf("SIM operator name is unavailable\n");
        }

        // free after use
        mdm_free_data(lp_data);
    }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_data_t * : The Service Provider Name (SPN) on success,
 *                        NULL on error, or if the SPN is not available
 *
 * @see mdm_msim_get_sim_operator
 */
mdm_data_t *mdm_msim_get_sim_operator_name(const char *id);

/*
 * @brief API to get the numeric name (MCC+MNC) of the current registered network operator.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the numeric name (MCC+MNC) of the current registered network operator for specific SIM
 * The numeric name of the network operator will be available only if the user's device is registered to a network.
 *
 * @code{.c}

    mdm_data_t *lp_data = NULL;

    lp_data = mdm_msim_get_network_operator("SIM1");
    if (lp_data) {
        char *operator_number = (char *)lp_data->data;
        if(no != NULL) {
            printf("network operator : %s", operator_number);
        }

        // free after use
        mdm_free_data(lp_data);
    }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_data_t * : The numeric name (MCC+MNC) of the network operator on success,
 *                        NULL on error, or if the device is not registered to any network
 *
 * @see mdm_msim_get_network_operator_name
 */
mdm_data_t *mdm_msim_get_network_operator(const char *id);

/*
 * @brief API to get the alphanumeric name of current registered network operator.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the alphanumeric name of the current registered network operator.
 * The alphanumeric name of the network operator will be available only if the device is registered to a network.
 *
 * @code{.c}

    mdm_data_t *lp_data = NULL;

    lp_data = mdm_msim_get_network_operator_name("SIM1");
    if (lp_data) {
        char *operator_name = (char *)lp_data->data;
        if(name != NULL) {
            printf("network operator name : %s", operator_name);
        }

        // free after use
        mdm_free_data(lp_data);
    }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_data_t * : The alphanumeric name of the network operator on success,
 *                        NULL on error, or if the device is not registered to any network
 *
 * @see mdm_msim_get_network_operator
 */
mdm_data_t *mdm_msim_get_network_operator_name(const char *id);

/*
 * @brief API to get the numeric name (MCC+MNC) of the SIM operator.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Admin can get the MCC+MNC (mobile country code + mobile network code)
 * of the SIM operator. Equals to 5 or 6 decimal digits.
 * @code{.c}

    mdm_data_t *lp_data = NULL;
    lp_data = mdm_msim_get_sim_operator("SIM1");
    if (lp_data) {
        char *sim_op = (char *)lp_data->data;
        if(sim_op != NULL) {
            printf("sim operator : %s", sim_op);
        }

        // free after use
        mdm_free_data(lp_data);
    }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_data_t * : The numeric name (MCC+MNC) of the SIM operator on success, NULL on error.
 *
 * @see mdm_msim_get_sim_operator_name
 */
mdm_data_t *mdm_msim_get_sim_operator(const char *id);

/*
 * @brief Retrieves the model firmware version of the device
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.2.1.1
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the firmware version of the device
 *
 * @code{.c}

     mdm_data_t *lp_data = NULL;
     lp_data = mdm_msim_get_modem_firmware("SIM1");
     if (lp_data) {
        char *data = (char *)lp_data->data;
        if(data != NULL) {
            printf("firmware version : %s\n", data);
        }
        mdm_free_data(lp_data);
     }

 * @endcode
 *
 * @return #mdm_data_t * : Firmware version as string. If modem version is set, then actual modem version will be
 returned, otherwise null value will be returned.
 *
 */
mdm_data_t *mdm_msim_get_modem_firmware(const char *simid);


/*
 * @brief API to retrieve the number of calls completed successfully on the device for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the number of calls completed successfully on the device.
 *
 * @code{.c}
     int count;
     mdm_result_t ret = mdm_get_success_calls_count("SIM1", &count);
     if (ret == MDM_RESULT_SUCCESS) {
        //locked
        printf("Count : %d\n", count);
     }

 * @endcode
 *
 * @param[in]  id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[out] count  Number of successful calls.
 *
 * @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_msim_get_missed_calls_count, mdm_msim_get_rejected_calls_count,
 *      mdm_msim_get_blocked_calls_count, mdm_msim_reset_calls_count
 *
 */
mdm_result_t mdm_msim_get_success_calls_count(const char *id, int *count);

/*
 * @brief API to retrieve the number of missed calls on the device
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the number of missed calls on the device
 *
 * @code{.c}
     int count;
     mdm_result_t ret = mdm_msim_get_missed_calls_count("SIM1", &count);
     if (ret == MDM_RESULT_SUCCESS) {
        //locked
        printf("Count : %d\n", count);
     }

 * @endcode
 *
 * @param[in]  id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[out] count  Number of missed calls.
 *
 * @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_msim_get_success_calls_count, mdm_msim_get_rejected_calls_count,
 *      mdm_msim_get_blocked_calls_count, mdm_msim_reset_calls_count
 *
 */
mdm_result_t mdm_msim_get_missed_calls_count(const char *id, int *count);

/*
 * @brief API to retrieve the number of rejected calls on the device
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the number of rejected calls on the device
 *
 * @code{.c}
     int count;
     mdm_result_t ret = mdm_msim_get_rejected_calls_count("SIM1", &count);
     if (ret == MDM_RESULT_SUCCESS) {
        //locked
        printf("Count : %d\n", count);
     }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[out] count Number of rejected calls.
 *
 * @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_msim_get_success_calls_count, mdm_msim_get_missed_calls_count,
 *      mdm_msim_get_blocked_calls_count, mdm_msim_reset_calls_count
 *
 */
mdm_result_t mdm_msim_get_rejected_calls_count(const char *id, int *count);

/*
 * @brief API to retrieve the number of blocked calls on the device
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the number of blocked calls on the device
 *
 * @code{.c}
     int count;
     mdm_result_t ret = mdm_msim_get_blocked_calls_count("SIM1", &count);
     if (ret == MDM_RESULT_SUCCESS) {
        //locked
        printf("Count : %d\n", count);
     }

 * @endcode
 *
 * @param[in]  id    SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[out] count Number of blocked calls.
 *
 * @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_msim_get_success_calls_count, mdm_msim_get_missed_calls_count,
 *      mdm_msim_get_rejected_calls_count, mdm_msim_reset_calls_count
 *
 */
mdm_result_t mdm_msim_get_blocked_calls_count(const char *id, int *count);

/*
 * @brief API to reset the counters related to calls count for a specific SIM
 * card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to reset the counters related to calls count.
 *
 * @code{.c}
     mdm_result_t ret = mdm_msim_reset_calls_count("SIM1");
     if (ret == MDM_RESULT_SUCCESS) {
        //Success
     }

 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.device
 *
 * @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_msim_get_success_calls_count, mdm_msim_get_missed_calls_count,
 *      mdm_msim_get_rejected_calls_count, mdm_msim_get_blocked_calls_count
 *
 */
mdm_result_t mdm_msim_reset_calls_count(const char *simid);

/*
 * @brief API used to enable logging of cellular data network statistics on the device for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * An administrator can use this API to enable logging the number of cellular data network bytes received or sent.
 * If the device is managed by multiple administrators, logging is enabled if at least one administrator enables it.
 * Logging is disabled only if all administrators disable it.
 *
 * @code{.c}
     mdm_result_t ret = mdm_msim_enable_data_call_statistics("SIM1", MDM_ENABLED);
     if (ret == MDM_RESULT_SUCCESS) {
        //Success
     }

 * @endcode
 *
 * @privlevel public
 * @privilege %http://developer.samsung.com/tizen/privilege/mdm.device
 *
 * @param[in] id      SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[in] status  #MDM_ENABLED if the device shall store the data call statistics (count amount of data).
 *
 * @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_msim_is_data_call_statistics_enabled, mdm_msim_get_bytes_sent_network,
 *      mdm_msim_get_bytes_received_network
 *
 */
mdm_result_t mdm_msim_enable_data_call_statistics(const char *id, mdm_status_t status);

/*
 * @brief API to determine whether cellular data network statistics logging is enabled.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * An administrator can use this API to verify whether carrier data statistics logging is enabled on the device.
 * For a device managed by multiple administrators, logging is enabled if at least one administrator has enabled it.
 * Logging is disabled only if all administrators have disabled logging.
 *
 * @code{.c}
     mdm_status_t ret = mdm_msim_is_data_call_statistics_enabled("SIM1");
     if (ret == MDM_TRUE) {
        //Enabled
     }

 * @endcode
 *
 * @param[in] id SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 *
 * @return #mdm_status_t : Whether carrier data call statistics are enabled
 *
 * @retval #MDM_TRUE Data call statistics is enabled
 * @retval #MDM_FALSE Data call statistics is disabled
 *
 * @see mdm_msim_enable_data_call_statistics, mdm_msim_get_bytes_sent_network,
 *      mdm_msim_get_bytes_received_network
 */
mdm_status_t mdm_msim_is_data_call_statistics_enabled(const char *id);

/*
 * @brief API to retrieve the amount of bytes sent through network connection
 * for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the amount of bytes sent to cellular network connection.
 *
 * @code{.c}
     long long bytes;
     mdm_result_t ret = mdm_msim_get_bytes_sent_network("SIM1", &bytes);
     if (ret == MDM_RESULT_SUCCESS) {
        //Success
     }

 * @endcode
 *
 * @param[in] id     SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[out] bytes The amount of bytes sent through network connection.
 *
 * @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_msim_enable_data_call_statistics, mdm_msim_is_data_call_statistics_enabled,
        mdm_msim_get_bytes_received_network
 *
 */
mdm_result_t mdm_msim_get_bytes_sent_network(const char *id, long long *bytes);

/*
 * @brief API to retrieve the amount of bytes received from network connection
 * for a specific SIM card.
 *
 * @since_mdm 1.1.0
 *
 * @since_tizen 2.4.0.4
 *
 * @feature %http://developer.samsung.com/tizen/feature/mdm
 *
 * @par Usage:
 * Used by admin to get the amount of bytes received from cellular network connection.
 *
 * @code{.c}
     long long bytes;
     mdm_result_t ret = mdm_msim_get_bytes_received_network("SIM1", &bytes);
     if (ret == MDM_RESULT_SUCCESS) {
        //Success
     }

 * @endcode
 *
 * @param[in]  id    SIM card id. Check mdm_msim_get_sim_ids() for available SIM card ids.
 * @param[out] bytes The amount of bytes received from network connection.
 *
 * @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_msim_enable_data_call_statistics, mdm_msim_is_data_call_statistics_enabled,
 *      mdm_msim_get_bytes_sent_network
 *
 */
mdm_result_t mdm_msim_get_bytes_received_network(const char *id, long long *bytes);

mdm_history_context_t *mdm_history_context_new(void);

mdm_result_t mdm_history_context_free(mdm_history_context_t *ctx);

mdm_data_t *mdm_history_get_next(mdm_history_context_t *ctx, unsigned long window_size);

mdm_result_t mdm_history_remove(mdm_history_context_t *ctx);

mdm_result_t mdm_history_add_parameter(mdm_history_context_t *ctx, const mdm_history_query_t *query_parameter);

mdm_result_t mdm_history_add_sort_parameter(mdm_history_context_t *ctx, mdm_history_parameter_t parameter,
                                            mdm_sort_order_t order);

mdm_result_t mdm_history_set_purge_interval(uint64_t interval);

typedef struct mdm_history_purge_status_s {
    uint64_t interval;

    int64_t last_purge_date;

    uint64_t sms_record_purged_recently;

    uint64_t sms_record_purged_total;

    uint64_t call_record_purged_recently;

    uint64_t call_record_purged_total;
} mdm_history_purge_status_t;

mdm_data_t *mdm_history_get_purge_status(void);

#endif /* MDM_FOR_SOLIS_PROF */

#ifdef __cplusplus
}
#endif

#endif // LIBMDM_MDM_DEVICE_INVENTORY_H