Fix ABI issue for enum and parameter type

Change-Id: I65a5e8eb6e23e38b55d47ac5a6f5888f5c0557cc
Signed-off-by: hyunuk.tak <hyunuk.tak@samsung.com>

diff --git a/include/stc.h b/include/stc.h
index 560a25a37164770a912efe446375f2710dfbc2fe..388fa1e225ac93553e2feb4402d15c7ee8a71101 100755 (executable)
--- a/include/stc.h
+++ b/include/stc.h
@@ -148,8 +148,9 @@ typedef enum {
  * @since_tizen 4.0
  */
 typedef enum {
-       STC_ROAMING_DISABLED,    /**< Not in roaming */
+       STC_ROAMING_UNKNOWN,
        STC_ROAMING_ENABLED,     /**< In roaming */
+       STC_ROAMING_DISABLED,    /**< Not in roaming */
 } stc_roaming_type_e;
 
 /**
@@ -175,8 +176,8 @@ typedef enum {
  */
 typedef enum {
        STC_PROCESS_STATE_UNKNOWN,         /**< Unknown state */
-       STC_PROCESS_STATE_FOREGROUND,      /**< Foreground state */
-       STC_PROCESS_STATE_BACKGROUND,      /**< Background state */
+       STC_PROCESS_STATE_FOREGROUND = 1 << 1,      /**< Foreground state */
+       STC_PROCESS_STATE_BACKGROUND = 1 << 2,      /**< Background state */
 } stc_process_state_e;
 
 /**

diff --git a/src/stc-info.c b/src/stc-info.c
index 73285f3c8b861288d480f965e89b5133a6f683bb..0e600c8369b6e11ea1c6e630a5dcb67d1e8ec094 100755 (executable)
--- a/src/stc-info.c
+++ b/src/stc-info.c
@@ -186,7 +186,7 @@ EXPORT_API int stc_stats_info_get_counter(stc_stats_info_h info,
        *incoming = stats_info->cnt.incoming_bytes;
        *outgoing = stats_info->cnt.outgoing_bytes;
 
-       STC_LOGI("Counters incoming[%lld] outgoing[%lld]",
+       STC_LOGI("Counters incoming[%"PRId64"] outgoing[%"PRId64"]",
                *incoming, *outgoing);
 
        return STC_ERROR_NONE;

diff --git a/src/stc-restriction.c b/src/stc-restriction.c
index e83cef34add720899e26a4cf6f90d792f7bc8ccf..be23980a38e3d0f2e89da200bc7d181e08699a4b 100755 (executable)
--- a/src/stc-restriction.c
+++ b/src/stc-restriction.c
@@ -240,19 +240,19 @@ static void __stc_restriction_print_rule(
                STC_LOGD("Type:      [%s]", _stc_convert_rstn_type_to_string(rule->rstn_type));
 
        if (rule->data_limit >= 0)
-               STC_LOGD("Limit:     [%lld] bytes", rule->data_limit);
+               STC_LOGD("Limit:     [%"PRId64"] bytes", rule->data_limit);
 
        if (rule->data_warn_limit >= 0)
-               STC_LOGD("Warning:   [%lld] bytes", rule->data_warn_limit);
+               STC_LOGD("Warning:   [%"PRId64"] bytes", rule->data_warn_limit);
 
        if (rule->monthly_limit >= 0)
-               STC_LOGD("Monthly:   [%lld] bytes", rule->monthly_limit);
+               STC_LOGD("Monthly:   [%"PRId64"] bytes", rule->monthly_limit);
 
        if (rule->weekly_limit >= 0)
-               STC_LOGD("Weekly:    [%lld] bytes", rule->weekly_limit);
+               STC_LOGD("Weekly:    [%"PRId64"] bytes", rule->weekly_limit);
 
        if (rule->daily_limit >= 0)
-               STC_LOGD("Daily:     [%lld] bytes", rule->daily_limit);
+               STC_LOGD("Daily:     [%"PRId64"] bytes", rule->daily_limit);
 
        STC_LOGD("Month start date: [%d]", rule->month_start_date);
 
@@ -478,27 +478,27 @@ stc_error_e _stc_restriction_validate_rule(
        if (restriction_rule->rstn_type == STC_RSTN_TYPE_DROP) {
                STC_RETURN_VAL_IF(restriction_rule->data_limit < -1,
                        STC_ERROR_INVALID_PARAMETER,
-                       "Invalid data limit [%lld] bytes",
+                       "Invalid data limit [%"PRId64"] bytes",
                        restriction_rule->data_limit);
 
                STC_RETURN_VAL_IF(restriction_rule->data_warn_limit < -1,
                        STC_ERROR_INVALID_PARAMETER,
-                       "Invalid data warn limit [%lld] bytes",
+                       "Invalid data warn limit [%"PRId64"] bytes",
                        restriction_rule->data_warn_limit);
 
                STC_RETURN_VAL_IF(restriction_rule->monthly_limit < -1,
                        STC_ERROR_INVALID_PARAMETER,
-                       "Invalid monthly limit [%lld] bytes",
+                       "Invalid monthly limit [%"PRId64"] bytes",
                        restriction_rule->monthly_limit);
 
                STC_RETURN_VAL_IF(restriction_rule->weekly_limit < -1,
                        STC_ERROR_INVALID_PARAMETER,
-                       "Invalid weekly limit [%lld] bytes",
+                       "Invalid weekly limit [%"PRId64"] bytes",
                        restriction_rule->weekly_limit);
 
                STC_RETURN_VAL_IF(restriction_rule->daily_limit < -1,
                        STC_ERROR_INVALID_PARAMETER,
-                       "Invalid daily limit [%lld] bytes",
+                       "Invalid daily limit [%"PRId64"] bytes",
                        restriction_rule->daily_limit);
 
                STC_RETURN_VAL_IF(restriction_rule->month_start_date < 0,
@@ -536,27 +536,27 @@ stc_error_e _stc_restriction_check_set_rule(
 
        STC_RETURN_VAL_IF(restriction_rule->data_limit < -1,
                STC_ERROR_INVALID_PARAMETER,
-               "Invalid data limit [%lld] bytes",
+               "Invalid data limit [%"PRId64"] bytes",
                restriction_rule->data_limit);
 
        STC_RETURN_VAL_IF(restriction_rule->data_warn_limit < -1,
                STC_ERROR_INVALID_PARAMETER,
-               "Invalid data warn limit [%lld] bytes",
+               "Invalid data warn limit [%"PRId64"] bytes",
                restriction_rule->data_warn_limit);
 
        STC_RETURN_VAL_IF(restriction_rule->monthly_limit < -1,
                STC_ERROR_INVALID_PARAMETER,
-               "Invalid monthly limit [%lld] bytes",
+               "Invalid monthly limit [%"PRId64"] bytes",
                restriction_rule->monthly_limit);
 
        STC_RETURN_VAL_IF(restriction_rule->weekly_limit < -1,
                STC_ERROR_INVALID_PARAMETER,
-               "Invalid weekly limit [%lld] bytes",
+               "Invalid weekly limit [%"PRId64"] bytes",
                restriction_rule->weekly_limit);
 
        STC_RETURN_VAL_IF(restriction_rule->daily_limit < -1,
                STC_ERROR_INVALID_PARAMETER,
-               "Invalid daily limit [%lld] bytes",
+               "Invalid daily limit [%"PRId64"] bytes",
                restriction_rule->daily_limit);
 
        STC_RETURN_VAL_IF(restriction_rule->month_start_date < 0,
@@ -659,12 +659,12 @@ stc_error_e _stc_restriction_check_remove_rule(
 
        STC_RETURN_VAL_IF(restriction_rule->data_limit < 0,
                STC_ERROR_INVALID_PARAMETER,
-               "Invalid tx limit [%lld] bytes",
+               "Invalid tx limit [%"PRId64"] bytes",
                restriction_rule->data_limit);
 
        STC_RETURN_VAL_IF(restriction_rule->data_warn_limit < 0,
                STC_ERROR_INVALID_PARAMETER,
-               "Invalid rx limit [%lld] bytes",
+               "Invalid rx limit [%"PRId64"] bytes",
                restriction_rule->data_warn_limit);
 
        STC_RETURN_VAL_IF(restriction_rule->roaming_type > STC_ROAMING_ENABLED,
@@ -700,12 +700,12 @@ stc_error_e _stc_restriction_check_exclude_rule(
 
        STC_RETURN_VAL_IF(restriction_rule->data_limit < 0,
                STC_ERROR_INVALID_PARAMETER,
-               "Invalid tx limit [%lld] bytes",
+               "Invalid tx limit [%"PRId64"] bytes",
                restriction_rule->data_limit);
 
        STC_RETURN_VAL_IF(restriction_rule->data_warn_limit < 0,
                STC_ERROR_INVALID_PARAMETER,
-               "Invalid rx limit [%lld] bytes",
+               "Invalid rx limit [%"PRId64"] bytes",
                restriction_rule->data_warn_limit);
 
        STC_RETURN_VAL_IF(restriction_rule->roaming_type > STC_ROAMING_ENABLED,
@@ -994,7 +994,7 @@ EXPORT_API int stc_restriction_rule_set_limit(stc_restriction_rule_h rule,
 
        restriction_rule->data_limit = data_limit;
 
-       STC_LOGI("Data limit [%lld] bytes", restriction_rule->data_limit);
+       STC_LOGI("Data limit [%"PRId64"] bytes", restriction_rule->data_limit);
 
        return STC_ERROR_NONE;
 }
@@ -1014,7 +1014,7 @@ EXPORT_API int stc_restriction_rule_set_warning_limit(stc_restriction_rule_h rul
 
        restriction_rule->data_warn_limit = data_warn_limit;
 
-       STC_LOGI("Data warn limit [%lld] bytes",
+       STC_LOGI("Data warn limit [%"PRId64"] bytes",
                 restriction_rule->data_warn_limit);
 
        return STC_ERROR_NONE;
@@ -1035,7 +1035,7 @@ EXPORT_API int stc_restriction_rule_set_monthly_limit(stc_restriction_rule_h rul
 
        restriction_rule->monthly_limit = limit;
 
-       STC_LOGI("Monthly limit [%lld] bytes",
+       STC_LOGI("Monthly limit [%"PRId64"] bytes",
                 restriction_rule->monthly_limit);
 
        return STC_ERROR_NONE;
@@ -1056,7 +1056,7 @@ EXPORT_API int stc_restriction_rule_set_weekly_limit(stc_restriction_rule_h rule
 
        restriction_rule->weekly_limit = limit;
 
-       STC_LOGI("Weekly data limit [%lld] bytes",
+       STC_LOGI("Weekly data limit [%"PRId64"] bytes",
                 restriction_rule->weekly_limit);
 
        return STC_ERROR_NONE;
@@ -1077,7 +1077,7 @@ EXPORT_API int stc_restriction_rule_set_daily_limit(stc_restriction_rule_h rule,
 
        restriction_rule->daily_limit = limit;
 
-       STC_LOGI("Daily data limit [%lld] bytes",
+       STC_LOGI("Daily data limit [%"PRId64"] bytes",
                 restriction_rule->daily_limit);
 
        return STC_ERROR_NONE;
@@ -1254,7 +1254,7 @@ EXPORT_API int stc_restriction_rule_get_limit(stc_restriction_rule_h rule,
 
        *data_limit = restriction_rule->data_limit;
 
-       STC_LOGI("Data limit [%lld] bytes", *data_limit);
+       STC_LOGI("Data limit [%"PRId64"] bytes", *data_limit);
 
        return STC_ERROR_NONE;
 }
@@ -1274,7 +1274,7 @@ EXPORT_API int stc_restriction_rule_get_warning_limit(stc_restriction_rule_h rul
 
        *data_warn_limit = restriction_rule->data_warn_limit;
 
-       STC_LOGI("Data Warn limit [%lld] bytes", *data_warn_limit);
+       STC_LOGI("Data Warn limit [%"PRId64"] bytes", *data_warn_limit);
 
        return STC_ERROR_NONE;
 }
@@ -1294,7 +1294,7 @@ EXPORT_API int stc_restriction_rule_get_monthly_limit(stc_restriction_rule_h rul
 
        *limit = restriction_rule->monthly_limit;
 
-       STC_LOGI("Monthly data limit [%lld] bytes", *limit);
+       STC_LOGI("Monthly data limit [%"PRId64"] bytes", *limit);
 
        return STC_ERROR_NONE;
 }
@@ -1314,7 +1314,7 @@ EXPORT_API int stc_restriction_rule_get_weekly_limit(stc_restriction_rule_h rule
 
        *limit = restriction_rule->weekly_limit;
 
-       STC_LOGI("Weekly data limit [%lld] bytes", *limit);
+       STC_LOGI("Weekly data limit [%"PRId64"] bytes", *limit);
 
        return STC_ERROR_NONE;
 }
@@ -1334,7 +1334,7 @@ EXPORT_API int stc_restriction_rule_get_daily_limit(stc_restriction_rule_h rule,
 
        *limit = restriction_rule->daily_limit;
 
-       STC_LOGI("Daily data limit [%lld] bytes", *limit);
+       STC_LOGI("Daily data limit [%"PRId64"] bytes", *limit);
 
        return STC_ERROR_NONE;
 }

diff --git a/src/stc-statistics.c b/src/stc-statistics.c
index d4476ed604a480b031f89db9736cc70026978c62..1246612671f978090e40d56bbd4a8fbcdd43ae91 100755 (executable)
--- a/src/stc-statistics.c
+++ b/src/stc-statistics.c
@@ -247,8 +247,8 @@ static void __stc_stats_print_info(stc_stats_info_s *info)
 
        STC_LOGD("Roaming:  [%d]", info->roaming_type);
 
-       STC_LOGD("Received: [%lld]", info->cnt.incoming_bytes);
-       STC_LOGD("Sent:     [%lld]", info->cnt.outgoing_bytes);
+       STC_LOGD("Received: [%"PRId64"]", info->cnt.incoming_bytes);
+       STC_LOGD("Sent:     [%"PRId64"]", info->cnt.outgoing_bytes);
 
        if (info->protocol_type != STC_PROTOCOL_UNKNOWN)
                STC_LOGD("Protocol: [%d]", info->protocol_type);

diff --git a/test/restriction.c b/test/restriction.c
index 1682f34f3dddccfa34fcc721e9ef3c5e748351d2..6eca71852345481c7cc5e138548adc478cd23c44 100755 (executable)
--- a/test/restriction.c
+++ b/test/restriction.c
@@ -109,23 +109,23 @@ static stc_callback_ret_e __test_stc_restriction_rule_cb(
 
        ret = stc_restriction_rule_get_limit(rule, &data_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Data limit: [%lld]", data_limit);
+               msg("Data limit: [%"PRId64"]", data_limit);
 
        ret = stc_restriction_rule_get_warning_limit(rule, &data_warn_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Warn limit: [%lld]", data_warn_limit);
+               msg("Warn limit: [%"PRId64"]", data_warn_limit);
 
        ret = stc_restriction_rule_get_monthly_limit(rule, &monthly_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Monthly limit: [%lld]", monthly_limit);
+               msg("Monthly limit: [%"PRId64"]", monthly_limit);
 
        ret = stc_restriction_rule_get_weekly_limit(rule, &weekly_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Weekly limit:  [%lld]", weekly_limit);
+               msg("Weekly limit:  [%"PRId64"]", weekly_limit);
 
        ret = stc_restriction_rule_get_daily_limit(rule, &daily_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Daily limit:   [%lld]", weekly_limit);
+               msg("Daily limit:   [%"PRId64"]", weekly_limit);
 
        ret = stc_restriction_rule_get_month_start_date(rule, &month_start_date);
        if (ret == STC_ERROR_NONE)
@@ -358,28 +358,28 @@ static int __test_stc_set_restriction_rule(MManager *mm, struct menu_data *menu)
        data_limit = 0;
        ret = stc_restriction_rule_get_limit(g_restriction_rule, &data_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Data limit: " LOG_CYAN "[%lld]" LOG_END, data_limit);
+               msg("Data limit: " LOG_CYAN "[%"PRId64"]" LOG_END, data_limit);
 
        data_warn_limit = 0;
        ret = stc_restriction_rule_get_warning_limit(g_restriction_rule,
                                                     &data_warn_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Warn limit: " LOG_CYAN "[%lld]" LOG_END, data_warn_limit);
+               msg("Warn limit: " LOG_CYAN "[%"PRId64"]" LOG_END, data_warn_limit);
 
        monthly_limit = 0;
        ret = stc_restriction_rule_get_monthly_limit(g_restriction_rule, &monthly_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Monthly limit: " LOG_CYAN "[%lld]" LOG_END, monthly_limit);
+               msg("Monthly limit: " LOG_CYAN "[%"PRId64"]" LOG_END, monthly_limit);
 
        weekly_limit = 0;
        ret = stc_restriction_rule_get_weekly_limit(g_restriction_rule, &weekly_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Weekly limit:  " LOG_CYAN "[%lld]" LOG_END, weekly_limit);
+               msg("Weekly limit:  " LOG_CYAN "[%"PRId64"]" LOG_END, weekly_limit);
 
        daily_limit = 0;
        ret = stc_restriction_rule_get_daily_limit(g_restriction_rule, &daily_limit);
        if (ret == STC_ERROR_NONE)
-               msg("Daily limit:   " LOG_CYAN "[%lld]" LOG_END, daily_limit);
+               msg("Daily limit:   " LOG_CYAN "[%"PRId64"]" LOG_END, daily_limit);
 
        month_start_date = 0;
        ret = stc_restriction_rule_get_month_start_date(g_restriction_rule, &month_start_date);

diff --git a/test/statistics.c b/test/statistics.c
index 73c79371b813e79290f446af7e6b1ab9469e8592..5f6bed0ea7c0144e2f15f7a992ec82b8da067139 100755 (executable)
--- a/test/statistics.c
+++ b/test/statistics.c
@@ -107,8 +107,8 @@ static stc_callback_ret_e __test_stc_stats_info_cb(
 
        ret = stc_stats_info_get_counter(info, &incoming, &outgoing);
        if (ret == STC_ERROR_NONE) {
-               msg("Received: [%lld]", incoming);
-               msg("Sent:     [%lld]", outgoing);
+               msg("Received: [%"PRId64"]", incoming);
+               msg("Sent:     [%"PRId64"]", outgoing);
        }
 
        ret = stc_stats_info_get_roaming_type(info, &roaming);