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