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