src/productivity.c

   1 /*
   2  * tel-plugin-dbus-tapi
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <assert.h>
  24 #include <unistd.h>
  25 #include <stdlib.h>
  26 #include <glib.h>
  27
  28 #include <tcore.h>
  29 #include <plugin.h>
  30 #include <server.h>
  31 #include <storage.h>
  32 #include <user_request.h>
  33 #include <co_sim.h>
  34 #include <util.h>
  35 #include <communicator.h>
  36
  37 #include <TapiCommon.h>
  38 #include <ITapiProductivity.h>
  39
  40 #include "tel_cs_conn.h"
  41 #include "common.h"
  42 #include "ts_utility.h"
  43 #include "ts_common.h"
  44 #include "ts_svr_req.h"
  45 #include "ts_noti.h"
  46 #include "modules.h"
  47
  48 #define SVCMODE_CMD_ENTER                       1
  49 #define SVCMODE_CMD_END                         2
  50 #define SVCMODE_CMD_SEND_KEYCODE        3
  51 #define SVCMODE_CMD_REQUEST_DUMP        4
  52 #define SVCMODE_CMD_DISPLAY_SCREEN      5
  53 #define SVCMODE_CMD_SCREEN_CONFIG   6
  54 #define SVCMODE_CMD_CHANGE_SVCMODE  7
  55 #define SVCMODE_CMD_DEVICE_TEST     8
  56
  57 #define FACTORY_CMD_SET_OMISSION_AVOIDANCE 0x10
  58 #define FACTORY_CMD_GET_OMISSION_AVOIDANCE 0x11
  59
  60 static int svcmode_convert_table[] = {
  61                 [TAPI_SVC_MODE_TEST_MANUAL] = 0x01,
  62                 [TAPI_SVC_MODE_NAM_EDIT] = 0x03,
  63                 [TAPI_SVC_MODE_MONITOR] = 0x04,
  64                 [TAPI_SVC_MODE_TEST_AUTO] = 0x02,
  65                 [TAPI_SVC_MODE_NAM_BASIC_EDIT] = 0x03,
  66                 [TAPI_SVC_MODE_PHONE_TEST] = 0x05,
  67                 [TAPI_SVC_MODE_OPERATOR_SPECIFIC_TEST] = 0x06,
  68 };
  69
  70 static int svcmode_convert_table_r[] = {
  71                 [0x01] = TAPI_SVC_MODE_TEST_MANUAL,
  72                 [0x02] = TAPI_SVC_MODE_TEST_AUTO,
  73                 [0x03] = TAPI_SVC_MODE_NAM_EDIT,
  74                 [0x04] = TAPI_SVC_MODE_MONITOR,
  75                 [0x05] = TAPI_SVC_MODE_PHONE_TEST,
  76                 [0x06] = TAPI_SVC_MODE_OPERATOR_SPECIFIC_TEST
  77 };
  78
  79 static int svcmode_convert_debug_dump_table[] = {
  80                 [TAPI_SVC_DBG_CP_DUMP_TARGET_ALL] = 0x00,
  81                 [TAPI_SVC_DBG_CP_DUMP_TARGET_MSG] = 0x01,
  82                 [TAPI_SVC_DBG_CP_DUMP_TARGET_LOG] = 0x02,
  83                 [TAPI_SVC_DBG_CP_DUMP_TARGET_LOG2] = 0x03,
  84                 [TAPI_SVC_DBG_CP_DUMP_TARGET_RAM_DUMP] = 0x04,
  85 };
  86
  87 void dbus_request_productivity(struct custom_data *ctx, TcorePlugin *plugin, int tapi_service_function, GArray* in_param1,
  88                 GArray* in_param2, GArray* in_param3, GArray* in_param4, GArray** out_param1, GArray** out_param2,
  89                 GArray** out_param3, GArray** out_param4, GError** error)
  90 {
  91         int api_err = TAPI_API_SUCCESS;
  92         tapi_dbus_connection_name conn_name;
  93         tapi_service_mode_t svc_mode;
  94         tapi_test_mode_sub_t test_sub;
  95         char key_code;
  96         tapi_service_mode_debug_cp_dump_t dump_type;
  97         tapi_factory_omission_avoidance_info_t *oa_info;
  98         int value;
  99         unsigned int i;
 100         char key[10] = { 0, };
 101
 102         TReturn ret;
 103         UserRequest *ur = NULL;
 104         struct tcore_user_info ui = { 0, };
 105         gchar *req_data;
 106         GHashTable *req_hash;
 107         GHashTable *req_sub_hash;
 108         int custom_command;
 109
 110         conn_name = g_array_index(in_param4, tapi_dbus_connection_name, 0);
 111
 112         ur = tcore_user_request_new(ctx->comm, tcore_plugin_get_description(plugin)->name);
 113         if (!ur) {
 114                 api_err = TAPI_API_SERVER_FAILURE;
 115                 goto OUT;
 116         }
 117
 118         ui.appname = conn_name.name;
 119         tcore_user_request_set_user_info(ur, &ui);
 120
 121         switch (tapi_service_function) {
 122                 case TAPI_CS_SVCMODE_ENTERSVCMODE:
 123                         svc_mode = svcmode_convert_table[g_array_index(in_param1, tapi_service_mode_t, 0)];
 124                         test_sub = g_array_index(in_param2, tapi_test_mode_sub_t, 0);
 125                         custom_command = SVCMODE_CMD_ENTER;
 126
 127                         req_hash = tcore_util_marshal_create();
 128                         tcore_util_marshal_add_data(req_hash, "svc_mode", &svc_mode, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 129                         tcore_util_marshal_add_data(req_hash, "test_sub", &test_sub, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 130                         tcore_util_marshal_add_data(req_hash, "custom_command", &custom_command, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 131
 132                         req_data = tcore_util_marshal_serialize(req_hash);
 133                         if (!req_data) {
 134                                 api_err = TAPI_API_OPERATION_FAILED;
 135                                 break;
 136                         }
 137
 138                         dbg("serialize data = [%s]", req_data);
 139                         tcore_user_request_set_data(ur, strlen(req_data), req_data);
 140                         tcore_user_request_set_command(ur, TREQ_CUSTOM);
 141
 142                         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 143                         if (ret != TCORE_RETURN_SUCCESS) {
 144                                 api_err = TAPI_API_OPERATION_FAILED;
 145                         }
 146
 147                         dbg("ret = 0x%x", ret);
 148                         break;
 149
 150                 case TAPI_CS_SVCMODE_ENDSVCMODE:
 151                         svc_mode = svcmode_convert_table[g_array_index(in_param1, tapi_service_mode_t, 0)];
 152                         custom_command = SVCMODE_CMD_END;
 153
 154                         req_hash = tcore_util_marshal_create();
 155                         tcore_util_marshal_add_data(req_hash, "svc_mode", &svc_mode, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 156                         tcore_util_marshal_add_data(req_hash, "custom_command", &custom_command, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 157
 158                         req_data = tcore_util_marshal_serialize(req_hash);
 159                         if (!req_data) {
 160                                 api_err = TAPI_API_OPERATION_FAILED;
 161                                 break;
 162                         }
 163
 164                         dbg("serialize data = [%s]", req_data);
 165                         tcore_user_request_set_data(ur, strlen(req_data), req_data);
 166                         tcore_user_request_set_command(ur, TREQ_CUSTOM);
 167
 168                         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 169                         if (ret != TCORE_RETURN_SUCCESS) {
 170                                 api_err = TAPI_API_OPERATION_FAILED;
 171                         }
 172
 173                         dbg("ret = 0x%x", ret);
 174                         break;
 175
 176                 case TAPI_CS_SVCMODE_PROCESS_KEYCODE:
 177                         key_code = g_array_index(in_param1, char, 0);
 178                         custom_command = SVCMODE_CMD_SEND_KEYCODE;
 179
 180                         req_hash = tcore_util_marshal_create();
 181                         tcore_util_marshal_add_data(req_hash, "key_code", &key_code, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 182                         tcore_util_marshal_add_data(req_hash, "custom_command", &custom_command, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 183
 184                         req_data = tcore_util_marshal_serialize(req_hash);
 185                         if (!req_data) {
 186                                 api_err = TAPI_API_OPERATION_FAILED;
 187                                 break;
 188                         }
 189
 190                         dbg("serialize data = [%s]", req_data);
 191                         tcore_user_request_set_data(ur, strlen(req_data), req_data);
 192                         tcore_user_request_set_command(ur, TREQ_CUSTOM);
 193
 194                         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 195                         if (ret != TCORE_RETURN_SUCCESS) {
 196                                 api_err = TAPI_API_OPERATION_FAILED;
 197                         }
 198
 199                         dbg("ret = 0x%x", ret);
 200                         break;
 201
 202                 case TAPI_CS_SVCMODE_DEBUG_DUMP:
 203                         dump_type = svcmode_convert_debug_dump_table[g_array_index(in_param1, tapi_service_mode_debug_cp_dump_t, 0)];
 204                         custom_command = SVCMODE_CMD_REQUEST_DUMP;
 205
 206                         req_hash = tcore_util_marshal_create();
 207                         tcore_util_marshal_add_data(req_hash, "dump_type", &dump_type, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 208                         tcore_util_marshal_add_data(req_hash, "custom_command", &custom_command, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 209
 210                         req_data = tcore_util_marshal_serialize(req_hash);
 211                         if (!req_data) {
 212                                 api_err = TAPI_API_OPERATION_FAILED;
 213                                 break;
 214                         }
 215
 216                         dbg("serialize data = [%s]", req_data);
 217                         tcore_user_request_set_data(ur, strlen(req_data), req_data);
 218                         tcore_user_request_set_command(ur, TREQ_CUSTOM);
 219
 220                         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 221                         if (ret != TCORE_RETURN_SUCCESS) {
 222                                 api_err = TAPI_API_OPERATION_FAILED;
 223                         }
 224
 225                         dbg("ret = 0x%x", ret);
 226                         break;
 227
 228                 case TAPI_CS_FACTORY_OMISSION_AVOIDANCE_SET:
 229                         oa_info = &g_array_index(in_param1, tapi_factory_omission_avoidance_info_t, 0);
 230                         custom_command = FACTORY_CMD_SET_OMISSION_AVOIDANCE;
 231
 232                         req_hash = tcore_util_marshal_create();
 233                         value = oa_info->cmd.write_cmd;
 234                         tcore_util_marshal_add_data(req_hash, "cmd", &value, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 235                         value = oa_info->data_cnt;
 236                         tcore_util_marshal_add_data(req_hash, "count", &value, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 237                         tcore_util_marshal_add_data(req_hash, "custom_command", &custom_command, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 238
 239                         for (i = 0; i < oa_info->data_cnt; i++) {
 240                                 dbg("i=%d [id=0x%x] [result=0x%x]", i, oa_info->data[i].test_id, oa_info->data[i].test_result);
 241                                 snprintf(key, 10, "%d", i);
 242
 243                                 req_sub_hash = tcore_util_marshal_create();
 244                                 value = oa_info->data[i].test_id;
 245                                 tcore_util_marshal_add_data(req_sub_hash, "id", &value, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 246                                 value = oa_info->data[i].test_result;
 247                                 tcore_util_marshal_add_data(req_sub_hash, "result", &value, TCORE_UTIL_MARSHAL_DATA_INT_TYPE);
 248
 249                                 tcore_util_marshal_add_data(req_hash, key, req_sub_hash, TCORE_UTIL_MARSHAL_DATA_OBJECT_TYPE);
 250                         }
 251
 252                         req_data = tcore_util_marshal_serialize(req_hash);
 253                         if (!req_data) {
 254                                 api_err = TAPI_API_OPERATION_FAILED;
 255                                 break;
 256                         }
 257
 258                         dbg("serialize data = [%s]", req_data);
 259                         tcore_user_request_set_data(ur, strlen(req_data), req_data);
 260                         tcore_user_request_set_command(ur, TREQ_CUSTOM);
 261
 262                         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 263                         if (ret != TCORE_RETURN_SUCCESS) {
 264                                 api_err = TAPI_API_OPERATION_FAILED;
 265                         }
 266
 267                         dbg("ret = 0x%x", ret);
 268                         break;
 269
 270                 case TAPI_CS_IMEI_STARTFACTORYPROCESS:
 271                 case TAPI_CS_IMEI_COMPARE_ITEM_IND:
 272                 case TAPI_CS_FACTORY_OMISSION_AVOIDANCE_GET:
 273                 default:
 274                         api_err = TAPI_API_NOT_SUPPORTED;
 275                         break;
 276         }
 277
 278 OUT:
 279         if (api_err != TAPI_API_SUCCESS) {
 280                 tcore_user_request_free(ur);
 281         }
 282         g_array_append_vals(*out_param1, &api_err, sizeof(int));
 283 }
 284
 285 TReturn dbus_response_productivity(struct custom_data *ctx, UserRequest *ur, const char *appname,
 286                 enum tcore_response_command command, unsigned int data_len, const void *data)
 287 {
 288         GHashTable *resp_hash;
 289         int custom_command;
 290         tapi_service_mode_t svc_mode;
 291         int status;
 292         int request_id = 0;
 293         int ret = TAPI_API_SUCCESS;
 294
 295         dbg("command = 0x%x", command);
 296
 297         if (command != TRESP_CUSTOM)
 298                 return TRUE;
 299
 300         resp_hash = tcore_util_marshal_deserialize_string(data);
 301         if (!resp_hash) {
 302                 warn("hash corrupted");
 303                 return TCORE_RETURN_FAILURE;
 304         }
 305
 306         custom_command = tcore_util_marshal_get_int(resp_hash, "custom_command");
 307         dbg("custom_command = %d", custom_command);
 308
 309         switch (custom_command) {
 310                 case SVCMODE_CMD_ENTER:
 311                         svc_mode = svcmode_convert_table_r[g_value_get_int(g_hash_table_lookup(resp_hash, "svc_mode"))];
 312                         tcore_util_marshal_destory(resp_hash);
 313
 314                         dbg("svc_mode = %d", svc_mode);
 315                         return ts_delivery_event(ctx->EvtDeliveryHandle, TAPI_EVENT_CLASS_SVCMODE, TAPI_EVENT_SVCMODE_START_NOTI,
 316                                         appname, request_id, ret, sizeof(tapi_service_mode_t), &svc_mode);
 317                         break;
 318
 319                 case SVCMODE_CMD_END:
 320                         svc_mode = svcmode_convert_table_r[g_value_get_int(g_hash_table_lookup(resp_hash, "svc_mode"))];
 321                         tcore_util_marshal_destory(resp_hash);
 322
 323                         dbg("svc_mode = %d", svc_mode);
 324                         return ts_delivery_event(ctx->EvtDeliveryHandle, TAPI_EVENT_CLASS_SVCMODE, TAPI_EVENT_SVCMODE_END_NOTI,
 325                                         appname, request_id, ret, sizeof(tapi_service_mode_t), &svc_mode);
 326                         break;
 327
 328                 case SVCMODE_CMD_SEND_KEYCODE:
 329                         dbg("send_keycode response. unused.");
 330                         break;
 331
 332                 case SVCMODE_CMD_REQUEST_DUMP:
 333                         status = svcmode_convert_table_r[g_value_get_int(g_hash_table_lookup(resp_hash, "status"))];
 334                         tcore_util_marshal_destory(resp_hash);
 335
 336                         dbg("status = %d", status);
 337                         return ts_delivery_event(ctx->EvtDeliveryHandle, TAPI_EVENT_CLASS_SVCMODE, TAPI_EVENT_SVCMODE_DEBUG_DUMP_CNF,
 338                                         appname, request_id, ret, sizeof(int), &status);
 339                         break;
 340
 341                 case FACTORY_CMD_SET_OMISSION_AVOIDANCE:
 342                         status = svcmode_convert_table_r[g_value_get_int(g_hash_table_lookup(resp_hash, "status"))];
 343                         tcore_util_marshal_destory(resp_hash);
 344
 345                         dbg("status = %d", status);
 346                         return ts_delivery_event(ctx->EvtDeliveryHandle, TAPI_EVENT_CLASS_FACTORY,
 347                                         TAPI_EVENT_FACTORY_OMISSION_AVOIDANCE_SET_CNF, appname, request_id, ret, sizeof(int), &status);
 348                         break;
 349         }
 350
 351         return TRUE;
 352 }
 353
 354 TReturn dbus_notification_productivity(struct custom_data *ctx, CoreObject *source, enum tcore_notification_command command,
 355                 unsigned int data_len, const void *data)
 356 {
 357         tapi_service_display_info_t noti_display_screen;
 358         tapi_device_info_t noti_device_info;
 359         int svc_mode;
 360         tapi_screen_config_t noti_screen_config;
 361
 362         GHashTable *noti_hash;
 363         GHashTable *noti_sub_hash;
 364         int custom_command;
 365         int i;
 366         int count;
 367         char key[10] = { 0, };
 368         int line = 0;
 369         int reverse = 0;
 370         char *text = NULL;
 371
 372         dbg("command = 0x%x", command);
 373
 374         if (command != TNOTI_CUSTOM)
 375                 return TRUE;
 376
 377         noti_hash = tcore_util_marshal_deserialize_string(data);
 378         if (!noti_hash) {
 379                 warn("hash corrupted");
 380                 return TCORE_RETURN_FAILURE;
 381         }
 382
 383         custom_command = tcore_util_marshal_get_int(noti_hash, "custom_command");
 384         dbg("custom_command = %d", custom_command);
 385
 386         switch (custom_command) {
 387                 case SVCMODE_CMD_DISPLAY_SCREEN:
 388                         memset(&noti_display_screen, 0, sizeof(tapi_service_display_info_t));
 389
 390                         count = tcore_util_marshal_get_int(noti_hash, "count");
 391                         noti_display_screen.num_of_lines = count;
 392
 393                         dbg("count = %d", count);
 394
 395                         for (i = 0; i < count; i++) {
 396                                 snprintf(key, 10, "%d", i);
 397                                 noti_sub_hash = tcore_util_marshal_get_object(noti_hash, key);
 398                                 if (noti_sub_hash) {
 399                                         line = tcore_util_marshal_get_int(noti_sub_hash, "line");
 400                                         reverse = tcore_util_marshal_get_int(noti_sub_hash, "reverse");
 401                                         text = tcore_util_marshal_get_string(noti_sub_hash, "text");
 402
 403                                         noti_display_screen.display[i].line = line;
 404                                         noti_display_screen.display[i].reverse = reverse;
 405                                         snprintf(noti_display_screen.display[i].string, 30, "%s", text);
 406                                 }
 407
 408                                 dbg("i = %d, [%02d][%d] [%s]", i, line, reverse, text);
 409
 410                                 if (text)
 411                                         free(text);
 412
 413                                 if (i > 100)
 414                                         break;
 415                         }
 416
 417                         ts_delivery_event(ctx->EvtDeliveryHandle, TAPI_EVENT_CLASS_SVCMODE, TAPI_EVENT_SVCMODE_DISP_SCREEN_NOTI, NULL, 0,
 418                                         TAPI_API_SUCCESS, sizeof(tapi_service_display_info_t), (void *) &noti_display_screen);
 419                         break;
 420
 421                 case SVCMODE_CMD_SCREEN_CONFIG:
 422                         memset(&noti_screen_config, 0, sizeof(tapi_screen_config_t));
 423                         noti_screen_config.line_number = tcore_util_marshal_get_int(noti_hash, "line_number");
 424                         noti_screen_config.keypad = tcore_util_marshal_get_int(noti_hash, "keypad");
 425
 426                         ts_delivery_event(ctx->EvtDeliveryHandle, TAPI_EVENT_CLASS_SVCMODE, TAPI_EVENT_SVCMODE_SCREEN_CFG_NOTI,
 427                                         NULL, 0, TAPI_API_SUCCESS, sizeof(tapi_screen_config_t), (void *) &noti_screen_config);
 428                         break;
 429
 430                 case SVCMODE_CMD_CHANGE_SVCMODE:
 431                         svc_mode = tcore_util_marshal_get_int(noti_hash, "svc_mode");
 432
 433                         ts_delivery_event(ctx->EvtDeliveryHandle, TAPI_EVENT_CLASS_SVCMODE, TAPI_EVENT_SVCMODE_CHANGE_NOTI, NULL, 0,
 434                                         TAPI_API_SUCCESS, sizeof(int), (void *) &svc_mode);
 435                         break;
 436
 437                 case SVCMODE_CMD_DEVICE_TEST:
 438                         memset(&noti_device_info, 0, sizeof(tapi_device_info_t));
 439                         noti_device_info.device_id = tcore_util_marshal_get_int(noti_hash, "device_id");
 440                         noti_device_info.device_status = tcore_util_marshal_get_int(noti_hash, "device_status");
 441
 442                         ts_delivery_event(ctx->EvtDeliveryHandle, TAPI_EVENT_CLASS_SVCMODE, TAPI_EVENT_SVCMODE_SCREEN_CFG_NOTI,
 443                                         NULL, 0, TAPI_API_SUCCESS, sizeof(tapi_device_info_t), (void *) &noti_device_info);
 444                         break;
 445
 446                 case SVCMODE_CMD_SEND_KEYCODE:
 447                         dbg("keycode notification. unused.");
 448                         break;
 449
 450                 default:
 451                         break;
 452         }
 453
 454         return TRUE;
 455 }