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