Samsung Galaxy Watch: mdm_set_automatic_time () вернул статус -13 и не установил время - PullRequest
Новая
       59

Samsung Galaxy Watch: mdm_set_automatic_time () вернул статус -13 и не установил время

1 голос
/ 31 марта 2020

У меня есть:

Устройство: Samsung Galaxy Watch Active (SM-R500); Версия Tizen (API): 4.0; Knox Tizen SDK для носимых версий: 2,4;

На портале партнеров Knox я нашел активный Ключ KPE Standart и затем внедрил его в мой код. Я получаю привилегию устанавливать функции времени (http://developer.samsung.com/tizen/privilege/mdm.datetime) с помощью функции ppm_check_permission : 

...

const char *privileges[] =
{
    "http://tizen.org/privilege/mediastorage",
    "http://tizen.org/privilege/location",
    "http://tizen.org/privilege/healthinfo",
    "http://developer.samsung.com/tizen/privilege/mdm.admin",
    "http://developer.samsung.com/tizen/privilege/mdm.datetime",
    "http://developer.samsung.com/tizen/privilege/mdm.location",
};

...

static void _ppm_request_response_cb(ppm_call_cause_e cause, ppm_request_result_e result, const char *privilege, void *user_data)
{
    if (cause == PRIVACY_PRIVILEGE_MANAGER_CALL_CAUSE_ERROR)
    {
        LOG_PRINT(DLOG_DEBUG, "Error request response!");
        /* Log and handle errors */
        return;
    }

    switch (result)
    {
    case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_ALLOW_FOREVER:
        /* Update UI and start accessing protected functionality */
        LOG_PRINT(DLOG_DEBUG, "PPM request result: allow forever");
        break;
    case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_DENY_FOREVER:
        /* Show a message and terminate the application */
        LOG_PRINT(DLOG_DEBUG, "PPM request result: deny forever");
        ui_app_exit();
        break;
    case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_DENY_ONCE:
        /* Show a message with explanation */
        LOG_PRINT(DLOG_DEBUG, "PPM request result: deny once");
        ui_app_exit();
        break;
    }
}

...

static bool _create_cb(void *data)
{
    int i = 0;
    int ret = PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE;
    ppm_check_result_e result = PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ALLOW;

    int size = sizeof(privileges) / sizeof(char *);

    setlocale(LC_ALL, "en_US.UTF-8");

    for (i = 0; i < size; i++)
    {
        ret = ppm_check_permission(privileges[i], &result);
        if (ret == PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE)
        {
            switch (result)
            {
            case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ALLOW:
                LOG_PRINT(DLOG_DEBUG, "PPM request response: allow");
                break;
            case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_DENY:
                LOG_PRINT(DLOG_DEBUG, "PPM error request response: deny");
                ui_app_exit();
                break;
            case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ASK:
                ret = ppm_request_permission(privileges[i], _ppm_request_response_cb, NULL);
                LOG_PRINT(DLOG_DEBUG, "[ppm_request_permission] return %d", (int)ret);
                break;
            }
        }
    }

    file_logger_init(pfl, PATH_LOGS, CURRENT_VERSION, LOGGER_ROTATE_BY_SIZE | LOGGER_ROTATE_PER_HOUR, 8);

    if (!g_init())
    {
        LOG_PRINT(DLOG_ERROR, "GNSS is not working!");
    }

    me_init();

    gui_create_base();

    c_set_state(ST_WIZARD_STEP1);

    elm_run();
    return true;
}

...

int main(int argc, char *argv[])
{
    int ret = 0;
    app_data_t app_data = { 0, };
    ui_app_lifecycle_callback_s event_callback = { 0, };
    app_event_handler_h handlers[5] = { NULL, };
    pfl = &fl;

    feedback_initialize();

    event_callback.create = _create_cb;
    event_callback.terminate = _terminate_cb;
    event_callback.pause = _pause_cb;
    event_callback.resume = _resume_cb;
    event_callback.app_control = _app_control_cb;

    device_add_callback(DEVICE_CALLBACK_BATTERY_CHARGING, _device_changed_cb, NULL);

    ui_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY],
            APP_EVENT_LOW_BATTERY, _app_event_low_battery_cb, &app_data);
    ui_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY],
            APP_EVENT_LOW_MEMORY, _app_event_low_memory_cb, &app_data);
    ui_app_add_event_handler(&handlers[APP_EVENT_DEVICE_ORIENTATION_CHANGED],
            APP_EVENT_DEVICE_ORIENTATION_CHANGED, _app_event_device_orientation_changed_cb, &app_data);
    ui_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED],
            APP_EVENT_LANGUAGE_CHANGED, _app_event_language_changed_cb, &app_data);
    ui_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED],
            APP_EVENT_REGION_FORMAT_CHANGED, _app_event_region_format_changed_cb, &app_data);

    ret = ui_app_main(argc, argv, &event_callback, &app_data);
    if (ret != APP_ERROR_NONE)
    {
        LOG_PRINT(DLOG_ERROR, "[ui_app_main] return %d.", ret);
    }
    return ret;
}

Я пытаюсь установить время с помощью следующего кода: 

#include <logger_ext.h>
#include "mdm_ext.h"
#include "main.h"

#include <mdm.h>
#include <knox_custom.h>
#include <tizen.h>
#include <app_preference.h>

/* Registration keys */
#ifndef KEY
    #define KEY "KLM09-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX"
#endif

static const char *old_licenses[] =
{
"KLM09-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX",
"KLM09-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX",
"KLM06-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX",
};

static void _date_time_cb(int oper, void *cb_data, void *user_data);
static void _mdm_client_cb(int oper, void *cb_data, void *user_data);

static void _date_time_cb(int oper, void *cb_data, void *user_data)
{
    /*mdm_license_callback_t *ldata = (mdm_license_callback_t *)cb_data;
    switch (oper)
    {
        case MDM_CB_LICENSE_DEACTIVATE_KNOX:
            break;
        default:
            break;
    }*/
}

static void _mdm_client_cb(int oper, void *cb_data, void *user_data)
{
    if (!cb_data)
    {
        LOG_PRINT(DLOG_DEBUG, "cb_data == NULL");
        return;
    }
    const mdm_license_callback_t *ldata = (mdm_license_callback_t *) cb_data;
    if (!ldata || !ldata->license_info)
    {
        LOG_PRINT(DLOG_DEBUG, "ldata == NULL");
        return;
    }

    switch (oper)
    {
    case MDM_CB_LICENSE_ACTIVATE:
        if (ldata->license_info->error_code == 0)
        {
            LOG_PRINT(DLOG_INFO, "Success");
        }
        else
        {
            LOG_PRINT(DLOG_ERROR, "Fail: %s", ldata->license_info->error_desc);
        }
        break;
    case MDM_CB_LICENSE_ACTIVATE_KNOX:
        if (ldata->license_info->error_code == 0)
        {
            LOG_PRINT(DLOG_INFO, "Success");
        }
        else
        {
            LOG_PRINT(DLOG_ERROR, "Fail: %s", ldata->license_info->error_desc);
        }
        break;
    case MDM_CB_LICENSE_DEACTIVATE_KNOX:
        if (ldata->license_info->error_code == 0)
        {
            LOG_PRINT(DLOG_INFO, "Success");
        }
        else
        {
            LOG_PRINT(DLOG_ERROR, "Fail: %s", ldata->license_info->error_desc);
        }
        break;
    case MDM_CB_LICENSE_VALIDATE_RESULT:
        if (ldata->license_info->error_code == 0)
        {
            LOG_PRINT(DLOG_INFO, "Success");
        }
        else
        {
            LOG_PRINT(DLOG_ERROR, "Fail: %s", ldata->license_info->error_desc);
        }
        break;
    case MDM_CB_LICENSE_KNOX_VALIDATE_RESULT:
        if (ldata->license_info->error_code == 0)
        {
            LOG_PRINT(DLOG_INFO, "Success");
        }
        else
        {
            LOG_PRINT(DLOG_ERROR, "Fail: %s", ldata->license_info->error_desc);
        }
        break;
    default:
        break;
    }
}

void me_init(void)
{
    int ret = MDM_RESULT_SUCCESS;
    mdm_data_t *mdm_data = NULL;
    mdm_result_t mdm_result = MDM_RESULT_SUCCESS;
    mdm_status_t mdm_status = MDM_TRUE;
    int size = sizeof(old_licenses) / sizeof(char *);
    int i = 0;

    ret = mdm_register_client(PACKAGE);
    switch (ret)
    {
    case MDM_RESULT_SERVICE_NOT_ENABLED:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_SERVICE_NOT_ENABLED");
        break;
    case MDM_RESULT_ACCESS_DENIED:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_ACCESS_DENIED");
        break;
    case MDM_RESULT_INVALID_PARAM:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_INVALID_PARAM");
        break;
    case MDM_RESULT_NOT_SUPPORTED:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_NOT_SUPPORTED");
        break;
    case MDM_RESULT_FAIL:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_FAIL");
        break;
    case MDM_RESULT_SUCCESS:
        LOG_PRINT(DLOG_INFO, "MDM_RESULT_SUCCESS");
        break;
    case MDM_NOT_AN_OWNER:
        LOG_PRINT(DLOG_ERROR, "MDM_NOT_AN_OWNER");
        break;
    default:
        LOG_PRINT(DLOG_ERROR, "[mdm_register_client] return %d", ret);
        break;
    }

    mdm_result = mdm_get_service();
    if (mdm_result != MDM_RESULT_SUCCESS)
    {
        LOG_PRINT(DLOG_ERROR, "[mdm_get_service] return %d", mdm_result);
        mdm_release_service();
        return;
    }

    ret = mdm_register_client_callback(MDM_LICENSE_CB, _mdm_client_cb, NULL, NULL);
    if (ret != MDM_RESULT_SUCCESS)
    {
        LOG_PRINT(DLOG_ERROR, "[mdm_register_client_callback] return %d", ret);
        mdm_release_service();
        return;
    }

    for (i = 0; i < size; i++)
    {
        mdm_data = mdm_deactivate_knox_license(PACKAGE, old_licenses[i]);
        if (mdm_data != NULL)
        {
            mdm_free_data(mdm_data);
        }
        else
        {
            LOG_PRINT(DLOG_ERROR, "[mdm_deactivate_knox_license] return NULL");
        }
    }

    mdm_data = mdm_activate_knox_license(PACKAGE, KEY);
    if (mdm_data->ret == MDM_RESULT_SUCCESS)
    {
        LOG_PRINT(DLOG_INFO, "License Activated");
    }
    else
    {
        LOG_PRINT(DLOG_ERROR, "[mdm_activate_knox_license] return %d", (int)mdm_data->ret);
    }
    mdm_free_data(mdm_data);

    mdm_status = mdm_is_client_registered(PACKAGE);
    if (mdm_status != MDM_TRUE)
    {
        LOG_PRINT(DLOG_ERROR, "[mdm_is_client_registered] return %d", (int)mdm_status);

        mdm_data = mdm_activate_knox_license(PACKAGE, KEY);
        if (mdm_data->ret == MDM_RESULT_SUCCESS)
        {
            LOG_PRINT(DLOG_INFO, "MDM_RESULT_SUCCESS");
        }
        else
        {
            LOG_PRINT(DLOG_ERROR, "[mdm_activate_knox_license] return %d", (int)mdm_data->ret);
        }

        mdm_free_data(mdm_data);
    }
    else
    {
        LOG_PRINT(DLOG_INFO, "Client Registered");
    }

    mdm_release_service();
}


void me_disable_automatic_time(void)
{
    int ret = MDM_RESULT_SUCCESS;
    mdm_result_t mdm_result = MDM_RESULT_SUCCESS;

    ret = mdm_register_client(PACKAGE);
    switch (ret)
    {
    case MDM_RESULT_SERVICE_NOT_ENABLED:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_SERVICE_NOT_ENABLED");
        break;
    case MDM_RESULT_ACCESS_DENIED:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_ACCESS_DENIED");
        break;
    case MDM_RESULT_INVALID_PARAM:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_INVALID_PARAM");
        break;
    case MDM_RESULT_NOT_SUPPORTED:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_NOT_SUPPORTED");
        break;
    case MDM_RESULT_FAIL:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_FAIL");
        break;
    case MDM_RESULT_SUCCESS:
        LOG_PRINT(DLOG_INFO, "MDM_RESULT_SUCCESS");
        break;
    case MDM_NOT_AN_OWNER:
        LOG_PRINT(DLOG_ERROR, "MDM_NOT_AN_OWNER");
        break;
    default:
        LOG_PRINT(DLOG_ERROR, "[mdm_register_client] return %d", ret);
        break;
    }

    mdm_result = mdm_get_service();
    if (mdm_result != MDM_RESULT_SUCCESS)
    {
        LOG_PRINT(DLOG_ERROR, "[mdm_get_service] return %d", mdm_result);
        mdm_release_service();
        return;
    }

    mdm_result = mdm_set_automatic_time(MDM_FALSE);
    if (mdm_result != MDM_RESULT_SUCCESS)
    {
        LOG_PRINT(DLOG_ERROR, "[mdm_set_automatic_time] return %d", mdm_result);
    }

    mdm_release_service();
}

bool me_set_date_time(int year, int month, int day, int hour, int minute, int second)
{
    int _ret = MDM_RESULT_SUCCESS;
    bool ret = false;
    mdm_result_t res = MDM_RESULT_SUCCESS;

    LOG_PRINT(DLOG_DEBUG, "-> %4d-%02d-%02d %02d:%02d:%02d", year, month, day, hour, minute, second);

    _ret = mdm_register_client(PACKAGE);
    switch (_ret)
    {
    case MDM_RESULT_SERVICE_NOT_ENABLED:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_SERVICE_NOT_ENABLED");
        break;
    case MDM_RESULT_ACCESS_DENIED:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_ACCESS_DENIED");
        break;
    case MDM_RESULT_INVALID_PARAM:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_INVALID_PARAM");
        break;
    case MDM_RESULT_NOT_SUPPORTED:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_NOT_SUPPORTED");
        break;
    case MDM_RESULT_FAIL:
        LOG_PRINT(DLOG_ERROR, "MDM_RESULT_FAIL");
        break;
    case MDM_RESULT_SUCCESS:
        LOG_PRINT(DLOG_INFO, "MDM_RESULT_SUCCESS");
        break;
    case MDM_NOT_AN_OWNER:
        LOG_PRINT(DLOG_ERROR, "MDM_NOT_AN_OWNER");
        break;
    default:
        LOG_PRINT(DLOG_ERROR, "[mdm_register_client] return %d", ret);
        break;
    }

    res = mdm_get_service();
    if (res != MDM_RESULT_SUCCESS)
    {
        LOG_PRINT(DLOG_ERROR, "[mdm_get_service] return %d", (int)res);
        return ret;
    }

    mdm_register_client_callback(MDM_DATE_TIME_CB, _date_time_cb, NULL, NULL);

    res = mdm_set_date_time_change_enabled(true);
    if (res != MDM_RESULT_SUCCESS)
    {
        mdm_release_service();
        LOG_PRINT(DLOG_ERROR, "[mdm_set_date_time_change_enabled] return %d", (int)res);
        return ret;
    }

    res = mdm_set_date_time(day, month, year, hour, minute, second);
    if (res != MDM_RESULT_SUCCESS)
    {
        mdm_release_service();
        LOG_PRINT(DLOG_ERROR, "[mdm_set_date_time] return %d", (int)res);
        return ret;
    }

    res = mdm_set_date_time_change_enabled(false);
    if (res != MDM_RESULT_SUCCESS)
    {
        mdm_release_service();
        LOG_PRINT(DLOG_ERROR, "[mdm_set_date_time_change_enabled] return %d", (int)res);
        return ret;
    }

    ret = true;

    mdm_release_service();

    LOG_PRINT(DLOG_INFO, "Time sync completed");

    return ret;
}

Порядок вызова функций: 

...

me_init();
me_disable_automatic_time();
me_set_date_time(2020, 3, 31, 16, 54, 1);

...

МОЙ ВЫПУСК : Для функции mdm_set_automatic_time () вернул статус -13 с моим коммерческим ключом, но в то же время статус для mdm_activate_knox_license () равен MDM_RESULT_SUCCESS, НО это нормально работает, и ошибка не повторяется для нескольких устройств, это 2-3 из 42 устройств . Для этих устройств приложение было загружено с консоли Knox Configure. Какие действия я могу делать неправильно?

...