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