ism/modules/panelagent/ecoresocket/ecore_socket_panel_agent_module.cpp

   1 /*
   2  * ISF(Input Service Framework)
   3  *
   4  * ISF is based on SCIM 1.4.7 and extended for supporting more mobile fitable.
   5  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   6  *
   7  * Contact: Li Zhang <li2012.zhang@samsung.com>
   8  *
   9  * This library is free software; you can redistribute it and/or modify it under
  10  * the terms of the GNU Lesser General Public License as published by the
  11  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  12  * any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  15  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  17  * License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  21  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  *
  23  */
  24
  25 #define Uses_SCIM_TRANSACTION
  26 #define Uses_SCIM_TRANS_COMMANDS
  27 #define Uses_SCIM_PANEL_AGENT
  28 #define Uses_SCIM_HELPER
  29 #define Uses_SCIM_SOCKET
  30 #define Uses_SCIM_EVENT
  31 #define Uses_SCIM_CONFIG
  32 #define Uses_SCIM_CONFIG_MODULE
  33 #define Uses_SCIM_CONFIG_PATH
  34 #define Uses_SCIM_UTILITY
  35
  36 #include <string.h>
  37 #include <sys/types.h>
  38 #include <sys/times.h>
  39 #include <dlog.h>
  40 #include <unistd.h>
  41 #include <Ecore.h>
  42 #include "scim_private.h"
  43 #include "scim.h"
  44 #include "scim_stl_map.h"
  45 #include "isf_debug.h"
  46
  47 #ifdef LOG_TAG
  48 # undef LOG_TAG
  49 #endif
  50 #define LOG_TAG             "ISF_ECORE_SOCKET_MODULE"
  51
  52 #define MIN_REPEAT_TIME     2.0
  53
  54 #define IMEMANAGER_PRIVILEGE "http://tizen.org/privilege/imemanager"
  55
  56 #define SCIM_CONFIG_PANEL_SOCKET_CONFIG_READONLY    "/Panel/Socket/ConfigReadOnly"
  57
  58 namespace scim
  59 {
  60
  61 struct HelperClientStub {
  62     int id;
  63     int ref;
  64
  65     HelperClientStub(int i = 0, int r = 0) : id(i), ref(r) { }
  66 };
  67
  68 struct IMControlStub {
  69     std::vector<ISE_INFO> info;
  70     std::vector<int> count;
  71 };
  72
  73 #define DEFAULT_CONTEXT_VALUE 0xfff
  74
  75 #define scim_module_init ecoresocket_LTX_scim_module_init
  76 #define scim_module_exit ecoresocket_LTX_scim_module_exit
  77 #define scim_panel_agent_module_init ecoresocket_LTX_scim_panel_agent_module_init
  78 #define scim_panel_agent_module_get_instance ecoresocket_LTX_scim_panel_agent_module_get_instance
  79
  80
  81 //==================================== PanelAgent ===========================
  82 class EcoreSocketPanelAgent: public PanelAgentBase
  83 {
  84     bool                                m_should_exit;
  85
  86     int                                 m_socket_timeout;
  87     String                              m_socket_address;
  88     SocketServer                        m_socket_server;
  89
  90     Transaction                         m_send_trans;
  91     Transaction                         m_recv_trans;
  92     Transaction                         m_nest_trans;
  93
  94     bool                                m_should_shared_ise;
  95     bool                                m_ise_exiting;
  96
  97     std::vector<Ecore_Fd_Handler*>     _read_handler_list;
  98
  99     InfoManager* m_info_manager;
 100
 101 public:
 102     EcoreSocketPanelAgent()
 103         : PanelAgentBase ("ecore_socket"),
 104           m_should_exit(false),
 105           m_socket_timeout(scim_get_default_socket_timeout()),
 106           m_should_shared_ise(false),
 107           m_ise_exiting(false) {
 108         m_socket_server.signal_connect_accept(slot(this, &EcoreSocketPanelAgent::socket_accept_callback));
 109         m_socket_server.signal_connect_receive(slot(this, &EcoreSocketPanelAgent::socket_receive_callback));
 110         m_socket_server.signal_connect_exception(slot(this, &EcoreSocketPanelAgent::socket_exception_callback));
 111     }
 112
 113     ~EcoreSocketPanelAgent() {
 114         for (unsigned int ii = 0; ii < _read_handler_list.size(); ++ii) {
 115             ecore_main_fd_handler_del(_read_handler_list[ii]);
 116         }
 117         _read_handler_list.clear();
 118     }
 119
 120     bool initialize(InfoManager* info_manager, const String& display, bool resident) {
 121         LOGD ("");
 122         m_info_manager = info_manager;
 123         m_socket_address = scim_get_default_panel_socket_address(display);
 124
 125         m_socket_server.shutdown();
 126
 127         if (m_socket_server.create(SocketAddress(m_socket_address))) {
 128             Ecore_Fd_Handler* panel_agent_read_handler = NULL;
 129             panel_agent_read_handler = ecore_main_fd_handler_add(get_server_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
 130             _read_handler_list.push_back(panel_agent_read_handler);
 131             return true;
 132         }
 133         LOGE("create server failed\n");
 134         return false;
 135     }
 136
 137     bool valid(void) const {
 138         return m_socket_server.valid();
 139     }
 140
 141     void stop(void) {
 142         SCIM_DEBUG_MAIN(1) << "PanelAgent::stop ()\n";
 143         LOGD ("");
 144         lock();
 145         m_should_exit = true;
 146         unlock();
 147         SocketClient  client;
 148         if (client.connect(SocketAddress(m_socket_address))) {
 149             client.close();
 150         }
 151     }
 152 private:
 153     void update_panel_event(int client, uint32 context_id, int cmd, uint32 nType, uint32 nValue) {
 154         LOGD ("client id:%d\n", client);
 155         Socket client_socket(client);
 156         m_send_trans.clear();
 157         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 158         m_send_trans.put_data(context_id);
 159         m_send_trans.put_command(cmd);
 160         m_send_trans.put_data(nType);
 161         m_send_trans.put_data(nValue);
 162         m_send_trans.write_to_socket(client_socket);
 163     }
 164
 165     void move_preedit_caret(int client, uint32 context_id, uint32 position) {
 166         SCIM_DEBUG_MAIN(1) << "PanelAgent::move_preedit_caret (" << position << ")\n";
 167         LOGD ("client id:%d\n", client);
 168         Socket client_socket(client);
 169         m_send_trans.clear();
 170         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 171         m_send_trans.put_data((uint32) context_id);
 172         m_send_trans.put_command(SCIM_TRANS_CMD_MOVE_PREEDIT_CARET);
 173         m_send_trans.put_data((uint32) position);
 174         m_send_trans.write_to_socket(client_socket);
 175     }
 176
 177 //useless
 178 #if 0
 179     void request_help(int client_id, uint32 context_id) {
 180         SCIM_DEBUG_MAIN(1) << "PanelAgent::request_help ()\n";
 181         LOGD ("client id:%d", client_id);
 182
 183         Socket client_socket(client_id);
 184         m_send_trans.clear();
 185         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 186         m_send_trans.put_data((uint32) context_id);
 187         m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_REQUEST_HELP);
 188         m_send_trans.write_to_socket(client_socket);
 189
 190     }
 191
 192     void request_factory_menu(int client_id, uint32 context_id) {
 193         LOGD ("client id:%d", client_id);
 194         Socket client_socket(client_id);
 195         m_send_trans.clear();
 196         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 197         m_send_trans.put_data((uint32) context_id);
 198         m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_REQUEST_FACTORY_MENU);
 199         m_send_trans.write_to_socket(client_socket);
 200     }
 201 #endif
 202
 203     void reset_keyboard_ise(int client, uint32 context_id) {
 204         LOGD ("client id:%d\n", client);
 205         Socket client_socket(client);
 206         m_send_trans.clear();
 207         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 208         m_send_trans.put_data((uint32) context_id);
 209         m_send_trans.put_command(ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE);
 210         m_send_trans.write_to_socket(client_socket);
 211     }
 212
 213     void update_keyboard_ise_list(int client, uint32 context) {
 214         LOGD ("client id:%d\n", client);
 215
 216         Socket client_socket(client);
 217         m_send_trans.clear();
 218         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 219         m_send_trans.put_data((uint32) context);
 220         m_send_trans.put_command(ISM_TRANS_CMD_PANEL_UPDATE_KEYBOARD_ISE);
 221         m_send_trans.write_to_socket(client_socket);
 222     }
 223
 224     void change_factory(int client, uint32 context, const String&  uuid) {
 225         SCIM_DEBUG_MAIN(1) << "PanelAgent::change_factory (" << uuid << ")\n";
 226         LOGD ("client id:%d\n", client);
 227
 228         Socket client_socket(client);
 229         m_send_trans.clear();
 230         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 231         m_send_trans.put_data((uint32) context);
 232         m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_CHANGE_FACTORY);
 233         m_send_trans.put_data(uuid);
 234         m_send_trans.write_to_socket(client_socket);
 235     }
 236
 237     void helper_candidate_show(int client, uint32 context, const String&  uuid) {
 238         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 239         LOGD ("client id:%d\n", client);
 240
 241
 242         Socket client_socket(client);
 243
 244         m_send_trans.clear();
 245         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 246         m_send_trans.put_data(context);
 247         m_send_trans.put_data(uuid);
 248         m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_SHOW);
 249         m_send_trans.write_to_socket(client_socket);
 250     }
 251
 252     void helper_candidate_hide(int client, uint32 context, const String&  uuid) {
 253         LOGD ("client id:%d\n", client);
 254
 255         Socket client_socket(client);
 256
 257         m_send_trans.clear();
 258         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 259         m_send_trans.put_data(context);
 260         m_send_trans.put_data(uuid);
 261         m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_HIDE);
 262         m_send_trans.write_to_socket(client_socket);
 263     }
 264
 265     void candidate_more_window_show(int client, uint32 context) {
 266         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 267         LOGD ("client id:%d\n", client);
 268
 269
 270         Socket client_socket(client);
 271
 272         m_send_trans.clear();
 273         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 274         m_send_trans.put_data(context);
 275         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 276             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 277         m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_SHOW);
 278         m_send_trans.write_to_socket(client_socket);
 279     }
 280
 281     void candidate_more_window_hide(int client, uint32 context) {
 282         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 283         LOGD ("client id:%d\n", client);
 284
 285         Socket client_socket(client);
 286
 287         m_send_trans.clear();
 288         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 289         m_send_trans.put_data(context);
 290         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 291             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 292         m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_HIDE);
 293         m_send_trans.write_to_socket(client_socket);
 294     }
 295
 296     void update_helper_lookup_table(int client, uint32 context, const String& uuid, const LookupTable& table) {
 297         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 298         LOGD ("client id:%d\n", client);
 299
 300         Socket client_socket(client);
 301
 302         m_send_trans.clear();
 303         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 304         m_send_trans.put_data(context);
 305         m_send_trans.put_data(uuid);
 306         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_LOOKUP_TABLE);
 307         m_send_trans.put_data(table);
 308         m_send_trans.write_to_socket(client_socket);
 309     }
 310
 311     void select_aux(int client, uint32 contextid, uint32 item) {
 312         SCIM_DEBUG_MAIN(1) << "PanelAgent::select_aux (" << item << ")\n";
 313         LOGD ("client id:%d\n", client);
 314
 315         Socket client_socket(client);
 316         m_send_trans.clear();
 317         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 318         m_send_trans.put_data((uint32) contextid);
 319
 320         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 321             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 322
 323         m_send_trans.put_command(ISM_TRANS_CMD_SELECT_AUX);
 324         m_send_trans.put_data((uint32)item);
 325         m_send_trans.write_to_socket(client_socket);
 326     }
 327
 328     void select_candidate(int client, uint32 context, uint32 item) {
 329         LOGD ("client id:%d\n", client);
 330
 331         Socket client_socket(client);
 332         m_send_trans.clear();
 333         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 334         m_send_trans.put_data((uint32) context);
 335
 336         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 337             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 338
 339         m_send_trans.put_command(SCIM_TRANS_CMD_SELECT_CANDIDATE);
 340         m_send_trans.put_data((uint32)item);
 341         m_send_trans.write_to_socket(client_socket);
 342     }
 343
 344     void lookup_table_page_up(int client, uint32 context) {
 345         SCIM_DEBUG_MAIN(1) << "PanelAgent::lookup_table_page_up ()\n";
 346         LOGD ("client id:%d\n", client);
 347
 348         Socket client_socket(client);
 349         m_send_trans.clear();
 350         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 351         m_send_trans.put_data((uint32) context);
 352
 353         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 354             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 355
 356         m_send_trans.put_command(SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_UP);
 357         m_send_trans.write_to_socket(client_socket);
 358     }
 359
 360     void lookup_table_page_down(int client, uint32 context) {
 361         LOGD ("client id:%d\n", client);
 362
 363         Socket client_socket(client);
 364         m_send_trans.clear();
 365         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 366         m_send_trans.put_data((uint32) context);
 367
 368         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 369             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 370
 371         m_send_trans.put_command(SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_DOWN);
 372         m_send_trans.write_to_socket(client_socket);
 373     }
 374
 375     void update_lookup_table_page_size(int client, uint32 context, uint32 size) {
 376         LOGD ("client id:%d\n", client);
 377
 378         Socket client_socket(client);
 379         m_send_trans.clear();
 380         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 381         m_send_trans.put_data((uint32) context);
 382
 383         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 384             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 385
 386         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE_PAGE_SIZE);
 387         m_send_trans.put_data(size);
 388         m_send_trans.write_to_socket(client_socket);
 389     }
 390
 391     void update_candidate_item_layout(int client, uint32 context, const std::vector<uint32>& row_items) {
 392         LOGD ("client id:%d\n", client);
 393
 394         Socket client_socket(client);
 395         m_send_trans.clear();
 396         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 397         m_send_trans.put_data((uint32) context);
 398
 399         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 400             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 401
 402         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_ITEM_LAYOUT);
 403         m_send_trans.put_data(row_items);
 404         m_send_trans.write_to_socket(client_socket);
 405     }
 406
 407     void select_associate(int client, uint32 context, uint32 item) {
 408         LOGD ("client id:%d\n", client);
 409
 410         Socket client_socket(client);
 411         m_send_trans.clear();
 412         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 413         m_send_trans.put_data((uint32) context);
 414
 415         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 416             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 417
 418         m_send_trans.put_command(ISM_TRANS_CMD_SELECT_ASSOCIATE);
 419         m_send_trans.put_data((uint32)item);
 420         m_send_trans.write_to_socket(client_socket);
 421     }
 422
 423     void associate_table_page_up(int client, uint32 context) {
 424         LOGD ("client id:%d\n", client);
 425
 426         Socket client_socket(client);
 427         m_send_trans.clear();
 428         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 429         m_send_trans.put_data((uint32) context);
 430
 431         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 432             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 433
 434         m_send_trans.put_command(ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_UP);
 435         m_send_trans.write_to_socket(client_socket);
 436     }
 437
 438     void associate_table_page_down(int client, uint32 context) {
 439         LOGD ("client id:%d\n", client);
 440
 441         Socket client_socket(client);
 442         m_send_trans.clear();
 443         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 444         m_send_trans.put_data((uint32) context);
 445
 446         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 447             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 448
 449         m_send_trans.put_command(ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_DOWN);
 450         m_send_trans.write_to_socket(client_socket);
 451     }
 452
 453     void update_associate_table_page_size(int client, uint32 context, uint32 size) {
 454         LOGD ("client id:%d\n", client);
 455
 456         Socket client_socket(client);
 457         m_send_trans.clear();
 458         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 459         m_send_trans.put_data((uint32) context);
 460
 461         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 462             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 463
 464         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE_PAGE_SIZE);
 465         m_send_trans.put_data(size);
 466         m_send_trans.write_to_socket(client_socket);
 467     }
 468
 469     void update_displayed_candidate_number(int client, uint32 context, uint32 size) {
 470         LOGD ("client id:%d\n", client);
 471
 472         Socket client_socket(client);
 473         m_send_trans.clear();
 474         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 475         m_send_trans.put_data((uint32) context);
 476
 477         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 478             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 479
 480         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_DISPLAYED_CANDIDATE);
 481         m_send_trans.put_data(size);
 482         m_send_trans.write_to_socket(client_socket);
 483     }
 484
 485     void send_longpress_event(int client, uint32 context, int index) {
 486         LOGD ("client id:%d\n", client);
 487
 488         Socket client_socket(client);
 489         m_send_trans.clear();
 490         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 491         m_send_trans.put_data((uint32) context);
 492
 493         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 494             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 495
 496         m_send_trans.put_command(ISM_TRANS_CMD_LONGPRESS_CANDIDATE);
 497         m_send_trans.put_data(index);
 498         m_send_trans.write_to_socket(client_socket);
 499     }
 500
 501     void trigger_property(int client, uint32 context, const String&  property) {
 502         LOGD ("client id:%d\n", client);
 503
 504         Socket client_socket(client);
 505         m_send_trans.clear();
 506         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 507         m_send_trans.put_data((uint32) context);
 508
 509         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
 510             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 511
 512         m_send_trans.put_command(SCIM_TRANS_CMD_TRIGGER_PROPERTY);
 513         m_send_trans.put_data(property);
 514         m_send_trans.write_to_socket(client_socket);
 515     }
 516
 517     void focus_out_helper(int client, uint32 context, const String& uuid) {
 518         LOGD ("client id:%d\n", client);
 519
 520         Socket client_socket(client);
 521         m_send_trans.clear();
 522         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 523         m_send_trans.put_data(context);
 524         m_send_trans.put_data(uuid);
 525         m_send_trans.put_command(SCIM_TRANS_CMD_FOCUS_OUT);
 526         m_send_trans.write_to_socket(client_socket);
 527     }
 528
 529     void focus_in_helper(int client, uint32 context, const String& uuid) {
 530         LOGD ("client id:%d\n", client);
 531
 532         Socket client_socket(client);
 533         m_send_trans.clear();
 534         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 535         m_send_trans.put_data(context);
 536         m_send_trans.put_data(uuid);
 537         m_send_trans.put_command(SCIM_TRANS_CMD_FOCUS_IN);
 538         m_send_trans.write_to_socket(client_socket);
 539     }
 540
 541     void show_helper(int client, uint32 context, const String& uuid, char* data, size_t& len) {
 542         LOGD ("client id:%d\n", client);
 543
 544         Socket client_socket(client);
 545         m_send_trans.clear();
 546         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 547         m_send_trans.put_data(context);
 548         m_send_trans.put_data(uuid);
 549         m_send_trans.put_command(ISM_TRANS_CMD_SHOW_ISE_PANEL);
 550         m_send_trans.put_data(data, len);
 551         m_send_trans.write_to_socket(client_socket);
 552     }
 553
 554     void hide_helper(int client, uint32 context, const String& uuid) {
 555         LOGD ("client id:%d\n", client);
 556
 557         Socket client_socket(client);
 558         m_send_trans.clear();
 559         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 560         m_send_trans.put_data(context);
 561         m_send_trans.put_data(uuid);
 562         m_send_trans.put_command(ISM_TRANS_CMD_HIDE_ISE_PANEL);
 563         m_send_trans.write_to_socket(client_socket);
 564     }
 565
 566     void set_helper_mode(int client, uint32 context, const String& uuid, uint32& mode) {
 567         LOGD ("client id:%d\n", client);
 568
 569         Socket client_socket(client);
 570         m_send_trans.clear();
 571         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 572         m_send_trans.put_data(context);
 573         m_send_trans.put_data(uuid);
 574         m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_MODE);
 575         m_send_trans.put_data(mode);
 576         m_send_trans.write_to_socket(client_socket);
 577     }
 578
 579     void set_helper_language(int client, uint32 context, const String& uuid, uint32& language) {
 580         LOGD ("client id:%d\n", client);
 581
 582         Socket client_socket(client);
 583         m_send_trans.clear();
 584         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 585         m_send_trans.put_data(context);
 586         m_send_trans.put_data(uuid);
 587         m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_LANGUAGE);
 588         m_send_trans.put_data(language);
 589         m_send_trans.write_to_socket(client_socket);
 590     }
 591
 592     void set_helper_imdata(int client, uint32 context, const String& uuid, const char* imdata, size_t& len) {
 593         LOGD ("client id:%d\n", client);
 594
 595         Socket client_socket(client);
 596         m_send_trans.clear();
 597         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 598         m_send_trans.put_data(context);
 599         m_send_trans.put_data(uuid);
 600         m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_IMDATA);
 601         m_send_trans.put_data(imdata, len);
 602         m_send_trans.write_to_socket(client_socket);
 603     }
 604
 605     void set_helper_return_key_type(int client, uint32 context, const String& uuid, uint32 type) {
 606         LOGD ("client id:%d\n", client);
 607
 608         Socket client_socket(client);
 609         m_send_trans.clear();
 610         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 611         m_send_trans.put_data(context);
 612         m_send_trans.put_data(uuid);
 613         m_send_trans.put_command(ISM_TRANS_CMD_SET_RETURN_KEY_TYPE);
 614         m_send_trans.put_data(type);
 615         m_send_trans.write_to_socket(client_socket);
 616     }
 617
 618     void get_helper_return_key_type(int client, uint32 context, const String& uuid, _OUT_ uint32& type) {
 619         LOGD ("client id:%d\n", client);
 620
 621         Socket client_socket(client);
 622         Transaction trans;
 623         trans.clear();
 624         trans.put_command(SCIM_TRANS_CMD_REPLY);
 625         trans.put_data(context);
 626         trans.put_data(uuid);
 627         trans.put_command(ISM_TRANS_CMD_GET_RETURN_KEY_TYPE);
 628
 629         int cmd;
 630
 631         if (trans.write_to_socket(client_socket)
 632             && trans.read_from_socket(client_socket)
 633             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 634             && trans.get_data(type)) {
 635             SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
 636
 637         } else {
 638             LOGW ("read failed\n");
 639         }
 640     }
 641
 642     void set_helper_return_key_disable(int client, uint32 context, const String& uuid, uint32 disabled) {
 643         LOGD ("client id:%d\n", client);
 644
 645         Socket client_socket(client);
 646         m_send_trans.clear();
 647         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 648         m_send_trans.put_data(context);
 649         m_send_trans.put_data(uuid);
 650         m_send_trans.put_command(ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE);
 651         m_send_trans.put_data(disabled);
 652         m_send_trans.write_to_socket(client_socket);
 653     }
 654
 655     void get_helper_return_key_disable(int client, uint32 context, const String& uuid, _OUT_ uint32& disabled) {
 656
 657         Socket client_socket(client);
 658         LOGD ("client id:%d", client);
 659
 660         Transaction trans;
 661
 662         trans.clear();
 663         trans.put_command(SCIM_TRANS_CMD_REPLY);
 664         trans.put_data(context);
 665         trans.put_data(uuid);
 666         trans.put_command(ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE);
 667
 668         int cmd;
 669
 670         if (trans.write_to_socket(client_socket)
 671             && trans.read_from_socket(client_socket)
 672             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 673             && trans.get_data(disabled)) {
 674             SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
 675
 676         } else {
 677             LOGW ("read failed");
 678         }
 679     }
 680
 681     void set_helper_layout(int client, uint32 context, const String& uuid, uint32& layout) {
 682         LOGD ("client id:%d\n", client);
 683
 684         Socket client_socket(client);
 685         m_send_trans.clear();
 686         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 687         m_send_trans.put_data(context);
 688         m_send_trans.put_data(uuid);
 689         m_send_trans.put_command(ISM_TRANS_CMD_SET_LAYOUT);
 690         m_send_trans.put_data(layout);
 691         m_send_trans.write_to_socket(client_socket);
 692     }
 693
 694     void set_helper_input_mode(int client, uint32 context, const String& uuid, uint32& mode) {
 695         LOGD ("client id:%d\n", client);
 696
 697         Socket client_socket(client);
 698         m_send_trans.clear();
 699         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 700         m_send_trans.put_data(context);
 701         m_send_trans.put_data(uuid);
 702         m_send_trans.put_command(ISM_TRANS_CMD_SET_INPUT_MODE);
 703         m_send_trans.put_data(mode);
 704         m_send_trans.write_to_socket(client_socket);
 705     }
 706
 707     void set_helper_input_hint(int client, uint32 context, const String& uuid, uint32& hint) {
 708         LOGD ("client id:%d\n", client);
 709
 710         Socket client_socket(client);
 711         m_send_trans.clear();
 712         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 713         m_send_trans.put_data(context);
 714         m_send_trans.put_data(uuid);
 715         m_send_trans.put_command(ISM_TRANS_CMD_SET_INPUT_HINT);
 716         m_send_trans.put_data(hint);
 717         m_send_trans.write_to_socket(client_socket);
 718     }
 719
 720     void set_helper_bidi_direction(int client, uint32 context, const String& uuid, uint32& direction) {
 721         LOGD ("client id:%d\n", client);
 722
 723         Socket client_socket(client);
 724         m_send_trans.clear();
 725         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 726         m_send_trans.put_data(context);
 727         m_send_trans.put_data(uuid);
 728         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION);
 729         m_send_trans.put_data(direction);
 730         m_send_trans.write_to_socket(client_socket);
 731     }
 732
 733     void set_helper_caps_mode(int client, uint32 context, const String& uuid, uint32& mode) {
 734         LOGD ("client id:%d\n", client);
 735
 736         Socket client_socket(client);
 737         m_send_trans.clear();
 738         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 739         m_send_trans.put_data(context);
 740         m_send_trans.put_data(uuid);
 741         m_send_trans.put_command(ISM_TRANS_CMD_SET_CAPS_MODE);
 742         m_send_trans.put_data(mode);
 743         m_send_trans.write_to_socket(client_socket);
 744     }
 745
 746     void show_helper_option_window(int client, uint32 context, const String& uuid) {
 747         LOGD ("client id:%d\n", client);
 748
 749         Socket client_socket(client);
 750         m_send_trans.clear();
 751         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 752         m_send_trans.put_data(context);
 753         m_send_trans.put_data(uuid);
 754         m_send_trans.put_command(ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW);
 755         m_send_trans.write_to_socket(client_socket);
 756     }
 757
 758     bool process_key_event(int client, uint32 context, const String& uuid, KeyEvent& key, uint32 serial) {
 759         LOGD ("client id:%d\n", client);
 760
 761         Socket client_socket(client);
 762
 763         Transaction trans;
 764
 765         trans.clear();
 766         trans.put_command(SCIM_TRANS_CMD_REPLY);
 767         trans.put_data(context);
 768         trans.put_data(uuid);
 769         trans.put_command(SCIM_TRANS_CMD_PROCESS_KEY_EVENT);
 770         trans.put_data(key);
 771         trans.put_data(serial);
 772
 773         if (trans.write_to_socket(client_socket)) {
 774             SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
 775             return true;
 776         } else {
 777             LOGW ("read failed\n");
 778         }
 779
 780         return false;
 781     }
 782
 783     bool get_helper_geometry(int client, uint32 context, String& uuid, _OUT_ struct rectinfo& info) {
 784         LOGD ("client id:%d\n", client);
 785
 786         Socket client_socket(client);
 787
 788         Transaction trans;
 789         trans.clear();
 790         trans.put_command(SCIM_TRANS_CMD_REPLY);
 791         trans.put_data(context);
 792         trans.put_data(uuid);
 793         trans.put_command(ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY);
 794
 795         if (trans.write_to_socket(client_socket)) {
 796             int cmd;
 797
 798             trans.clear();
 799
 800             if (trans.read_from_socket(client_socket)
 801                 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 802                 && trans.get_data(info.pos_x)
 803                 && trans.get_data(info.pos_y)
 804                 && trans.get_data(info.width)
 805                 && trans.get_data(info.height)) {
 806                 SCIM_DEBUG_MAIN(1) << __func__ << " is successful\n";
 807                 return true;
 808             } else
 809                 LOGW ("read failed\n");
 810         } else
 811             LOGW ("write failed\n");
 812
 813         return false;
 814     }
 815
 816     void get_helper_imdata(int client, uint32 context, String& uuid, char** imdata, size_t& len) {
 817         LOGD ("client id:%d\n", client);
 818         Socket client_socket(client);
 819
 820         Transaction trans;
 821         trans.clear();
 822         trans.put_command(SCIM_TRANS_CMD_REPLY);
 823         trans.put_data(context);
 824         trans.put_data(uuid);
 825         trans.put_command(ISM_TRANS_CMD_GET_ISE_IMDATA);
 826
 827         int cmd;
 828
 829         if (trans.write_to_socket(client_socket)
 830             && trans.read_from_socket(client_socket)
 831             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY) {
 832             trans.get_data(imdata, len);
 833             LOGD ("length of imdata is %d", len);
 834         } else {
 835             LOGW ("read imdata failed\n");
 836         }
 837     }
 838
 839     void get_helper_layout(int client, uint32 context, String& uuid, uint32& layout) {
 840         LOGD ("client id:%d\n", client);
 841
 842         Socket client_socket(client);
 843
 844         Transaction trans;
 845         trans.clear();
 846         trans.put_command(SCIM_TRANS_CMD_REPLY);
 847         trans.put_data(context);
 848         trans.put_data(uuid);
 849         trans.put_command(ISM_TRANS_CMD_GET_LAYOUT);
 850
 851         int cmd;
 852
 853         if (trans.write_to_socket(client_socket)
 854             && trans.read_from_socket(client_socket)
 855             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 856             && trans.get_data(layout)) {
 857             SCIM_DEBUG_MAIN(1) << "get_helper_layout success\n";
 858         } else
 859             LOGW ("failed\n");
 860     }
 861
 862     void get_ise_language_locale(int client, uint32 context, String& uuid, char** data,  size_t& len) {
 863         SCIM_DEBUG_MAIN(4) << __func__ << "\n";
 864         LOGD ("client id:%d\n", client);
 865
 866         Transaction trans;
 867
 868         trans.clear();
 869         trans.put_command(SCIM_TRANS_CMD_REPLY);
 870         trans.put_data(context);
 871         trans.put_data(uuid);
 872         trans.put_command(ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE);
 873
 874         int cmd;
 875         Socket client_socket(client);
 876
 877         if (trans.write_to_socket(client_socket)
 878             && trans.read_from_socket(client_socket)
 879             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 880             && trans.get_data(data, len)) {
 881         } else {
 882             LOGW ("failed\n");
 883         }
 884     }
 885
 886     void check_option_window(int client, uint32 context, String& uuid, _OUT_ uint32& avail) {
 887         LOGD ("client id:%d\n", client);
 888
 889         int cmd;
 890         Socket client_socket(client);
 891
 892         Transaction trans;
 893
 894         trans.clear();
 895         trans.put_command(SCIM_TRANS_CMD_REPLY);
 896         trans.put_data(context);
 897         trans.put_data(uuid);
 898         trans.put_command(ISM_TRANS_CMD_CHECK_OPTION_WINDOW);
 899         trans.write_to_socket(client_socket);
 900
 901         if (!trans.read_from_socket(client_socket, m_socket_timeout) ||
 902             !trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REPLY ||
 903             !trans.get_data(avail)) {
 904             LOGW ("ISM_TRANS_CMD_CHECK_OPTION_WINDOW failed\n");
 905         }
 906     }
 907
 908     void reset_ise_option(int client, uint32 context) {
 909         LOGD ("client id:%d\n", client);
 910
 911         Socket client_socket(client);
 912         m_send_trans.clear();
 913         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 914         m_send_trans.put_data((uint32) context);
 915         m_send_trans.put_command(ISM_TRANS_CMD_RESET_ISE_OPTION);
 916         m_send_trans.write_to_socket(client_socket);
 917     }
 918
 919     void reset_helper_context(int client, uint32 context, const String& uuid) {
 920         LOGD ("client id:%d\n", client);
 921         Transaction trans;
 922         Socket client_socket(client);
 923         m_send_trans.clear();
 924         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 925         m_send_trans.put_data(context);
 926         m_send_trans.put_data(uuid);
 927         m_send_trans.put_command(ISM_TRANS_CMD_RESET_ISE_CONTEXT);
 928         m_send_trans.write_to_socket(client_socket);
 929     }
 930
 931     void reload_config(int client) {
 932         SCIM_DEBUG_MAIN(1) << "PanelAgent::reload_config ()\n";
 933         LOGD ("client id:%d\n", client);
 934
 935         m_send_trans.clear();
 936         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 937         m_send_trans.put_command(SCIM_TRANS_CMD_RELOAD_CONFIG);
 938
 939         Socket client_socket(client);
 940         m_send_trans.write_to_socket(client_socket);
 941     }
 942
 943     void exit(int client, uint32 context) {
 944         SCIM_DEBUG_MAIN(1) << "PanelAgent::exit ()\n";
 945         LOGD ("client id:%d\n", client);
 946
 947         m_send_trans.clear();
 948         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 949
 950         if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT) {
 951             m_send_trans.put_data(context);
 952             m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
 953         }
 954
 955         m_send_trans.put_command(SCIM_TRANS_CMD_EXIT);
 956
 957         Socket client_socket(client);
 958         m_send_trans.write_to_socket(client_socket);
 959     }
 960
 961     bool process_input_device_event(int client, uint32 context, const String& uuid, uint32 type, const char *data, size_t len, _OUT_ uint32& result) {
 962         LOGD("client id:%d\n", client);
 963
 964         Socket client_socket(client);
 965
 966         Transaction trans;
 967
 968         trans.clear();
 969         trans.put_command(SCIM_TRANS_CMD_REPLY);
 970         trans.put_data(context);
 971         trans.put_data(uuid);
 972         trans.put_command(ISM_TRANS_CMD_PROCESS_INPUT_DEVICE_EVENT);
 973         trans.put_data(type);
 974         trans.put_data(data, len);
 975         int cmd;
 976
 977         if (trans.write_to_socket(client_socket)
 978             && trans.read_from_socket(client_socket)
 979             && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
 980             && trans.get_data(result)) {
 981             SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
 982             return true;
 983         }
 984         else {
 985             LOGW("read failed\n");
 986         }
 987
 988         return false;
 989     }
 990
 991     void socket_update_surrounding_text(int client, uint32 context, const String& uuid, String& text, uint32 cursor) {
 992         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
 993         LOGD ("client id:%d\n", client);
 994
 995         Socket client_socket(client);
 996
 997         m_send_trans.clear();
 998         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
 999         m_send_trans.put_data(context);
1000         m_send_trans.put_data(uuid);
1001         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT);
1002         m_send_trans.put_data(text);
1003         m_send_trans.put_data(cursor);
1004         m_send_trans.write_to_socket(client_socket);
1005     }
1006
1007     void socket_remoteinput_focus_in (int client) {
1008         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1009         LOGD ("client id:%d\n", client);
1010
1011         bool ret;
1012         ret = (client == -1) ? false : true;
1013
1014         if (ret) {
1015             Socket client_socket(client);
1016
1017             m_send_trans.clear();
1018             m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1019             m_send_trans.put_command(ISM_TRANS_CMD_RECV_REMOTE_FOCUS_IN);
1020             m_send_trans.write_to_socket(client_socket);
1021         }
1022     }
1023
1024     void socket_remoteinput_focus_out (int client) {
1025         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1026         LOGD ("client id:%d\n", client);
1027
1028         bool ret;
1029         ret = (client == -1) ? false : true;
1030
1031         if (ret) {
1032             Socket client_socket(client);
1033
1034             m_send_trans.clear();
1035             m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1036             m_send_trans.put_command(ISM_TRANS_CMD_RECV_REMOTE_FOCUS_OUT);
1037             m_send_trans.write_to_socket(client_socket);
1038         }
1039     }
1040
1041     void socket_remoteinput_entry_metadata (int client, uint32 hint, uint32 layout, int variation, uint32 autocapital_type) {
1042         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1043         LOGD ("client id:%d\n", client);
1044
1045         bool ret;
1046         ret = (client == -1) ? false : true;
1047
1048         if (ret) {
1049             Socket client_socket(client);
1050
1051             m_send_trans.clear();
1052             m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1053             m_send_trans.put_command(ISM_TRANS_CMD_RECV_REMOTE_ENTRY_METADATA);
1054             m_send_trans.put_data(hint);
1055             m_send_trans.put_data(layout);
1056             m_send_trans.put_data(variation);
1057             m_send_trans.put_data(autocapital_type);
1058             m_send_trans.write_to_socket(client_socket);
1059         }
1060     }
1061
1062     void socket_remoteinput_default_text (int client, String& text, uint32 cursor) {
1063         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1064         LOGD ("client id:%d\n", client);
1065
1066         bool ret;
1067         ret = (client == -1) ? false : true;
1068
1069         if (ret) {
1070             Socket client_socket(client);
1071
1072             m_send_trans.clear();
1073             m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1074             m_send_trans.put_command(ISM_TRANS_CMD_RECV_REMOTE_DEFAULT_TEXT);
1075             m_send_trans.put_data(text);
1076             m_send_trans.put_data(cursor);
1077             m_send_trans.write_to_socket(client_socket);
1078         }
1079     }
1080
1081     void socket_update_selection(int client, uint32 context, String& uuid, String text) {
1082         LOGD ("client id:%d\n", client);
1083
1084         Socket client_socket(client);
1085
1086         m_send_trans.clear();
1087         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1088         m_send_trans.put_data(context);
1089         m_send_trans.put_data(uuid);
1090         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SELECTION);
1091         m_send_trans.put_data(text);
1092         m_send_trans.write_to_socket(client_socket);
1093     }
1094
1095     void socket_get_keyboard_ise_list(int client, uint32 context, const String& uuid, std::vector<String>& list) {
1096         LOGD ("client id:%d\n", client);
1097
1098         Socket socket_client(client);
1099         m_send_trans.clear();
1100         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1101         m_send_trans.put_data(context);
1102         m_send_trans.put_data(uuid);
1103         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE_LIST);
1104         m_send_trans.put_data(list.size());
1105
1106         for (unsigned int i = 0; i < list.size(); i++)
1107             m_send_trans.put_data(list[i]);
1108
1109         m_send_trans.write_to_socket(socket_client);
1110     }
1111
1112     void socket_get_candidate_ui(int client, uint32 context, const String& uuid,  int style,  int mode) {
1113         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_get_candidate_ui ()\n";
1114
1115         LOGD ("client id:%d\n", client);
1116
1117         Socket socket_client(client);
1118         m_send_trans.clear();
1119         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1120         m_send_trans.put_data(context);
1121         m_send_trans.put_data(uuid);
1122         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_UI);
1123         m_send_trans.put_data(style);
1124         m_send_trans.put_data(mode);
1125         m_send_trans.write_to_socket(socket_client);
1126     }
1127
1128     void socket_get_candidate_geometry(int client, uint32 context, const String& uuid, struct rectinfo& info) {
1129         SCIM_DEBUG_MAIN(4) << __func__ << " \n";
1130
1131         LOGD ("client id:%d\n", client);
1132
1133         Socket socket_client(client);
1134         m_send_trans.clear();
1135         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1136         m_send_trans.put_data(context);
1137         m_send_trans.put_data(uuid);
1138         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_GEOMETRY);
1139         m_send_trans.put_data(info.pos_x);
1140         m_send_trans.put_data(info.pos_y);
1141         m_send_trans.put_data(info.width);
1142         m_send_trans.put_data(info.height);
1143         m_send_trans.write_to_socket(socket_client);
1144     }
1145
1146     void socket_get_keyboard_ise(int client, uint32 context, const String& uuid, String& ise_name, String& ise_uuid) {
1147         LOGD ("client id:%d\n", client);
1148
1149         Socket socket_client(client);
1150         m_send_trans.clear();
1151         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1152         m_send_trans.put_data(context);
1153         m_send_trans.put_data(uuid);
1154         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE);
1155         m_send_trans.put_data(ise_name);
1156         m_send_trans.put_data(ise_uuid);
1157         m_send_trans.write_to_socket(socket_client);
1158     }
1159
1160     void socket_start_helper(int client, uint32 context, const String& ic_uuid) {
1161         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_start_helper ()\n";
1162
1163         LOGD ("client id:%d\n", client);
1164
1165         Socket client_socket(client);
1166         m_send_trans.clear();
1167         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1168         m_send_trans.put_data(context);
1169         m_send_trans.put_data(ic_uuid);
1170         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1171         m_send_trans.write_to_socket(client_socket);
1172     }
1173
1174     void helper_detach_input_context(int client, uint32 context, const String& ic_uuid) {
1175         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_stop_helper ()\n";
1176
1177         LOGD ("client id:%d\n", client);
1178
1179         Socket client_socket(client);
1180         m_send_trans.clear();
1181         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1182         m_send_trans.put_data(context);
1183         m_send_trans.put_data(ic_uuid);
1184         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_DETACH_INPUT_CONTEXT);
1185         m_send_trans.write_to_socket(client_socket);
1186     }
1187
1188     void helper_process_imengine_event(int client, uint32 context, const String& ic_uuid, const Transaction& _nest_trans) {
1189         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_send_helper_event ()\n";
1190         LOGD ("client id:%d\n", client);
1191
1192         Socket client_socket(client);
1193
1194         lock();
1195
1196         m_send_trans.clear();
1197         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1198
1199         /* FIXME: We presume that client and context are both less than 65536.
1200          * Hopefully, it should be true in any UNIXs.
1201          * So it's ok to combine client and context into one uint32. */
1202         m_send_trans.put_data(context);
1203         m_send_trans.put_data(ic_uuid);
1204         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_PROCESS_IMENGINE_EVENT);
1205         m_send_trans.put_data(_nest_trans);
1206         m_send_trans.write_to_socket(client_socket);
1207
1208         unlock();
1209     }
1210
1211     void process_helper_event(int client, uint32 context, String target_uuid, String active_uuid, Transaction& nest_trans) {
1212         LOGD ("client id:%d\n", client);
1213
1214         SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_helper_send_imengine_event (" << client << ")\n";
1215         Socket socket_client(client);
1216         lock();
1217         m_send_trans.clear();
1218         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1219         m_send_trans.put_data(context);
1220         m_send_trans.put_command(SCIM_TRANS_CMD_PROCESS_HELPER_EVENT);
1221         m_send_trans.put_data(target_uuid);
1222         m_send_trans.put_data(active_uuid);
1223         m_send_trans.put_data(nest_trans);
1224         m_send_trans.write_to_socket(socket_client);
1225         unlock();
1226
1227     }
1228
1229     void socket_helper_key_event(int client, uint32 context, int cmd, KeyEvent& key) {
1230         LOGD ("client id:%d\n", client);
1231
1232         Socket socket_client(client);
1233         lock();
1234         m_send_trans.clear();
1235         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1236         m_send_trans.put_data(context);
1237         m_send_trans.put_command(cmd);
1238         m_send_trans.put_data(key);
1239         m_send_trans.write_to_socket(socket_client);
1240         unlock();
1241     }
1242
1243     void commit_string(int client, uint32 target_context, const WideString& wstr) {
1244         LOGD ("client id:%d\n", client);
1245
1246         Socket socket_client(client);
1247         lock();
1248         m_send_trans.clear();
1249         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1250         m_send_trans.put_data(target_context);
1251         m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_STRING);
1252         m_send_trans.put_data(wstr);
1253         m_send_trans.write_to_socket(socket_client);
1254         unlock();
1255     }
1256
1257     void socket_helper_get_surrounding_text(int client, uint32 context_id, uint32 maxlen_before, uint32 maxlen_after) {
1258         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1259         LOGD ("client id:%d\n", client);
1260
1261         Socket socket_client(client);
1262         lock();
1263         m_send_trans.clear();
1264         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1265         m_send_trans.put_data(context_id);
1266         m_send_trans.put_command(SCIM_TRANS_CMD_GET_SURROUNDING_TEXT);
1267         m_send_trans.put_data(maxlen_before);
1268         m_send_trans.put_data(maxlen_after);
1269         m_send_trans.write_to_socket(socket_client);
1270         unlock();
1271     }
1272
1273     void socket_helper_delete_surrounding_text(int client, uint32 context_id, uint32 offset, uint32 len) {
1274         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1275         LOGD ("client id:%d\n", client);
1276
1277         Socket socket_client(client);
1278         lock();
1279         m_send_trans.clear();
1280         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1281         m_send_trans.put_data(context_id);
1282         m_send_trans.put_command(SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT);
1283         m_send_trans.put_data(offset);
1284         m_send_trans.put_data(len);
1285         m_send_trans.write_to_socket(socket_client);
1286         unlock();
1287     }
1288
1289     void socket_helper_get_selection(int client, uint32 context_id) {
1290         SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1291         LOGD ("client id:%d\n", client);
1292
1293
1294         Socket socket_client(client);
1295         lock();
1296         m_send_trans.clear();
1297         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1298         m_send_trans.put_data(context_id);
1299         m_send_trans.put_command(SCIM_TRANS_CMD_GET_SELECTION);
1300         m_send_trans.write_to_socket(socket_client);
1301         unlock();
1302     }
1303
1304     void socket_helper_set_selection(int client, uint32 context_id, uint32 start, uint32 end) {
1305         LOGD ("client id:%d\n", client);
1306
1307         Socket socket_client(client);
1308         lock();
1309         m_send_trans.clear();
1310         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1311         m_send_trans.put_data(context_id);
1312         m_send_trans.put_command(SCIM_TRANS_CMD_SET_SELECTION);
1313         m_send_trans.put_data(start);
1314         m_send_trans.put_data(end);
1315         m_send_trans.write_to_socket(socket_client);
1316         unlock();
1317     }
1318
1319     void show_preedit_string(int client, uint32  target_context) {
1320         LOGD ("client id:%d\n", client);
1321
1322         Socket socket_client(client);
1323         lock();
1324         m_send_trans.clear();
1325         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1326         m_send_trans.put_data(target_context);
1327         m_send_trans.put_command(SCIM_TRANS_CMD_SHOW_PREEDIT_STRING);
1328         m_send_trans.write_to_socket(socket_client);
1329         unlock();
1330     }
1331
1332     void hide_preedit_string(int client, uint32  target_context) {
1333         LOGD ("client id:%d\n", client);
1334
1335         Socket socket_client(client);
1336         lock();
1337         m_send_trans.clear();
1338         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1339         m_send_trans.put_data(target_context);
1340         m_send_trans.put_command(SCIM_TRANS_CMD_HIDE_PREEDIT_STRING);
1341         m_send_trans.write_to_socket(socket_client);
1342         unlock();
1343     }
1344
1345     void update_preedit_string(int client, uint32  target_context, WideString preedit, WideString commit, AttributeList& attrs, uint32 caret) {
1346         LOGD ("client id:%d\n", client);
1347
1348         Socket socket_client(client);
1349         lock();
1350         m_send_trans.clear();
1351         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1352         m_send_trans.put_data(target_context);
1353         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
1354         m_send_trans.put_data(preedit);
1355         m_send_trans.put_data(commit);
1356         m_send_trans.put_data(attrs);
1357         m_send_trans.put_data(caret);
1358         m_send_trans.write_to_socket(socket_client);
1359         unlock();
1360
1361     }
1362
1363     void update_preedit_caret(int client, uint32 focused_context, uint32 caret) {
1364
1365         LOGD ("client id:%d\n", client);
1366
1367         Socket socket_client(client);
1368         lock();
1369         m_send_trans.clear();
1370         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1371         m_send_trans.put_data(focused_context);
1372         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET);
1373         m_send_trans.put_data(caret);
1374         m_send_trans.write_to_socket(socket_client);
1375         unlock();
1376
1377     }
1378
1379     void helper_attach_input_context_and_update_screen(int client, std::vector < std::pair <uint32, String> >& helper_ic_index, uint32 current_screen) {
1380         LOGD ("client id:%d\n", client);
1381
1382         Socket socket_client(client);
1383         m_send_trans.clear();
1384         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1385         m_send_trans.put_command(SCIM_TRANS_CMD_OK);
1386         m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1387
1388         for (size_t i = 0; i < helper_ic_index.size(); ++i) {
1389             m_send_trans.put_data(helper_ic_index[i].first);
1390             m_send_trans.put_data(helper_ic_index[i].second);
1391         }
1392
1393         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1394         m_send_trans.put_data((uint32)current_screen);
1395         m_send_trans.write_to_socket(socket_client);
1396     }
1397
1398     void update_ise_input_context(int client, uint32 focused_context, uint32 type, uint32 value) {
1399         LOGD ("client id:%d\n", client);
1400
1401         Socket client_socket(client);
1402         m_send_trans.clear();
1403         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1404         m_send_trans.put_data(focused_context);
1405         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT);
1406         m_send_trans.put_data(type);
1407         m_send_trans.put_data(value);
1408         m_send_trans.write_to_socket(client_socket);
1409
1410     }
1411
1412     void send_private_command(int client, uint32 focused_context, String command) {
1413         LOGD ("client id:%d\n", client);
1414
1415         Socket socket_client(client);
1416         lock();
1417         m_send_trans.clear();
1418         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1419         m_send_trans.put_data(focused_context);
1420         m_send_trans.put_command(SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND);
1421         m_send_trans.put_data(command);
1422         m_send_trans.write_to_socket(socket_client);
1423
1424     }
1425
1426     void helper_all_update_spot_location(int client, uint32 context_id, String uuid, int x, int y) {
1427         LOGD ("client id:%d\n", client);
1428
1429         m_send_trans.clear();
1430         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1431
1432         /* FIXME: We presume that client and context are both less than 65536.
1433          * Hopefully, it should be true in any UNIXs.
1434          * So it's ok to combine client and context into one uint32. */
1435         m_send_trans.put_data(context_id);
1436         m_send_trans.put_data(uuid);
1437         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION);
1438         m_send_trans.put_data((uint32) x);
1439         m_send_trans.put_data((uint32) y);
1440
1441         Socket client_socket(client);
1442         m_send_trans.write_to_socket(client_socket);
1443
1444     }
1445
1446     void helper_all_update_cursor_position(int client, uint32 context_id, String uuid, int cursor_pos) {
1447         LOGD ("client id:%d\n", client);
1448
1449         m_send_trans.clear();
1450         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1451         m_send_trans.put_data(context_id);
1452         m_send_trans.put_data(uuid);
1453         m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CURSOR_POSITION);
1454         m_send_trans.put_data((uint32) cursor_pos);
1455
1456         Socket client_socket(client);
1457         m_send_trans.write_to_socket(client_socket);
1458
1459     }
1460
1461     void helper_all_update_screen(int client, uint32 context_id, String uuid, int screen) {
1462         LOGD ("client id:%d\n", client);
1463
1464         m_send_trans.clear();
1465         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1466
1467         /* FIXME: We presume that client and context are both less than 65536.
1468          * Hopefully, it should be true in any UNIXs.
1469          * So it's ok to combine client and context into one uint32. */
1470         m_send_trans.put_data(context_id);
1471         m_send_trans.put_data(uuid);
1472         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1473         m_send_trans.put_data((uint32) screen);
1474
1475         Socket client_socket(client);
1476         m_send_trans.write_to_socket(client_socket);
1477
1478     }
1479
1480     void set_autocapital_type(int client, uint32 context, String uuid, int mode) {
1481         LOGD ("client id:%d\n", client);
1482
1483         m_send_trans.clear();
1484         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1485
1486         m_send_trans.put_data(context);
1487         m_send_trans.put_data(uuid);
1488         m_send_trans.put_command(SCIM_TRANS_CMD_SET_AUTOCAPITAL_TYPE);
1489         m_send_trans.put_data((uint32) mode);
1490
1491         Socket client_socket(client);
1492         m_send_trans.write_to_socket(client_socket);
1493     }
1494
1495     void update_preedit_string (int client, uint32 target_context, const WideString &str, const AttributeList &attrs) {
1496         LOGD("client id:%d\n", client);
1497
1498         Socket client_socket(client);
1499         lock();
1500         m_send_trans.clear();
1501         m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1502         m_send_trans.put_data(target_context);
1503         m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
1504         m_send_trans.put_data(str);
1505         m_send_trans.put_data(attrs);
1506         m_send_trans.put_data(-1);
1507         m_send_trans.write_to_socket(client_socket);
1508         unlock();
1509     }
1510
1511     void send_key_event (int client, uint32 target_context, const KeyEvent &key) {
1512         LOGD("client id:%d\n", client);
1513
1514         Socket client_socket(client);
1515         lock();
1516         m_send_trans.clear ();
1517         m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
1518         m_send_trans.put_data (target_context);
1519         m_send_trans.put_command (SCIM_TRANS_CMD_PROCESS_KEY_EVENT);
1520         m_send_trans.put_data (key);
1521         m_send_trans.write_to_socket (client_socket);
1522         unlock();
1523     }
1524
1525     void forward_key_event (int client, uint32 target_context, const KeyEvent &key) {
1526         LOGD("client id:%d\n", client);
1527
1528         Socket client_socket(client);
1529         lock();
1530         m_send_trans.clear ();
1531         m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
1532         m_send_trans.put_data (target_context);
1533         m_send_trans.put_command (SCIM_TRANS_CMD_FORWARD_KEY_EVENT);
1534         m_send_trans.put_data (key);
1535         m_send_trans.write_to_socket (client_socket);
1536         unlock();
1537     }
1538 private:
1539
1540     static void send_fail_reply (int client_id)
1541     {
1542         Socket client_socket (client_id);
1543         Transaction trans;
1544         trans.clear ();
1545         trans.put_command (SCIM_TRANS_CMD_REPLY);
1546         trans.put_command (SCIM_TRANS_CMD_FAIL);
1547         trans.write_to_socket (client_socket);
1548     }
1549
1550     bool filter_event(int fd) {
1551         SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_event ()\n";
1552
1553         return m_socket_server.filter_event(fd);
1554     }
1555
1556     bool filter_exception_event(int fd) {
1557         SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_exception_event ()\n";
1558
1559         return m_socket_server.filter_exception_event(fd);
1560     }
1561
1562     int get_server_id() {
1563         SCIM_DEBUG_MAIN(1) << "PanelAgent::get_server_id ()\n";
1564
1565         return m_socket_server.get_id();
1566     }
1567
1568     bool socket_check_client_connection(const Socket& client) {
1569         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_check_client_connection (" << client.get_id() << ")\n";
1570
1571         unsigned char buf [sizeof(uint32)];
1572
1573         int nbytes = client.read_with_timeout(buf, sizeof(uint32), m_socket_timeout);
1574
1575         if (nbytes == sizeof(uint32))
1576             return true;
1577
1578         if (nbytes < 0) {
1579             LOGW ("Error occurred when reading socket: %s\n", client.get_error_message().c_str());
1580         } else {
1581             LOGW ("Timeout when reading socket\n");
1582         }
1583
1584         return false;
1585     }
1586
1587     /**
1588      * @brief Callback function for ecore fd handler.
1589      *
1590      * @param data The data to pass to this callback.
1591      * @param fd_handler The ecore fd handler.
1592      *
1593      * @return ECORE_CALLBACK_RENEW
1594      */
1595     static Eina_Bool panel_agent_handler(void* data, Ecore_Fd_Handler* fd_handler) {
1596         if (fd_handler == NULL || data == NULL)
1597             return ECORE_CALLBACK_RENEW;
1598
1599         EcoreSocketPanelAgent* _agent = (EcoreSocketPanelAgent*)data;
1600
1601         int fd = ecore_main_fd_handler_fd_get(fd_handler);
1602
1603         for (unsigned int i = 0; i < _agent->_read_handler_list.size(); i++) {
1604             if (fd_handler == _agent->_read_handler_list [i]) {
1605                 if (!_agent->filter_event(fd)) {
1606                     std::cerr << "_panel_agent->filter_event () is failed!!!\n";
1607                     ::close (fd);
1608                     ecore_main_fd_handler_del(fd_handler);
1609
1610                     ISF_SAVE_LOG("_panel_agent->filter_event (fd=%d) is failed!!!\n", fd);
1611                 }
1612
1613                 return ECORE_CALLBACK_RENEW;
1614             }
1615         }
1616
1617         std::cerr << "panel_agent_handler () has received exception event!!!\n";
1618         _agent->filter_exception_event(fd);
1619         ::close (fd);
1620         ecore_main_fd_handler_del(fd_handler);
1621
1622         ISF_SAVE_LOG("Received exception event (fd=%d)!!!\n", fd);
1623         return ECORE_CALLBACK_RENEW;
1624     }
1625
1626     void socket_accept_callback(SocketServer*   server,
1627                                 const Socket&   client) {
1628         SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_accept_callback (" << client.get_id() << ")\n";
1629         LOGD ("");
1630         lock();
1631
1632         if (m_should_exit) {
1633             SCIM_DEBUG_MAIN(3) << "Exit Socket Server Thread.\n";
1634             server->shutdown();
1635         } else {
1636             //m_signal_accept_connection (client.get_id ());
1637             Ecore_Fd_Handler* panel_agent_read_handler = ecore_main_fd_handler_add(client.get_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
1638             _read_handler_list.push_back(panel_agent_read_handler);
1639         }
1640
1641         unlock();
1642     }
1643
1644     void socket_receive_callback(SocketServer*   server,
1645                                  const Socket&   client) {
1646         int     client_id = client.get_id();
1647         int     cmd     = 0;
1648         uint32  key     = 0;
1649         uint32  context = 0;
1650         String  uuid;
1651
1652         ClientInfo client_info;
1653
1654         SCIM_DEBUG_MAIN(1) << "PanelAgent::socket_receive_callback (" << client_id << ")\n";
1655
1656         /* If the connection is closed then close this client. */
1657         if (!socket_check_client_connection(client)) {
1658             LOGW ("check client connection failed\n");
1659             socket_close_connection(server, client);
1660             return;
1661         }
1662
1663         client_info = m_info_manager->socket_get_client_info(client_id);
1664
1665         /* If it's a new client, then request to open the connection first. */
1666         if (client_info.type == UNKNOWN_CLIENT) {
1667             socket_open_connection(server, client);
1668             return;
1669         }
1670
1671         /* If can not read the transaction,
1672          * or the transaction is not started with SCIM_TRANS_CMD_REQUEST,
1673          * or the key is mismatch,
1674          * just return. */
1675         if (!m_recv_trans.read_from_socket(client, m_socket_timeout) ||
1676             !m_recv_trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REQUEST ||
1677             !m_recv_trans.get_data(key)    || key != (uint32) client_info.key) {
1678             LOGW ("cmd:%d key:%d client info key: %d\n", cmd, key, client_info.key);
1679             return;
1680         }
1681
1682         if (client_info.type == FRONTEND_ACT_CLIENT) {
1683             if (m_recv_trans.get_data(context)) {
1684                 SCIM_DEBUG_MAIN(1) << "PanelAgent::FrontEnd Client, context = " << context << "\n";
1685                 socket_transaction_start();
1686
1687                 while (m_recv_trans.get_command(cmd)) {
1688                     LOGD ("PanelAgent::cmd = %d\n", cmd);
1689
1690                     if (cmd == ISM_TRANS_CMD_REGISTER_PANEL_CLIENT) {
1691                         uint32 id = 0;
1692
1693                         if (m_recv_trans.get_data(id)) {
1694                             m_info_manager->register_panel_client(client_id, id);
1695                         } else {
1696                             LOGW ("wrong format of transaction\n");
1697                         }
1698
1699                         continue;
1700                     }
1701
1702                     else if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_INPUT_CONTEXT) {
1703                         if (m_recv_trans.get_data(uuid)) {
1704                             m_info_manager->register_input_context(client_id, context, uuid);
1705                         } else {
1706                             LOGW ("wrong format of transaction\n");
1707                         }
1708
1709                         continue;
1710                     }
1711
1712                     else if (cmd == SCIM_TRANS_CMD_PANEL_REMOVE_INPUT_CONTEXT) {
1713                         m_info_manager->remove_input_context(client_id, context);
1714                         continue;
1715                     }
1716
1717                     else if (cmd == SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT) {
1718                         m_info_manager->socket_reset_input_context(client_id, context);
1719                         continue;
1720                     }
1721
1722                     else if (cmd == SCIM_TRANS_CMD_FOCUS_IN) {
1723                         SCIM_DEBUG_MAIN(4) << "    SCIM_TRANS_CMD_FOCUS_IN (" << "client:" << client_id << " context:" << context << ")\n";
1724
1725                         if (m_recv_trans.get_data(uuid)) {
1726                             m_info_manager->focus_in(client_id, context, uuid);
1727                         } else {
1728                             LOGW ("wrong format of transaction\n");
1729                         }
1730
1731                         continue;
1732                     }
1733
1734                     else if (cmd == ISM_TRANS_CMD_TURN_ON_LOG) {
1735                         uint32 isOn;
1736
1737                         if (m_recv_trans.get_data(isOn)) {
1738                             m_info_manager->socket_turn_on_log(isOn);
1739                         } else {
1740                             LOGW ("wrong format of transaction\n");
1741                         }
1742
1743                         continue;
1744                     }
1745
1746                     else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
1747                         m_info_manager->show_isf_panel(client_id);
1748                         continue;
1749                     } else if (cmd == ISM_TRANS_CMD_HIDE_ISF_CONTROL) {
1750                         m_info_manager->hide_isf_panel(client_id);
1751                         continue;
1752                     } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_PANEL) {
1753                         uint32 client;
1754                         uint32 context;
1755                         char*   data = NULL;
1756                         size_t  len;
1757                         bool ret = false;
1758
1759                         if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context) && m_recv_trans.get_data(&data, len)) {
1760                             ret = true;
1761                         } else {
1762                             LOGW ("wrong format of transaction\n");
1763                         }
1764
1765                         Transaction trans;
1766                         Socket client_socket(client_id);
1767
1768                         trans.clear();
1769                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1770                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
1771                         trans.put_data(ret);
1772                         trans.write_to_socket(client_socket);
1773
1774                         if (data != NULL)
1775                             delete[] data;
1776
1777                         if (ret)
1778                             m_info_manager->show_ise_panel(client_id, client, context, data, len);
1779
1780                         continue;
1781                     } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
1782                         uint32 client;
1783                         uint32 context;
1784
1785                         if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context)) {
1786                             m_info_manager->hide_ise_panel(client_id, client, context);
1787                         } else {
1788                             LOGW ("wrong format of transaction\n");
1789                         }
1790
1791                         continue;
1792                     } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY) {
1793                         struct rectinfo info;
1794                         m_info_manager->get_input_panel_geometry(client_id, info);
1795                         Transaction trans;
1796                         Socket client_socket(client_id);
1797
1798                         trans.clear();
1799                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1800                         trans.put_command(SCIM_TRANS_CMD_OK);
1801                         trans.put_data(info.pos_x);
1802                         trans.put_data(info.pos_y);
1803                         trans.put_data(info.width);
1804                         trans.put_data(info.height);
1805                         trans.write_to_socket(client_socket);
1806                         continue;
1807                     } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
1808                         struct rectinfo info;
1809                         m_info_manager->get_candidate_window_geometry(client_id, info);
1810                         Transaction trans;
1811                         Socket client_socket(client_id);
1812
1813                         trans.clear();
1814                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1815                         trans.put_command(SCIM_TRANS_CMD_OK);
1816                         trans.put_data(info.pos_x);
1817                         trans.put_data(info.pos_y);
1818                         trans.put_data(info.width);
1819                         trans.put_data(info.height);
1820                         trans.write_to_socket(client_socket);
1821                         continue;
1822                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE) {
1823                         size_t  len;
1824                         char*   data = NULL;
1825                         m_info_manager->get_ise_language_locale(client_id, &data, len);
1826                         Transaction trans;
1827                         trans.clear();
1828                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1829
1830                         if (data != NULL && len > 0) {
1831                             trans.put_command(SCIM_TRANS_CMD_OK);
1832                             trans.put_data(data, len);
1833                         } else {
1834                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1835                         }
1836
1837                         Socket client_socket(client_id);
1838                         trans.write_to_socket(client_socket);
1839
1840                         if (NULL != data)
1841                             delete [] data;
1842
1843                         continue;
1844                     } else if (cmd == ISM_TRANS_CMD_SET_ISE_LANGUAGE) {
1845                         uint32 language;
1846
1847                         if (m_recv_trans.get_data(language)) {
1848                             m_info_manager->set_ise_language(client_id, language);
1849                         } else {
1850                             LOGW ("wrong format of transaction\n");
1851                         }
1852
1853                         continue;
1854                     } else if (cmd == ISM_TRANS_CMD_SET_ISE_IMDATA) {
1855                         char*   imdata = NULL;
1856                         size_t  len;
1857
1858                         if (m_recv_trans.get_data(&imdata, len)) {
1859                             m_info_manager->set_ise_imdata(client_id, imdata, len);
1860                         } else {
1861                             LOGW ("wrong format of transaction\n");
1862                         }
1863
1864                         if (NULL != imdata)
1865                             delete [] imdata;
1866
1867                         continue;
1868                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_IMDATA) {
1869                         char*   imdata = NULL;
1870                         size_t  len = 0;
1871                         m_info_manager->get_ise_imdata(client_id, &imdata, len);
1872                         Transaction trans;
1873                         Socket client_socket(client_id);
1874
1875                         trans.clear();
1876                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1877
1878                         if (len) {
1879                             trans.put_command(SCIM_TRANS_CMD_OK);
1880                             trans.put_data(imdata, len);
1881                         } else {
1882                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1883                         }
1884
1885                         trans.write_to_socket(client_socket);
1886
1887                         if (NULL != imdata)
1888                             delete [] imdata;
1889
1890                         continue;
1891                     } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_TYPE) {
1892                         uint32 type;
1893
1894                         if (m_recv_trans.get_data(type)) {
1895                             m_info_manager->set_ise_return_key_type(client_id, type);
1896                         } else {
1897                             LOGW ("wrong format of transaction\n");
1898                         }
1899
1900                         continue;
1901                     } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_TYPE) {
1902                         uint32 type;
1903                         bool ret = m_info_manager->get_ise_return_key_type(client_id, type);
1904                         Transaction trans;
1905                         Socket client_socket(client_id);
1906
1907                         trans.clear();
1908                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1909
1910                         if (ret) {
1911                             trans.put_command(SCIM_TRANS_CMD_OK);
1912                             trans.put_data(type);
1913                         } else {
1914                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1915                         }
1916
1917                         trans.write_to_socket(client_socket);
1918                         continue;
1919                     } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE) {
1920                         uint32 disabled;
1921
1922                         if (m_recv_trans.get_data(disabled)) {
1923                             m_info_manager->set_ise_return_key_disable(client_id, disabled);
1924                         } else {
1925                             LOGW ("wrong format of transaction\n");
1926                         }
1927
1928                         continue;
1929                     } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE) {
1930                         uint32 disabled;
1931                         bool ret = true;
1932                         m_info_manager->get_ise_return_key_disable(client_id, disabled);
1933                         Transaction trans;
1934                         Socket client_socket(client_id);
1935
1936                         trans.clear();
1937                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1938
1939                         if (ret) {
1940                             trans.put_command(SCIM_TRANS_CMD_OK);
1941                             trans.put_data(disabled);
1942                         } else {
1943                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1944                         }
1945
1946                         trans.write_to_socket(client_socket);
1947                         continue;
1948                     } else if (cmd == ISM_TRANS_CMD_GET_LAYOUT) {
1949                         uint32 layout;
1950                         bool ret = m_info_manager->get_ise_layout(client_id, layout);
1951                         Transaction trans;
1952                         Socket client_socket(client_id);
1953
1954                         trans.clear();
1955                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1956
1957                         if (ret) {
1958                             trans.put_command(SCIM_TRANS_CMD_OK);
1959                             trans.put_data(layout);
1960                         } else {
1961                             trans.put_command(SCIM_TRANS_CMD_FAIL);
1962                         }
1963
1964                         trans.write_to_socket(client_socket);
1965                         continue;
1966                     } else if (cmd == ISM_TRANS_CMD_SET_LAYOUT) {
1967                         uint32 layout;
1968
1969                         if (m_recv_trans.get_data(layout)) {
1970                             m_info_manager->set_ise_layout(client_id, layout);
1971                         } else {
1972                             LOGW ("wrong format of transaction\n");
1973                         }
1974
1975                         continue;
1976                     } else if (cmd == ISM_TRANS_CMD_SET_CAPS_MODE) {
1977                         uint32 mode;
1978
1979                         if (m_recv_trans.get_data(mode)) {
1980                             m_info_manager->set_ise_caps_mode(client_id, mode);
1981                         } else {
1982                             LOGW ("wrong format of transaction\n");
1983                         }
1984
1985                         continue;
1986                     } else if (cmd == ISM_TRANS_CMD_SEND_WILL_SHOW_ACK) {
1987                         m_info_manager->will_show_ack(client_id);
1988                         continue;
1989                     } else if (cmd == ISM_TRANS_CMD_SEND_WILL_HIDE_ACK) {
1990                         m_info_manager->will_hide_ack(client_id);
1991                         continue;
1992                     } else if (cmd == ISM_TRANS_CMD_SET_HARDWARE_KEYBOARD_MODE) {
1993                         uint32 mode;
1994
1995                         if (m_recv_trans.get_data(mode)) {
1996                             m_info_manager->set_keyboard_mode(client_id, mode);
1997                         } else {
1998                             LOGW ("wrong format of transaction\n");
1999                         }
2000
2001                         continue;
2002                     } else if (cmd == ISM_TRANS_CMD_SEND_CANDIDATE_WILL_HIDE_ACK) {
2003                         m_info_manager->candidate_will_hide_ack(client_id);
2004                         continue;
2005                     } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT) {
2006                         uint32 result = 0;
2007                         bool   ret      = false;
2008
2009                         KeyEvent key;
2010
2011                         if (m_recv_trans.get_data(key)) {
2012                             ret      = true;
2013                             m_info_manager->process_key_event(key, result);
2014                         } else {
2015                             LOGW ("wrong format of transaction\n");
2016                         }
2017
2018                         Transaction trans;
2019                         Socket client_socket(client_id);
2020
2021                         trans.clear();
2022                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2023
2024                         if (ret) {
2025                             trans.put_command(SCIM_TRANS_CMD_OK);
2026                             trans.put_data(result);
2027                         } else {
2028                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2029                         }
2030
2031                         trans.write_to_socket(client_socket);
2032                         continue;
2033                     } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_HELPER_OPTION) {
2034                         uint32 option;
2035                         m_info_manager->get_active_helper_option(client_id, option);
2036                         Transaction trans;
2037                         Socket client_socket(client_id);
2038
2039                         trans.clear();
2040                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2041                         trans.put_command(SCIM_TRANS_CMD_OK);
2042                         trans.put_data(option);
2043                         SCIM_DEBUG_MAIN(4) << __func__ << " option " << option << "\n";
2044                         trans.write_to_socket(client_socket);
2045                         continue;
2046                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_STATE) {
2047                         int state = 0;
2048                         m_info_manager->get_ise_state(client_id, state);
2049                         Transaction trans;
2050                         Socket client_socket(client_id);
2051
2052                         trans.clear();
2053                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2054                         trans.put_command(SCIM_TRANS_CMD_OK);
2055                         trans.put_data(state);
2056                         trans.write_to_socket(client_socket);
2057                         continue;
2058                     } else if (cmd == ISM_TRANS_CMD_SET_INPUT_MODE) {
2059                         uint32 input_mode;
2060
2061                         if (m_recv_trans.get_data(input_mode)) {
2062                             m_info_manager->set_ise_input_mode(client_id, input_mode);
2063                         } else {
2064                             LOGW ("wrong format of transaction\n");
2065                         }
2066
2067                         continue;
2068                     } else if (cmd == ISM_TRANS_CMD_SET_INPUT_HINT) {
2069                         uint32 input_hint;
2070
2071                         if (m_recv_trans.get_data(input_hint)) {
2072                             m_info_manager->set_ise_input_hint(client_id, input_hint);
2073                         } else {
2074                             LOGW ("wrong format of transaction\n");
2075                         }
2076
2077                         continue;
2078                     } else if (cmd == ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION) {
2079                         uint32 bidi_direction;
2080
2081                         if (m_recv_trans.get_data(bidi_direction)) {
2082                             m_info_manager->update_ise_bidi_direction(client_id, bidi_direction);
2083                         } else {
2084                             LOGW ("wrong format of transaction\n");
2085                         }
2086
2087                         continue;
2088                     } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
2089                         m_info_manager->show_ise_option_window(client_id);
2090                         continue;
2091                     }
2092
2093                     //FIXME
2094                     //skip data
2095
2096                     else if (cmd == SCIM_TRANS_CMD_START_HELPER) {
2097                         String uuid;
2098
2099                         if (m_recv_trans.get_data(uuid) && uuid.length()) {
2100                             m_info_manager->socket_start_helper(client_id, context, uuid);
2101                         } else {
2102                             LOGW ("wrong format of transaction\n");
2103                         }
2104
2105                         continue;
2106                     } else if (cmd == SCIM_TRANS_CMD_SEND_HELPER_EVENT) {
2107                         String uuid;
2108
2109                         if (m_recv_trans.get_data(uuid) && m_recv_trans.get_data(m_nest_trans) &&
2110                             uuid.length() && m_nest_trans.valid()) {
2111                             m_info_manager->socket_send_helper_event(client_id, context, uuid, m_nest_trans);
2112                         } else {
2113                             LOGW ("wrong format of transaction\n");
2114                         }
2115
2116                         continue;
2117                     } else if (cmd == SCIM_TRANS_CMD_STOP_HELPER) {
2118                         String uuid;
2119
2120                         if (m_recv_trans.get_data(uuid) && uuid.length()) {
2121                             m_info_manager->socket_stop_helper(client_id, context, uuid);
2122                         } else {
2123                             LOGW ("wrong format of transaction\n");
2124                         }
2125
2126                         continue;
2127                     }
2128
2129                     //FIXME
2130                     //skip data
2131
2132                     /* Client must focus in before do any other things. */
2133                     else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_ON)
2134                         m_info_manager->socket_turn_on();
2135                     else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_OFF)
2136                         m_info_manager->socket_turn_off();
2137                     else if (cmd == SCIM_TRANS_CMD_UPDATE_SCREEN) {
2138                         uint32 num;
2139
2140                         if (m_recv_trans.get_data(num))
2141                             m_info_manager->socket_update_screen(client_id, num);
2142                         else
2143                             LOGW ("wrong format of transaction\n");
2144                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION) {
2145                         uint32 x, y, top_y;
2146
2147                         if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) && m_recv_trans.get_data(top_y)) {
2148                             m_info_manager->socket_update_spot_location(x, y, top_y);
2149                         } else {
2150                             LOGW ("wrong format of transaction\n");
2151                         }
2152                     } else if (cmd == ISM_TRANS_CMD_UPDATE_CURSOR_POSITION) {
2153                         uint32 cursor_pos;
2154
2155                         if (m_recv_trans.get_data(cursor_pos)) {
2156                             m_info_manager->socket_update_cursor_position(cursor_pos);
2157                         } else {
2158                             LOGW ("wrong format of transaction\n");
2159                         }
2160                     } else if (cmd == ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT) {
2161                         String text;
2162                         uint32 cursor;
2163
2164                         if (m_recv_trans.get_data(text) && m_recv_trans.get_data(cursor)) {
2165                             m_info_manager->socket_update_surrounding_text(text, cursor);
2166                         } else {
2167                             LOGW ("wrong format of transaction\n");
2168                         }
2169                     } else if (cmd == ISM_TRANS_CMD_UPDATE_SELECTION) {
2170                         String text;
2171
2172                         if (m_recv_trans.get_data(text)) {
2173                             m_info_manager->socket_update_selection(text);
2174                         } else {
2175                             LOGW ("wrong format of transaction\n");
2176                         }
2177                     } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE)
2178                         m_info_manager->expand_candidate();
2179                     else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE)
2180                         m_info_manager->contract_candidate();
2181                     else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2182                         uint32 portrait_line, mode;
2183
2184                         if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2185                             m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2186                         else
2187                             LOGW ("wrong format of transaction\n");
2188                     } else if (cmd == SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO) {
2189                         PanelFactoryInfo info;
2190
2191                         if (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2192                             m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2193                             m_info_manager->socket_update_factory_info(info);
2194                         } else {
2195                             LOGW ("wrong format of transaction\n");
2196                         }
2197                     } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING)
2198                         m_info_manager->socket_show_preedit_string();
2199                     else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING)
2200                         m_info_manager->socket_show_aux_string();
2201                     else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE)
2202                         m_info_manager->socket_show_lookup_table();
2203                     else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE)
2204                         m_info_manager->socket_show_associate_table();
2205                     else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING)
2206                         m_info_manager->socket_hide_preedit_string();
2207                     else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING)
2208                         m_info_manager->socket_hide_aux_string();
2209                     else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE)
2210                         m_info_manager->socket_hide_lookup_table();
2211                     else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE)
2212                         m_info_manager->socket_hide_associate_table();
2213                     else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2214                         String str;
2215                         AttributeList attrs;
2216                         uint32 caret;
2217
2218                         if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs) && m_recv_trans.get_data(caret))
2219                             m_info_manager->socket_update_preedit_string(str, attrs, caret);
2220                         else
2221                             LOGW ("wrong format of transaction\n");
2222                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2223                         uint32 caret;
2224
2225                         if (m_recv_trans.get_data(caret))
2226                             m_info_manager->socket_update_preedit_caret(caret);
2227                         else
2228                             LOGW ("wrong format of transaction\n");
2229                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2230                         String str;
2231                         AttributeList attrs;
2232
2233                         if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2234                             m_info_manager->socket_update_aux_string(str, attrs);
2235                         else
2236                             LOGW ("wrong format of transaction\n");
2237                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2238                         CommonLookupTable _isf_candidate_table;
2239
2240                         if (m_recv_trans.get_data(_isf_candidate_table))
2241                             m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2242                         else
2243                             LOGW ("wrong format of transaction\n");
2244
2245                     } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2246                         CommonLookupTable table;
2247
2248                         if (m_recv_trans.get_data(table))
2249                             m_info_manager->socket_update_associate_table(table);
2250                         else
2251                             LOGW ("wrong format of transaction\n");
2252                     } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2253                         PropertyList properties;
2254
2255                         if (m_recv_trans.get_data(properties))
2256                             m_info_manager->socket_register_properties(properties);
2257                         else
2258                             LOGW ("wrong format of transaction\n");
2259                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2260                         Property property;
2261
2262                         if (m_recv_trans.get_data(property))
2263                             m_info_manager->socket_update_property(property);
2264                         else
2265                             LOGW ("wrong format of transaction\n");
2266                     } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_HELP) {
2267                         String help;
2268
2269                         if (m_recv_trans.get_data(help))
2270                             m_info_manager->socket_show_help(help);
2271                         else
2272                             LOGW ("wrong format of transaction\n");
2273                     } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU) {
2274                         PanelFactoryInfo info;
2275                         std::vector <PanelFactoryInfo> vec;
2276
2277                         while (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2278                                m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2279                             info.lang = scim_get_normalized_language(info.lang);
2280                             vec.push_back(info);
2281                         }
2282
2283                         m_info_manager->socket_show_factory_menu(vec);
2284                     } else if (cmd == SCIM_TRANS_CMD_FOCUS_OUT) {
2285                         m_info_manager->focus_out(client_id, context);
2286                     } else {
2287                         LOGW ("unknow cmd: %d\n", cmd);
2288                     }
2289                 }
2290
2291                 socket_transaction_end();
2292             }
2293         } else if (client_info.type == FRONTEND_CLIENT) {
2294             if (m_recv_trans.get_data(context)) {
2295                 SCIM_DEBUG_MAIN(1) << "client_info.type == FRONTEND_CLIENT\n";
2296                 socket_transaction_start();
2297
2298                 while (m_recv_trans.get_command(cmd)) {
2299                     LOGD ("PanelAgent::cmd = %d\n", cmd);
2300
2301                     if (cmd == ISM_TRANS_CMD_GET_PANEL_CLIENT_ID) {
2302                         Socket client_socket(client_id);
2303
2304                         Transaction trans;
2305                         trans.clear();
2306                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2307                         trans.put_command(SCIM_TRANS_CMD_OK);
2308                         trans.put_data(client_id);
2309                         trans.write_to_socket(client_socket);
2310                         continue;
2311                     } else {
2312                         LOGW ("unknow cmd: %d\n", cmd);
2313                     }
2314                 }
2315
2316                 socket_transaction_end();
2317             }
2318         } else if (client_info.type == HELPER_CLIENT) {
2319             socket_transaction_start();
2320
2321             while (m_recv_trans.get_command(cmd)) {
2322                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2323
2324                 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_HELPER) {
2325                     HelperInfo info;
2326
2327                     if (m_recv_trans.get_data(info.uuid) &&
2328                         m_recv_trans.get_data(info.name) &&
2329                         m_recv_trans.get_data(info.icon) &&
2330                         m_recv_trans.get_data(info.description) &&
2331                         m_recv_trans.get_data(info.option) &&
2332                         info.uuid.length()) {
2333                         m_info_manager->socket_helper_register_helper(client_id, info);
2334                     }
2335                 } else {
2336                     LOGW ("unknow cmd: %d\n", cmd);
2337                 }
2338             }
2339
2340             socket_transaction_end();
2341         } else if (client_info.type == HELPER_ACT_CLIENT) {
2342             socket_transaction_start();
2343
2344             while (m_recv_trans.get_command(cmd)) {
2345                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2346
2347                 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER) {
2348                     HelperInfo info;
2349
2350                     if (m_recv_trans.get_data(info.uuid) &&
2351                         m_recv_trans.get_data(info.name) &&
2352                         m_recv_trans.get_data(info.icon) &&
2353                         m_recv_trans.get_data(info.description) &&
2354                         m_recv_trans.get_data(info.option) &&
2355                         info.uuid.length()) {
2356                         m_info_manager->socket_helper_register_helper_passive(client_id, info);
2357                     } else {
2358                         LOGW ("wrong format of transaction\n");
2359                     }
2360                 } else if (cmd == SCIM_TRANS_CMD_COMMIT_STRING) {
2361                     uint32 target_ic;
2362                     String target_uuid;
2363                     WideString wstr;
2364
2365                     if (m_recv_trans.get_data(target_ic)    &&
2366                         m_recv_trans.get_data(target_uuid)  &&
2367                         m_recv_trans.get_data(wstr)         &&
2368                         wstr.length()) {
2369                         m_info_manager->socket_helper_commit_string(client_id, target_ic, target_uuid, wstr);
2370                     } else {
2371                         LOGW ("wrong format of transaction\n");
2372                     }
2373                 } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING) {
2374                     uint32 target_ic;
2375                     String target_uuid;
2376
2377                     if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2378                         m_info_manager->socket_helper_show_preedit_string(client_id, target_ic, target_uuid);
2379                     } else {
2380                         LOGW ("wrong format of transaction\n");
2381                     }
2382                 } else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING) {
2383                     m_info_manager->socket_show_aux_string();
2384                 } else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE) {
2385                     m_info_manager->socket_show_lookup_table();
2386                 } else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE) {
2387                     m_info_manager->socket_show_associate_table();
2388                 } else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING) {
2389                     uint32 target_ic;
2390                     String target_uuid;
2391
2392                     if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2393                         m_info_manager->socket_helper_hide_preedit_string(client_id, target_ic, target_uuid);
2394                     } else {
2395                         LOGW ("wrong format of transaction\n");
2396                     }
2397                 } else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING) {
2398                     m_info_manager->socket_hide_aux_string();
2399                 } else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE) {
2400                     m_info_manager->socket_hide_lookup_table();
2401                 } else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE) {
2402                     m_info_manager->socket_hide_associate_table();
2403                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2404                     uint32 target_ic;
2405                     String target_uuid;
2406                     WideString preedit;
2407                     WideString commit;
2408                     AttributeList attrs;
2409                     uint32 caret;
2410
2411                     if (m_recv_trans.get_data(target_ic)    &&
2412                         m_recv_trans.get_data(target_uuid)  &&
2413                         m_recv_trans.get_data(preedit) &&
2414                         m_recv_trans.get_data(commit) &&
2415                         m_recv_trans.get_data(attrs) &&
2416                         m_recv_trans.get_data(caret)) {
2417                         m_info_manager->socket_helper_update_preedit_string(client_id, target_ic, target_uuid, preedit, commit, attrs, caret);
2418                     } else {
2419                         LOGW ("wrong format of transaction\n");
2420                     }
2421                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2422                     uint32 caret;
2423
2424                     if (m_recv_trans.get_data(caret)) {
2425                         m_info_manager->socket_helper_update_preedit_caret(client_id, caret);
2426                     } else {
2427                         LOGW ("wrong format of transaction\n");
2428                     }
2429                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2430                     String str;
2431                     AttributeList attrs;
2432
2433                     if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2434                         m_info_manager->socket_update_aux_string(str, attrs);
2435                     else
2436                         LOGW ("wrong format of transaction\n");
2437
2438                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2439                     CommonLookupTable _isf_candidate_table;
2440
2441                     if (m_recv_trans.get_data(_isf_candidate_table)) {
2442                         m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2443                     } else {
2444                         LOGW ("wrong format of transaction\n");
2445                     }
2446                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2447                     CommonLookupTable _isf_candidate_table;
2448
2449                     if (m_recv_trans.get_data(_isf_candidate_table)) {
2450                         m_info_manager->socket_update_associate_table(_isf_candidate_table);
2451                     } else {
2452                         LOGW ("wrong format of transaction\n");
2453                     }
2454                 } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT ||
2455                            cmd == SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT) {
2456                     uint32 target_ic;
2457                     String target_uuid;
2458                     KeyEvent key;
2459
2460                     if (m_recv_trans.get_data(target_ic)    &&
2461                         m_recv_trans.get_data(target_uuid)  &&
2462                         m_recv_trans.get_data(key)          &&
2463                         !key.empty()) {
2464                         m_info_manager->socket_helper_send_key_event(client_id, target_ic, target_uuid, key);
2465                     } else {
2466                         LOGW ("wrong format of transaction\n");
2467                     }
2468                 } else if (cmd == SCIM_TRANS_CMD_FORWARD_KEY_EVENT) {
2469                     uint32 target_ic;
2470                     String target_uuid;
2471                     KeyEvent key;
2472
2473                     if (m_recv_trans.get_data(target_ic)    &&
2474                         m_recv_trans.get_data(target_uuid)  &&
2475                         m_recv_trans.get_data(key)          &&
2476                         !key.empty()) {
2477                         m_info_manager->socket_helper_forward_key_event(client_id, target_ic, target_uuid, key);
2478                     } else {
2479                         LOGW ("wrong format of transaction\n");
2480                     }
2481                 } else if (cmd == SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT) {
2482                     uint32 target_ic;
2483                     String target_uuid;
2484
2485                     if (m_recv_trans.get_data(target_ic)    &&
2486                         m_recv_trans.get_data(target_uuid)  &&
2487                         m_recv_trans.get_data(m_nest_trans) &&
2488                         m_nest_trans.valid()) {
2489                         m_info_manager->socket_helper_send_imengine_event(client_id, target_ic, target_uuid, m_nest_trans);
2490                     } else {
2491                         LOGW ("wrong format of transaction\n");
2492                     }
2493                 } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2494                     PropertyList properties;
2495
2496                     if (m_recv_trans.get_data(properties))
2497                         m_info_manager->socket_helper_register_properties(client_id, properties);
2498                     else
2499                         LOGW ("wrong format of transaction\n");
2500                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2501                     Property property;
2502
2503                     if (m_recv_trans.get_data(property))
2504                         m_info_manager->socket_helper_update_property(client_id, property);
2505                     else
2506                         LOGW ("wrong format of transaction\n");
2507                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT) {
2508                     uint32 type;
2509                     uint32 value;
2510
2511                     if (m_recv_trans.get_data(type) && m_recv_trans.get_data(value)) {
2512                         m_info_manager->socket_helper_update_input_context(client_id, type, value);
2513                     } else {
2514                         LOGW ("wrong format of transaction\n");
2515                     }
2516                 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST) {
2517                     String uuid;
2518
2519                     if (m_recv_trans.get_data(uuid)) {
2520                         m_info_manager->socket_get_keyboard_ise_list(uuid);
2521                     } else {
2522                         LOGW ("wrong format of transaction\n");
2523                     }
2524                 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2525                     uint32 portrait_line, mode;
2526
2527                     if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2528                         m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2529                     else
2530                         LOGW ("wrong format of transaction\n");
2531                 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_UI) {
2532                     String uuid;
2533
2534                     if (m_recv_trans.get_data(uuid)) {
2535                         m_info_manager->socket_get_candidate_ui(uuid);
2536                     } else {
2537                         LOGW ("wrong format of transaction\n");
2538                     }
2539                 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_POSITION) {
2540                     uint32 left, top;
2541
2542                     if (m_recv_trans.get_data(left) && m_recv_trans.get_data(top))
2543                         m_info_manager->socket_set_candidate_position(left, top);
2544                     else
2545                         LOGW ("wrong format of transaction\n");
2546                 } else if (cmd == ISM_TRANS_CMD_HIDE_CANDIDATE) {
2547                     m_info_manager->socket_hide_candidate();
2548                 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
2549                     String uuid;
2550
2551                     if (m_recv_trans.get_data(uuid)) {
2552                         m_info_manager->socket_get_candidate_geometry(uuid);
2553                     } else {
2554                         LOGW ("wrong format of transaction\n");
2555                     }
2556                 } else if (cmd == ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE) {
2557                     m_info_manager->reset_keyboard_ise();
2558                 } else if (cmd == ISM_TRANS_CMD_SET_KEYBOARD_ISE_BY_UUID) {
2559                     String uuid;
2560
2561                     if (m_recv_trans.get_data(uuid)) {
2562                         m_info_manager->socket_set_keyboard_ise(uuid);
2563                     } else {
2564                         LOGW ("wrong format of transaction\n");
2565                     }
2566                 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE) {
2567                     String uuid;
2568
2569                     if (m_recv_trans.get_data(uuid)) {
2570                         m_info_manager->socket_get_keyboard_ise(uuid);
2571                     } else {
2572                         LOGW ("wrong format of transaction\n");
2573                     }
2574                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY) {
2575                     uint32 x, y, width, height;
2576
2577                     if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) &&
2578                         m_recv_trans.get_data(width) && m_recv_trans.get_data(height)) {
2579                         m_info_manager->socket_helper_update_ise_geometry(client_id, x, y, width, height);
2580                     } else {
2581                         LOGW ("wrong format of transaction\n");
2582                     }
2583                 } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE) {
2584                     m_info_manager->expand_candidate();
2585                 } else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE) {
2586                     m_info_manager->contract_candidate();
2587                 } else if (cmd == ISM_TRANS_CMD_SELECT_CANDIDATE) {
2588                     uint32 index;
2589
2590                     if (m_recv_trans.get_data(index))
2591                         m_info_manager->socket_helper_select_candidate(index);
2592                     else
2593                         LOGW ("wrong format of transaction\n");
2594                 } else if (cmd == SCIM_TRANS_CMD_GET_SURROUNDING_TEXT) {
2595                     String uuid;
2596                     uint32 maxlen_before;
2597                     uint32 maxlen_after;
2598
2599                     if (m_recv_trans.get_data(uuid) &&
2600                         m_recv_trans.get_data(maxlen_before) &&
2601                         m_recv_trans.get_data(maxlen_after)) {
2602                         m_info_manager->socket_helper_get_surrounding_text(client_id, uuid, maxlen_before, maxlen_after);
2603                     } else {
2604                         LOGW ("wrong format of transaction\n");
2605                     }
2606                 } else if (cmd == SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
2607                     uint32 offset;
2608                     uint32 len;
2609
2610                     if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
2611                         m_info_manager->socket_helper_delete_surrounding_text(client_id, offset, len);
2612                     } else {
2613                         LOGW ("wrong format of transaction\n");
2614                     }
2615                 } else if (cmd == SCIM_TRANS_CMD_GET_SELECTION) {
2616                     String uuid;
2617
2618                     if (m_recv_trans.get_data(uuid)) {
2619                         m_info_manager->socket_helper_get_selection(client_id, uuid);
2620                     } else {
2621                         LOGW ("wrong format of transaction\n");
2622                     }
2623                 } else if (cmd == SCIM_TRANS_CMD_SET_SELECTION) {
2624                     uint32 start;
2625                     uint32 end;
2626
2627                     if (m_recv_trans.get_data(start) && m_recv_trans.get_data(end)) {
2628                         m_info_manager->socket_helper_set_selection(client_id, start, end);
2629                     } else {
2630                         LOGW ("wrong format of transaction\n");
2631                     }
2632                 } else if (cmd == SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND) {
2633                     String command;
2634
2635                     if (m_recv_trans.get_data(command)) {
2636                         m_info_manager->socket_helper_send_private_command(client_id, command);
2637                     } else {
2638                         LOGW ("wrong format of transaction\n");
2639                     }
2640                 //FIXME: useless
2641                 //} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_EXIT) {
2642                 //    m_info_manager->UPDATE_ISE_EXIT(client_id);
2643                 } else if (cmd == ISM_TRANS_CMD_PROCESS_KEY_EVENT_DONE) {
2644                     KeyEvent key;
2645                     uint32 ret;
2646                     uint32 serial;
2647
2648                     if (m_recv_trans.get_data(key) && m_recv_trans.get_data(ret) && m_recv_trans.get_data(serial)) {
2649                         m_info_manager->process_key_event_done(key, ret, serial);
2650                     } else {
2651                         LOGW ("wrong format of transaction\n");
2652                     }
2653                 } else {
2654                     LOGW ("unknow cmd: %d\n", cmd);
2655                 }
2656             }
2657
2658             socket_transaction_end();
2659         } else if (client_info.type == IMCONTROL_ACT_CLIENT) {
2660             socket_transaction_start();
2661
2662             while (m_recv_trans.get_command(cmd)) {
2663                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2664
2665                 if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE) {
2666
2667                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2668                         String default_uuid;
2669                         m_info_manager->get_active_ise(client_id, default_uuid);
2670                         Transaction trans;
2671                         Socket client_socket(client_id);
2672
2673                         trans.clear();
2674                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2675                         trans.put_command(SCIM_TRANS_CMD_OK);
2676                         trans.put_data(default_uuid);
2677                         trans.write_to_socket(client_socket);
2678                     }
2679                     else {
2680                         LOGW ("Access denied to get active ise\n");
2681                         send_fail_reply (client_id);
2682                     }
2683                 } else if (cmd == ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID) {
2684                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2685                         char*   buf = NULL;
2686                         size_t  len;
2687                         bool ret = false;
2688
2689                         if (m_recv_trans.get_data(&buf, len)) {
2690                             ret = m_info_manager->set_active_ise_by_uuid(client_id, buf, len);
2691                         } else {
2692                             LOGW ("wrong format of transaction\n");
2693                         }
2694
2695                         Transaction trans;
2696                         Socket client_socket(client_id);
2697
2698                         trans.clear();
2699                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2700                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2701                         trans.write_to_socket(client_socket);
2702
2703                         if (NULL != buf)
2704                             delete[] buf;
2705                     }
2706                     else {
2707                         LOGW ("Access denied to set active ise\n");
2708                         send_fail_reply (client_id);
2709                     }
2710                 } else if (cmd == ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID) {
2711                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2712                         char*   buf = NULL;
2713                         size_t  len;
2714                         bool ret = true;
2715
2716                         //FIXME
2717                         //ret need be checked
2718                         if (m_recv_trans.get_data(&buf, len)) {
2719                             m_info_manager->set_initial_ise_by_uuid(client_id, buf, len);
2720                         } else {
2721                             LOGW ("wrong format of transaction\n");
2722                         }
2723
2724                         Transaction trans;
2725                         Socket client_socket(client_id);
2726
2727                         trans.clear();
2728                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2729                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2730                         trans.write_to_socket(client_socket);
2731
2732                         if (NULL != buf)
2733                             delete[] buf;
2734                     }
2735                     else {
2736                         LOGW ("Access denied to set initial ise\n");
2737                         send_fail_reply (client_id);
2738                     }
2739                 } else if (cmd == ISM_TRANS_CMD_GET_ISE_LIST) {
2740                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2741                         std::vector<String> strlist;
2742                         m_info_manager->get_ise_list(client_id, strlist);
2743                         Transaction trans;
2744                         Socket client_socket(client_id);
2745                         char* buf = NULL;
2746                         size_t len;
2747                         uint32 num;
2748
2749                         trans.clear();
2750                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2751                         trans.put_command(SCIM_TRANS_CMD_OK);
2752
2753                         num = strlist.size();
2754                         trans.put_data(num);
2755
2756                         for (unsigned int i = 0; i < num; i++) {
2757                             buf = const_cast<char*>(strlist[i].c_str());
2758                             len = strlen(buf) + 1;
2759                             trans.put_data(buf, len);
2760                         }
2761
2762                         trans.write_to_socket(client_socket);
2763                     }
2764                     else {
2765                         LOGW ("Access denied to get ise list\n");
2766                         send_fail_reply (client_id);
2767                     }
2768                 } else if (cmd == ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO) {
2769                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2770                         HELPER_ISE_INFO info;
2771                         m_info_manager->get_all_helper_ise_info(client_id, info);
2772
2773                         do {
2774                             Transaction trans;
2775                             Socket client_socket(client_id);
2776
2777                             trans.clear();
2778                             trans.put_command(SCIM_TRANS_CMD_REPLY);
2779                             trans.put_command(SCIM_TRANS_CMD_OK);
2780
2781                             if (info.appid.size() > 0) {
2782                                 trans.put_data(info.appid);
2783                                 trans.put_data(info.label);
2784                                 trans.put_data(info.is_enabled);
2785                                 trans.put_data(info.is_preinstalled);
2786                                 trans.put_data(info.has_option);
2787                             }
2788
2789                             trans.write_to_socket(client_socket);
2790                         } while (0);
2791                     }
2792                     else {
2793                         LOGW ("Access denied to get all helper ise info\n");
2794                         send_fail_reply (client_id);
2795                     }
2796                 } else if (cmd == ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO) {
2797                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2798                         String appid;
2799                         uint32 is_enabled;
2800                         bool ret = false;
2801
2802                         if (m_recv_trans.get_data(appid) && appid.length() != 0 && m_recv_trans.get_data(is_enabled)) {
2803                             m_info_manager->set_enable_helper_ise_info(client_id, appid, is_enabled);
2804                             ret = true;
2805                         } else {
2806                             LOGW ("wrong format of transaction\n");
2807                         }
2808
2809                         Transaction trans;
2810                         Socket client_socket(client_id);
2811
2812                         trans.clear();
2813                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2814                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2815                         trans.write_to_socket(client_socket);
2816                     }
2817                     else {
2818                         LOGW ("Access denied to set enable helper ise info\n");
2819                         send_fail_reply (client_id);
2820                     }
2821                 } else if (cmd == ISM_TRANS_CMD_GET_ISE_INFORMATION) {
2822                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2823                         String strUuid, strName, strLanguage, strModuleName;
2824                         int nType   = 0;
2825                         int nOption = 0;
2826
2827                         if (m_recv_trans.get_data(strUuid)) {
2828                             m_info_manager->get_ise_information(client_id, strUuid, strName, strLanguage, nType, nOption, strModuleName);
2829                         } else {
2830                             LOGW ("wrong format of transaction\n");
2831                         }
2832
2833                         Transaction trans;
2834                         Socket client_socket(client_id);
2835                         trans.clear();
2836                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2837                         trans.put_command(SCIM_TRANS_CMD_OK);
2838                         trans.put_data(strName);
2839                         trans.put_data(strLanguage);
2840                         trans.put_data(nType);
2841                         trans.put_data(nOption);
2842                         trans.put_data(strModuleName);
2843                         trans.write_to_socket(client_socket);
2844                     }
2845                     else {
2846                         LOGW ("Access denied to get ise information\n");
2847                         send_fail_reply (client_id);
2848                     }
2849                 } else if (cmd == ISM_TRANS_CMD_RESET_ISE_OPTION) {
2850                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2851                         Transaction trans;
2852                         Socket client_socket(client_id);
2853
2854                         trans.clear();
2855                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2856                         trans.put_command(SCIM_TRANS_CMD_OK);
2857                         trans.write_to_socket(client_socket);
2858                         m_info_manager->show_helper_ise_selector(client_id);
2859                         m_info_manager->reset_ise_option(client_id);
2860                     }
2861                     else {
2862                         LOGW ("Access denied to reset ise option\n");
2863                         send_fail_reply (client_id);
2864                     }
2865                 } else if (cmd == ISM_TRANS_CMD_RESET_DEFAULT_ISE) {
2866                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2867                         m_info_manager->reset_default_ise(client_id);
2868                     }
2869                     else {
2870                         LOGW ("Access denied to reset default ise\n");
2871                         send_fail_reply (client_id);
2872                     }
2873                 } else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
2874                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2875                         m_info_manager->show_isf_panel(client_id);
2876                     }
2877                     else {
2878                         LOGW ("Access denied to show isf control\n");
2879                         send_fail_reply (client_id);
2880                     }
2881                 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
2882                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2883                         m_info_manager->show_ise_option_window(client_id);
2884                     }
2885                     else {
2886                         LOGW ("Access denied to show ise option window\n");
2887                         send_fail_reply (client_id);
2888                     }
2889                 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST) {
2890                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2891                         Transaction trans;
2892                         Socket client_socket(client_id);
2893
2894                         trans.clear();
2895                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2896                         trans.put_command(SCIM_TRANS_CMD_OK);
2897                         trans.write_to_socket(client_socket);
2898
2899                         m_info_manager->show_helper_ise_list(client_id);
2900                     }
2901                     else {
2902                         LOGW ("Access denied to show helper ise list\n");
2903                         send_fail_reply (client_id);
2904                     }
2905                 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR) {
2906                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2907                         Transaction trans;
2908                         Socket client_socket(client_id);
2909
2910                         trans.clear();
2911                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2912                         trans.put_command(SCIM_TRANS_CMD_OK);
2913                         trans.write_to_socket(client_socket);
2914                         m_info_manager->show_helper_ise_selector(client_id);
2915                     }
2916                     else {
2917                         LOGW ("Access denied to show helper ise selector\n");
2918                         send_fail_reply (client_id);
2919                     }
2920                 } else if (cmd == ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED) {
2921                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2922                         String strAppid;
2923                         uint32 nEnabled = 0;
2924                         bool ret = true;
2925                         //FIXME
2926                         //ret need be checked
2927                         m_info_manager->is_helper_ise_enabled(client_id, strAppid, nEnabled);
2928                         Transaction trans;
2929                         Socket client_socket(client_id);
2930                         trans.clear();
2931                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2932
2933                         if (ret) {
2934                             trans.put_command(SCIM_TRANS_CMD_OK);
2935                             trans.put_data(static_cast<uint32>(nEnabled));
2936                         } else {
2937                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2938                         }
2939
2940                         trans.write_to_socket(client_socket);
2941                     }
2942                     else {
2943                         LOGW ("Access denied to check helper ise enabled\n");
2944                         send_fail_reply (client_id);
2945                     }
2946                 } else if (cmd == ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY) {
2947                     uint32 angle;
2948
2949                     Transaction trans;
2950                     Socket client_socket(client_id);
2951
2952                     trans.clear();
2953                     trans.put_command(SCIM_TRANS_CMD_REPLY);
2954
2955                     if (m_recv_trans.get_data(angle)) {
2956                         struct rectinfo info = {0, 0, 0, 0};
2957                         m_info_manager->get_recent_ise_geometry(client_id, angle, info);
2958
2959                         trans.put_command(SCIM_TRANS_CMD_OK);
2960                         trans.put_data(info.pos_x);
2961                         trans.put_data(info.pos_y);
2962                         trans.put_data(info.width);
2963                         trans.put_data(info.height);
2964                     } else {
2965                         trans.put_command(SCIM_TRANS_CMD_FAIL);
2966                     }
2967
2968                     trans.write_to_socket(client_socket);
2969                 } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
2970                     Transaction trans;
2971                     Socket client_socket(client_id);
2972
2973                     trans.clear();
2974                     trans.put_command(SCIM_TRANS_CMD_REPLY);
2975                     trans.put_command(SCIM_TRANS_CMD_OK);
2976                     trans.write_to_socket(client_socket);
2977                     m_info_manager->hide_helper_ise ();
2978                 } else {
2979                     LOGW ("unknow cmd: %d\n", cmd);
2980                 }
2981             }
2982
2983             socket_transaction_end();
2984         } else if (client_info.type == REMOTEINPUT_ACT_CLIENT) {
2985             socket_transaction_start();
2986             while (m_recv_trans.get_command(cmd)) {
2987                 LOGD ("PanelAgent::cmd = %d\n", cmd);
2988                 if (cmd == ISM_TRANS_CMD_SEND_REMOTE_INPUT_MESSAGE) {
2989                     char*   buf = NULL;
2990                     size_t  len;
2991                     bool ret = false;
2992
2993                     if (m_recv_trans.get_data(&buf, len)) {
2994                         ret = m_info_manager->remoteinput_send_input_message(client_id, buf, len);
2995                     } else {
2996                         LOGW ("wrong format of transaction\n");
2997                     }
2998
2999                     Transaction trans;
3000                     Socket client_socket(client_id);
3001
3002                     trans.clear();
3003                     trans.put_command(SCIM_TRANS_CMD_REPLY);
3004                     trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3005                     trans.write_to_socket(client_socket);
3006
3007                     if (NULL != buf)
3008                         delete[] buf;
3009                 } else if (cmd == ISM_TRANS_CMD_CHECK_REMOTE_PRIVILEGE) {
3010                     bool ret = false;
3011
3012                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE))
3013                         ret = true;
3014
3015                     Transaction trans;
3016                     Socket client_socket(client_id);
3017
3018                     trans.clear();
3019                     trans.put_command(SCIM_TRANS_CMD_REPLY);
3020                     trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3021                     trans.write_to_socket(client_socket);
3022                 } else {
3023                     LOGW ("unknow cmd: %d\n", cmd);
3024                 }
3025             }
3026
3027             socket_transaction_end();
3028         }
3029     }
3030
3031     void socket_exception_callback(SocketServer*   server,
3032                                    const Socket&   client) {
3033         SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_exception_callback (" << client.get_id() << ")\n";
3034         LOGD ("client id:%d\n", client.get_id());
3035         socket_close_connection(server, client);
3036     }
3037
3038     bool socket_open_connection(SocketServer*   server,
3039                                 const Socket&   client) {
3040         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_open_connection (" << client.get_id() << ")\n";
3041         LOGD ("client id:%d\n", client.get_id());
3042         uint32 key;
3043         String type = scim_socket_accept_connection(key,
3044                       String("Panel"),
3045                       String("FrontEnd,FrontEnd_Active,Helper,Helper_Active,IMControl_Active,IMControl_Passive,RemoteInput_Active,RemoteInput_Passive,SocketConfig"),
3046                       client,
3047                       m_socket_timeout);
3048
3049         SCIM_DEBUG_MAIN (3) << "type = " << type << "\n";
3050         if (type.length()) {
3051             ClientType _type = ((type == "FrontEnd") ? FRONTEND_CLIENT :
3052                                ((type == "FrontEnd_Active") ? FRONTEND_ACT_CLIENT :
3053                                ((type == "Helper") ? HELPER_CLIENT :
3054                                ((type == "Helper_Active") ? HELPER_ACT_CLIENT :
3055                                ((type == "IMControl_Active") ? IMCONTROL_ACT_CLIENT :
3056                                ((type == "IMControl_Passive") ? IMCONTROL_CLIENT :
3057                                ((type == "RemoteInput_Active") ? REMOTEINPUT_ACT_CLIENT :
3058                                ((type == "RemoteInput_Passive") ? REMOTEINPUT_CLIENT : CONFIG_CLIENT))))))));
3059             lock();
3060             m_info_manager->add_client(client.get_id(), key, _type);
3061             unlock();
3062             return true;
3063         }
3064         LOGW ("open_connection failed\n");
3065
3066         SCIM_DEBUG_MAIN(4) << "Close client connection " << client.get_id() << "\n";
3067         server->close_connection(client);
3068         return false;
3069     }
3070
3071     void socket_close_connection(SocketServer*   server,
3072                                  const Socket&   client) {
3073         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_close_connection (" << client.get_id() << ")\n";
3074         LOGD ("client id:%d\n", client.get_id());
3075         int i = 0;
3076         std::vector<Ecore_Fd_Handler *>::iterator IterPos;
3077
3078         for (IterPos = _read_handler_list.begin (); IterPos != _read_handler_list.end (); ++IterPos,++i) {
3079             if (ecore_main_fd_handler_fd_get (_read_handler_list[i]) == client.get_id()) {
3080                 ::close (client.get_id ());
3081                 ecore_main_fd_handler_del (_read_handler_list[i]);
3082                 _read_handler_list.erase (IterPos);
3083                 break;
3084             }
3085         }
3086         m_info_manager->del_client(client.get_id());
3087     }
3088
3089     void socket_transaction_start(void) {
3090         //m_signal_transaction_start ();
3091     }
3092
3093     void socket_transaction_end(void) {
3094         //m_signal_transaction_end ();
3095     }
3096
3097     void lock(void) {
3098         //m_signal_lock ();
3099     }
3100     void unlock(void) {
3101         //m_signal_unlock ();
3102     }
3103 };
3104
3105 } /* namespace scim */
3106
3107 /***************************************************/
3108 /*** Beginning of panel agent interface for ISF ***/
3109 /***************************************************/
3110 static scim::PanelAgentPointer instance;
3111
3112 extern "C" {
3113
3114     EXAPI void scim_module_init(void)
3115     {
3116     }
3117
3118     EXAPI void scim_module_exit(void)
3119     {
3120         instance.reset();
3121     }
3122
3123     EXAPI void scim_panel_agent_module_init(const scim::ConfigPointer& config)
3124     {
3125         LOGD ("");
3126     }
3127
3128     EXAPI scim::PanelAgentPointer scim_panel_agent_module_get_instance()
3129     {
3130         scim::PanelAgentBase* _instance = NULL;
3131         if (instance.null()) {
3132             try {
3133                 _instance = new scim::EcoreSocketPanelAgent();
3134             } catch (...) {
3135                 delete _instance;
3136                 _instance = NULL;
3137             }
3138             if(_instance)
3139                 instance = _instance;
3140         }
3141         return instance;
3142     }
3143 }
3144
3145 /*
3146 vi:ts=4:nowrap:ai:expandtab
3147 */