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, uint32 caller_pid, uint32 ime_pid) {
 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         ecore_main_fd_handler_del(fd_handler);
1805
1806         ISF_SAVE_LOG("Received exception event (fd=%d)!!!", fd);
1807         return ECORE_CALLBACK_RENEW;
1808     }
1809
1810     void socket_accept_callback(SocketServer*   server,
1811                                 const Socket&   client) {
1812         SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_accept_callback (" << client.get_id() << ")\n";
1813         LOGD ("");
1814         lock();
1815
1816         if (m_should_exit) {
1817             SCIM_DEBUG_MAIN(3) << "Exit Socket Server Thread.\n";
1818             server->shutdown();
1819         } else {
1820             //m_signal_accept_connection (client.get_id ());
1821             Ecore_Fd_Handler* panel_agent_read_handler = ecore_main_fd_handler_add(client.get_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
1822             _read_handler_list.push_back(panel_agent_read_handler);
1823         }
1824
1825         unlock();
1826     }
1827
1828     void socket_receive_callback(SocketServer*   server,
1829                                  const Socket&   client) {
1830         int     client_id = client.get_id();
1831         int     cmd     = 0;
1832         uint32  key     = 0;
1833         uint32  context = 0;
1834         String  uuid;
1835
1836         ClientInfo client_info;
1837
1838         SCIM_DEBUG_MAIN(1) << "PanelAgent::socket_receive_callback (" << client_id << ")\n";
1839
1840         /* If the connection is closed then close this client. */
1841         if (!socket_check_client_connection(client)) {
1842             LOGW ("check client connection failed");
1843             socket_close_connection(server, client);
1844             return;
1845         }
1846
1847         client_info = m_info_manager->socket_get_client_info(client_id);
1848
1849         /* If it's a new client, then request to open the connection first. */
1850         if (client_info.type == UNKNOWN_CLIENT) {
1851             socket_open_connection(server, client);
1852             return;
1853         }
1854
1855         /* If can not read the transaction,
1856          * or the transaction is not started with SCIM_TRANS_CMD_REQUEST,
1857          * or the key is mismatch,
1858          * just return. */
1859         if (!m_recv_trans.read_from_socket(client, m_socket_timeout) ||
1860             !m_recv_trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REQUEST ||
1861             !m_recv_trans.get_data(key)    || key != (uint32) client_info.key) {
1862             LOGW ("cmd:%d key:%d client info key: %d", cmd, key, client_info.key);
1863             return;
1864         }
1865
1866         if (client_info.type == FRONTEND_ACT_CLIENT) {
1867             if (m_recv_trans.get_data(context)) {
1868                 SCIM_DEBUG_MAIN(1) << "PanelAgent::FrontEnd Client, context = " << context << "\n";
1869                 socket_transaction_start();
1870
1871                 while (m_recv_trans.get_command(cmd)) {
1872                     LOGD ("PanelAgent::cmd = %d", cmd);
1873
1874                     if (cmd == ISM_TRANS_CMD_REGISTER_PANEL_CLIENT) {
1875                         uint32 id = 0;
1876
1877                         if (m_recv_trans.get_data(id)) {
1878                             m_info_manager->register_panel_client(client_id, id);
1879                         } else {
1880                             LOGW ("wrong format of transaction");
1881                         }
1882
1883                         continue;
1884                     }
1885                     else if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_INPUT_CONTEXT) {
1886                         if (m_recv_trans.get_data(uuid)) {
1887                             m_info_manager->register_input_context(client_id, context, uuid);
1888                         } else {
1889                             LOGW ("wrong format of transaction");
1890                         }
1891
1892                         continue;
1893                     }
1894                     else if (cmd == SCIM_TRANS_CMD_PANEL_REMOVE_INPUT_CONTEXT) {
1895                         m_info_manager->remove_input_context(client_id, context);
1896                         continue;
1897                     }
1898                     else if (cmd == SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT) {
1899                         m_info_manager->socket_reset_input_context(client_id, context);
1900                         continue;
1901                     }
1902                     else if (cmd == SCIM_TRANS_CMD_FOCUS_IN) {
1903                         SCIM_DEBUG_MAIN(4) << "    SCIM_TRANS_CMD_FOCUS_IN (" << "client:" << client_id << " context:" << context << ")\n";
1904
1905                         if (m_recv_trans.get_data(uuid)) {
1906                             m_info_manager->focus_in(client_id, context, uuid);
1907                         } else {
1908                             LOGW ("wrong format of transaction");
1909                         }
1910
1911                         continue;
1912                     }
1913                     else if (cmd == ISM_TRANS_CMD_TURN_ON_LOG) {
1914                         uint32 isOn;
1915
1916                         if (m_recv_trans.get_data(isOn)) {
1917                             m_info_manager->socket_turn_on_log(isOn);
1918                         } else {
1919                             LOGW ("wrong format of transaction");
1920                         }
1921
1922                         continue;
1923                     }
1924                     else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
1925                         m_info_manager->show_isf_panel(client_id);
1926                         continue;
1927                     } else if (cmd == ISM_TRANS_CMD_HIDE_ISF_CONTROL) {
1928                         m_info_manager->hide_isf_panel(client_id);
1929                         continue;
1930                     } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_PANEL) {
1931                         uint32 target_client;
1932                         uint32 target_context;
1933                         char*   data = NULL;
1934                         size_t  len;
1935                         bool ret = false;
1936
1937                         if (m_recv_trans.get_data(target_client) && m_recv_trans.get_data(target_context) && m_recv_trans.get_data(&data, len)) {
1938                             ret = true;
1939                         } else {
1940                             LOGW ("wrong format of transaction");
1941                         }
1942
1943                         Transaction trans;
1944                         Socket client_socket(client_id);
1945
1946                         trans.clear();
1947                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1948                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
1949                         trans.put_data(ret);
1950                         trans.write_to_socket(client_socket);
1951
1952                         if (ret)
1953                             m_info_manager->show_ise_panel(client_id, target_client, target_context, data, len);
1954
1955                         if (data != NULL)
1956                             delete[] data;
1957
1958                         continue;
1959                     } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
1960                         uint32 target_client;
1961                         uint32 target_context;
1962
1963                         if (m_recv_trans.get_data(target_client) && m_recv_trans.get_data(target_context)) {
1964                             m_info_manager->hide_ise_panel(client_id, target_client, target_context);
1965                         } else {
1966                             LOGW ("wrong format of transaction");
1967                         }
1968
1969                         continue;
1970                     } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY) {
1971                         struct rectinfo info;
1972                         m_info_manager->get_input_panel_geometry(client_id, info);
1973                         Transaction trans;
1974                         Socket client_socket(client_id);
1975
1976                         trans.clear();
1977                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1978                         trans.put_command(SCIM_TRANS_CMD_OK);
1979                         trans.put_data(info.pos_x);
1980                         trans.put_data(info.pos_y);
1981                         trans.put_data(info.width);
1982                         trans.put_data(info.height);
1983                         trans.write_to_socket(client_socket);
1984                         continue;
1985                     } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
1986                         struct rectinfo info;
1987                         m_info_manager->get_candidate_window_geometry(client_id, info);
1988                         Transaction trans;
1989                         Socket client_socket(client_id);
1990
1991                         trans.clear();
1992                         trans.put_command(SCIM_TRANS_CMD_REPLY);
1993                         trans.put_command(SCIM_TRANS_CMD_OK);
1994                         trans.put_data(info.pos_x);
1995                         trans.put_data(info.pos_y);
1996                         trans.put_data(info.width);
1997                         trans.put_data(info.height);
1998                         trans.write_to_socket(client_socket);
1999                         continue;
2000                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE) {
2001                         size_t  len;
2002                         char*   data = NULL;
2003                         m_info_manager->get_ise_language_locale(client_id, &data, len);
2004                         Transaction trans;
2005                         trans.clear();
2006                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2007
2008                         if (data != NULL && len > 0) {
2009                             trans.put_command(SCIM_TRANS_CMD_OK);
2010                             trans.put_data(data, len);
2011                         } else {
2012                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2013                         }
2014
2015                         Socket client_socket(client_id);
2016                         trans.write_to_socket(client_socket);
2017
2018                         if (NULL != data)
2019                             delete [] data;
2020
2021                         continue;
2022                     } else if (cmd == ISM_TRANS_CMD_SET_ISE_LANGUAGE) {
2023                         uint32 language;
2024
2025                         if (m_recv_trans.get_data(language)) {
2026                             m_info_manager->set_ise_language(client_id, language);
2027                         } else {
2028                             LOGW ("wrong format of transaction");
2029                         }
2030
2031                         continue;
2032                     } else if (cmd == ISM_TRANS_CMD_SET_ISE_IMDATA) {
2033                         char*   imdata = NULL;
2034                         size_t  len;
2035
2036                         if (m_recv_trans.get_data(&imdata, len)) {
2037                             m_info_manager->set_ise_imdata(client_id, imdata, len);
2038                         } else {
2039                             LOGW ("wrong format of transaction");
2040                         }
2041
2042                         if (NULL != imdata)
2043                             delete [] imdata;
2044
2045                         continue;
2046                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_IMDATA) {
2047                         char*   imdata = NULL;
2048                         size_t  len = 0;
2049                         m_info_manager->get_ise_imdata(client_id, &imdata, len);
2050                         Transaction trans;
2051                         Socket client_socket(client_id);
2052
2053                         trans.clear();
2054                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2055
2056                         if (len) {
2057                             trans.put_command(SCIM_TRANS_CMD_OK);
2058                             trans.put_data(imdata, len);
2059                         } else {
2060                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2061                         }
2062
2063                         trans.write_to_socket(client_socket);
2064
2065                         if (NULL != imdata)
2066                             delete [] imdata;
2067
2068                         continue;
2069                     } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_TYPE) {
2070                         uint32 type;
2071
2072                         if (m_recv_trans.get_data(type)) {
2073                             m_info_manager->set_ise_return_key_type(client_id, type);
2074                         } else {
2075                             LOGW ("wrong format of transaction");
2076                         }
2077
2078                         continue;
2079                     } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_TYPE) {
2080                         uint32 type;
2081                         bool ret = m_info_manager->get_ise_return_key_type(client_id, type);
2082                         Transaction trans;
2083                         Socket client_socket(client_id);
2084
2085                         trans.clear();
2086                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2087
2088                         if (ret) {
2089                             trans.put_command(SCIM_TRANS_CMD_OK);
2090                             trans.put_data(type);
2091                         } else {
2092                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2093                         }
2094
2095                         trans.write_to_socket(client_socket);
2096                         continue;
2097                     } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE) {
2098                         uint32 disabled;
2099
2100                         if (m_recv_trans.get_data(disabled)) {
2101                             m_info_manager->set_ise_return_key_disable(client_id, disabled);
2102                         } else {
2103                             LOGW ("wrong format of transaction");
2104                         }
2105
2106                         continue;
2107                     } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE) {
2108                         uint32 disabled;
2109                         bool ret = true;
2110                         ret = m_info_manager->get_ise_return_key_disable(client_id, disabled);
2111                         Transaction trans;
2112                         Socket client_socket(client_id);
2113
2114                         trans.clear();
2115                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2116
2117                         if (ret) {
2118                             trans.put_command(SCIM_TRANS_CMD_OK);
2119                             trans.put_data(disabled);
2120                         } else {
2121                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2122                         }
2123
2124                         trans.write_to_socket(client_socket);
2125                         continue;
2126                     } else if (cmd == ISM_TRANS_CMD_GET_LAYOUT) {
2127                         uint32 layout;
2128                         bool ret = m_info_manager->get_ise_layout(client_id, layout);
2129                         Transaction trans;
2130                         Socket client_socket(client_id);
2131
2132                         trans.clear();
2133                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2134
2135                         if (ret) {
2136                             trans.put_command(SCIM_TRANS_CMD_OK);
2137                             trans.put_data(layout);
2138                         } else {
2139                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2140                         }
2141
2142                         trans.write_to_socket(client_socket);
2143                         continue;
2144                     } else if (cmd == ISM_TRANS_CMD_SET_LAYOUT) {
2145                         uint32 layout;
2146
2147                         if (m_recv_trans.get_data(layout)) {
2148                             m_info_manager->set_ise_layout(client_id, layout);
2149                         } else {
2150                             LOGW ("wrong format of transaction");
2151                         }
2152
2153                         continue;
2154                     } else if (cmd == ISM_TRANS_CMD_SET_CAPS_MODE) {
2155                         uint32 mode;
2156
2157                         if (m_recv_trans.get_data(mode)) {
2158                             m_info_manager->set_ise_caps_mode(client_id, mode);
2159                         } else {
2160                             LOGW ("wrong format of transaction");
2161                         }
2162
2163                         continue;
2164                     } else if (cmd == ISM_TRANS_CMD_SEND_WILL_SHOW_ACK) {
2165                         m_info_manager->will_show_ack(client_id);
2166                         continue;
2167                     } else if (cmd == ISM_TRANS_CMD_SEND_WILL_HIDE_ACK) {
2168                         m_info_manager->will_hide_ack(client_id);
2169                         continue;
2170                     } else if (cmd == ISM_TRANS_CMD_SET_HARDWARE_KEYBOARD_MODE) {
2171                         uint32 mode;
2172
2173                         if (m_recv_trans.get_data(mode)) {
2174                             m_info_manager->set_keyboard_mode(client_id, mode);
2175                         } else {
2176                             LOGW ("wrong format of transaction");
2177                         }
2178
2179                         continue;
2180                     } else if (cmd == ISM_TRANS_CMD_SEND_CANDIDATE_WILL_HIDE_ACK) {
2181                         m_info_manager->candidate_will_hide_ack(client_id);
2182                         continue;
2183                     } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT) {
2184                         uint32 result = 0;
2185                         bool   ret      = false;
2186
2187                         KeyEvent key;
2188
2189                         if (m_recv_trans.get_data(key)) {
2190                             ret      = true;
2191                             m_info_manager->process_key_event(key, result, 0);
2192                         } else {
2193                             LOGW ("wrong format of transaction");
2194                         }
2195
2196                         Transaction trans;
2197                         Socket client_socket(client_id);
2198
2199                         trans.clear();
2200                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2201
2202                         if (ret) {
2203                             trans.put_command(SCIM_TRANS_CMD_OK);
2204                             trans.put_data(result);
2205                         } else {
2206                             trans.put_command(SCIM_TRANS_CMD_FAIL);
2207                         }
2208
2209                         trans.write_to_socket(client_socket);
2210                         continue;
2211                     } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_HELPER_OPTION) {
2212                         uint32 option;
2213                         m_info_manager->get_active_helper_option(client_id, option);
2214                         Transaction trans;
2215                         Socket client_socket(client_id);
2216
2217                         trans.clear();
2218                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2219                         trans.put_command(SCIM_TRANS_CMD_OK);
2220                         trans.put_data(option);
2221                         SCIM_DEBUG_MAIN(4) << __func__ << " option " << option << "\n";
2222                         trans.write_to_socket(client_socket);
2223                         continue;
2224                     } else if (cmd == ISM_TRANS_CMD_GET_ISE_STATE) {
2225                         int state = 0;
2226                         m_info_manager->get_ise_state(client_id, state);
2227                         Transaction trans;
2228                         Socket client_socket(client_id);
2229
2230                         trans.clear();
2231                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2232                         trans.put_command(SCIM_TRANS_CMD_OK);
2233                         trans.put_data(state);
2234                         trans.write_to_socket(client_socket);
2235                         continue;
2236                     } else if (cmd == ISM_TRANS_CMD_SET_INPUT_MODE) {
2237                         uint32 input_mode;
2238
2239                         if (m_recv_trans.get_data(input_mode)) {
2240                             m_info_manager->set_ise_input_mode(client_id, input_mode);
2241                         } else {
2242                             LOGW ("wrong format of transaction");
2243                         }
2244
2245                         continue;
2246                     } else if (cmd == ISM_TRANS_CMD_SET_INPUT_HINT) {
2247                         uint32 input_hint;
2248
2249                         if (m_recv_trans.get_data(input_hint)) {
2250                             m_info_manager->set_ise_input_hint(client_id, input_hint);
2251                         } else {
2252                             LOGW ("wrong format of transaction");
2253                         }
2254
2255                         continue;
2256                     } else if (cmd == ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION) {
2257                         uint32 bidi_direction;
2258
2259                         if (m_recv_trans.get_data(bidi_direction)) {
2260                             m_info_manager->update_ise_bidi_direction(client_id, bidi_direction);
2261                         } else {
2262                             LOGW ("wrong format of transaction");
2263                         }
2264
2265                         continue;
2266                     } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
2267                         uint32 caller_pid = 0;
2268                         if (!m_recv_trans.get_data(caller_pid)) {
2269                             LOGW ("Failed to get pid");
2270                         }
2271
2272                         LOGI ("caller PID : %u", caller_pid);
2273                         m_info_manager->show_ise_option_window(client_id, caller_pid);
2274                         continue;
2275                     } else if (cmd == ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW) {
2276                         m_info_manager->resume_ise_option_window(client_id);
2277                         continue;
2278                     }
2279
2280                     //FIXME
2281                     //skip data
2282
2283                     else if (cmd == SCIM_TRANS_CMD_START_HELPER) {
2284                         String uuid;
2285
2286                         if (m_recv_trans.get_data(uuid) && uuid.length()) {
2287                             m_info_manager->socket_start_helper(client_id, context, uuid);
2288                         } else {
2289                             LOGW ("wrong format of transaction");
2290                         }
2291
2292                         continue;
2293                     } else if (cmd == SCIM_TRANS_CMD_SEND_HELPER_EVENT) {
2294                         String uuid;
2295
2296                         if (m_recv_trans.get_data(uuid) && m_recv_trans.get_data(m_nest_trans) &&
2297                             uuid.length() && m_nest_trans.valid()) {
2298                             m_info_manager->socket_send_helper_event(client_id, context, uuid, m_nest_trans);
2299                         } else {
2300                             LOGW ("wrong format of transaction");
2301                         }
2302
2303                         continue;
2304                     } else if (cmd == SCIM_TRANS_CMD_STOP_HELPER) {
2305                         String uuid;
2306
2307                         if (m_recv_trans.get_data(uuid) && uuid.length()) {
2308                             m_info_manager->socket_stop_helper(client_id, context, uuid);
2309                         } else {
2310                             LOGW ("wrong format of transaction");
2311                         }
2312
2313                         continue;
2314                     }
2315
2316                     //FIXME
2317                     //skip data
2318
2319                     /* Client must focus in before do any other things. */
2320                     else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_ON)
2321                         m_info_manager->socket_turn_on();
2322                     else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_OFF)
2323                         m_info_manager->socket_turn_off();
2324                     else if (cmd == SCIM_TRANS_CMD_UPDATE_SCREEN) {
2325                         uint32 num;
2326
2327                         if (m_recv_trans.get_data(num))
2328                             m_info_manager->socket_update_screen(client_id, num);
2329                         else
2330                             LOGW ("wrong format of transaction");
2331                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION) {
2332                         uint32 x, y, top_y;
2333
2334                         if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) && m_recv_trans.get_data(top_y)) {
2335                             m_info_manager->socket_update_spot_location(x, y, top_y);
2336                         } else {
2337                             LOGW ("wrong format of transaction");
2338                         }
2339                     } else if (cmd == ISM_TRANS_CMD_UPDATE_CURSOR_POSITION) {
2340                         uint32 cursor_pos;
2341
2342                         if (m_recv_trans.get_data(cursor_pos)) {
2343                             m_info_manager->socket_update_cursor_position(cursor_pos);
2344                         } else {
2345                             LOGW ("wrong format of transaction");
2346                         }
2347                     } else if (cmd == ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT) {
2348                         String text;
2349                         uint32 cursor;
2350
2351                         if (m_recv_trans.get_data(text) && m_recv_trans.get_data(cursor)) {
2352                             m_info_manager->socket_update_surrounding_text(text, cursor);
2353                         } else {
2354                             LOGW ("wrong format of transaction");
2355                         }
2356                     } else if (cmd == ISM_TRANS_CMD_UPDATE_SELECTION) {
2357                         String text;
2358
2359                         if (m_recv_trans.get_data(text)) {
2360                             m_info_manager->socket_update_selection(text);
2361                         } else {
2362                             LOGW ("wrong format of transaction");
2363                         }
2364                     } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE)
2365                         m_info_manager->expand_candidate();
2366                     else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE)
2367                         m_info_manager->contract_candidate();
2368                     else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2369                         uint32 portrait_line, mode;
2370
2371                         if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2372                             m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2373                         else
2374                             LOGW ("wrong format of transaction");
2375                     } else if (cmd == SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO) {
2376                         PanelFactoryInfo info;
2377
2378                         if (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2379                             m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2380                             m_info_manager->socket_update_factory_info(info);
2381                         } else {
2382                             LOGW ("wrong format of transaction");
2383                         }
2384                     } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING)
2385                         m_info_manager->socket_show_preedit_string();
2386                     else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING)
2387                         m_info_manager->socket_show_aux_string();
2388                     else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE)
2389                         m_info_manager->socket_show_lookup_table();
2390                     else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE)
2391                         m_info_manager->socket_show_associate_table();
2392                     else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING)
2393                         m_info_manager->socket_hide_preedit_string();
2394                     else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING)
2395                         m_info_manager->socket_hide_aux_string();
2396                     else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE)
2397                         m_info_manager->socket_hide_lookup_table();
2398                     else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE)
2399                         m_info_manager->socket_hide_associate_table();
2400                     else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2401                         String str;
2402                         AttributeList attrs;
2403                         uint32 caret;
2404
2405                         if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs) && m_recv_trans.get_data(caret))
2406                             m_info_manager->socket_update_preedit_string(str, attrs, caret);
2407                         else
2408                             LOGW ("wrong format of transaction");
2409                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2410                         uint32 caret;
2411
2412                         if (m_recv_trans.get_data(caret))
2413                             m_info_manager->socket_update_preedit_caret(caret);
2414                         else
2415                             LOGW ("wrong format of transaction");
2416                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2417                         String str;
2418                         AttributeList attrs;
2419
2420                         if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2421                             m_info_manager->socket_update_aux_string(str, attrs);
2422                         else
2423                             LOGW ("wrong format of transaction");
2424                     } else if (cmd == ISM_TRANS_CMD_RECAPTURE_STRING) {
2425                         uint32 target_ic;
2426                         String target_uuid;
2427                         uint32 offset;
2428                         uint32 len;
2429                         WideString preedit;
2430                         WideString commit;
2431                         AttributeList attrs;
2432
2433                         if (m_recv_trans.get_data(target_ic)    &&
2434                             m_recv_trans.get_data(target_uuid)  &&
2435                             m_recv_trans.get_data(offset) &&
2436                             m_recv_trans.get_data(len) &&
2437                             m_recv_trans.get_data(preedit) &&
2438                             m_recv_trans.get_data(commit) &&
2439                             m_recv_trans.get_data(attrs)) {
2440                             m_info_manager->socket_helper_recapture_string(client_id, target_ic, target_uuid, offset, len, preedit, commit, attrs);
2441                         } else {
2442                             LOGW ("wrong format of transaction");
2443                         }
2444                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2445                         CommonLookupTable _isf_candidate_table;
2446
2447                         if (m_recv_trans.get_data(_isf_candidate_table))
2448                             m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2449                         else
2450                             LOGW ("wrong format of transaction");
2451
2452                     } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2453                         CommonLookupTable table;
2454
2455                         if (m_recv_trans.get_data(table))
2456                             m_info_manager->socket_update_associate_table(table);
2457                         else
2458                             LOGW ("wrong format of transaction");
2459                     } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2460                         PropertyList properties;
2461
2462                         if (m_recv_trans.get_data(properties))
2463                             m_info_manager->socket_register_properties(properties);
2464                         else
2465                             LOGW ("wrong format of transaction");
2466                     } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2467                         Property property;
2468
2469                         if (m_recv_trans.get_data(property))
2470                             m_info_manager->socket_update_property(property);
2471                         else
2472                             LOGW ("wrong format of transaction");
2473                     } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_HELP) {
2474                         String help;
2475
2476                         if (m_recv_trans.get_data(help))
2477                             m_info_manager->socket_show_help(help);
2478                         else
2479                             LOGW ("wrong format of transaction");
2480                     } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU) {
2481                         PanelFactoryInfo info;
2482                         std::vector <PanelFactoryInfo> vec;
2483
2484                         while (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2485                                m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2486                             info.lang = scim_get_normalized_language(info.lang);
2487                             vec.push_back(info);
2488                         }
2489
2490                         m_info_manager->socket_show_factory_menu(vec);
2491                     } else if (cmd == SCIM_TRANS_CMD_FOCUS_OUT) {
2492                         m_info_manager->focus_out(client_id, context);
2493                     } else {
2494                         LOGW ("unknown cmd: %d", cmd);
2495                     }
2496                 }
2497
2498                 socket_transaction_end();
2499             }
2500         } else if (client_info.type == FRONTEND_CLIENT) {
2501             if (m_recv_trans.get_data(context)) {
2502                 SCIM_DEBUG_MAIN(1) << "client_info.type == FRONTEND_CLIENT\n";
2503                 socket_transaction_start();
2504
2505                 while (m_recv_trans.get_command(cmd)) {
2506                     LOGD ("PanelAgent::cmd = %d", cmd);
2507
2508                     if (cmd == ISM_TRANS_CMD_GET_PANEL_CLIENT_ID) {
2509                         Socket client_socket(client_id);
2510
2511                         Transaction trans;
2512                         trans.clear();
2513                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2514                         trans.put_command(SCIM_TRANS_CMD_OK);
2515                         trans.put_data(client_id);
2516                         trans.write_to_socket(client_socket);
2517                         continue;
2518                     } else {
2519                         LOGW ("unknown cmd: %d", cmd);
2520                     }
2521                 }
2522
2523                 socket_transaction_end();
2524             }
2525         } else if (client_info.type == HELPER_CLIENT) {
2526             socket_transaction_start();
2527
2528             while (m_recv_trans.get_command(cmd)) {
2529                 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_HELPER) {
2530                     HelperInfo info;
2531
2532                     if (m_recv_trans.get_data(info.uuid) &&
2533                         m_recv_trans.get_data(info.name) &&
2534                         m_recv_trans.get_data(info.icon) &&
2535                         m_recv_trans.get_data(info.description) &&
2536                         m_recv_trans.get_data(info.option) &&
2537                         info.uuid.length()) {
2538                         m_info_manager->socket_helper_register_helper(client_id, info);
2539                     }
2540                 } else {
2541                     LOGW ("unknown cmd: %d", cmd);
2542                 }
2543             }
2544
2545             socket_transaction_end();
2546         } else if (client_info.type == HELPER_ACT_CLIENT) {
2547             socket_transaction_start();
2548
2549             while (m_recv_trans.get_command(cmd)) {
2550                 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER) {
2551                     HelperInfo info;
2552
2553                     if (m_recv_trans.get_data(info.uuid) &&
2554                         m_recv_trans.get_data(info.name) &&
2555                         m_recv_trans.get_data(info.icon) &&
2556                         m_recv_trans.get_data(info.description) &&
2557                         m_recv_trans.get_data(info.option) &&
2558                         info.uuid.length()) {
2559                         m_info_manager->socket_helper_register_helper_passive(client_id, info);
2560                     } else {
2561                         LOGW ("wrong format of transaction");
2562                     }
2563
2564                     /* Check whether application already requested the focus_in and showing input_panel
2565                      * If so, Input FW request focus_in and show input_panel again to helper IME.
2566                      * Because Helper IME couldn't receive these events during the launch.
2567                      */
2568                     m_info_manager->reshow_input_panel ();
2569                 } else if (cmd == SCIM_TRANS_CMD_COMMIT_STRING) {
2570                     uint32 target_ic;
2571                     String target_uuid;
2572                     WideString wstr;
2573
2574                     if (m_recv_trans.get_data(target_ic)    &&
2575                         m_recv_trans.get_data(target_uuid)  &&
2576                         m_recv_trans.get_data(wstr)         &&
2577                         wstr.length()) {
2578                         m_info_manager->socket_helper_commit_string(client_id, target_ic, target_uuid, wstr);
2579                     } else {
2580                         LOGW ("wrong format of transaction");
2581                     }
2582                 } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING) {
2583                     uint32 target_ic;
2584                     String target_uuid;
2585
2586                     if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2587                         m_info_manager->socket_helper_show_preedit_string(client_id, target_ic, target_uuid);
2588                     } else {
2589                         LOGW ("wrong format of transaction");
2590                     }
2591                 } else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING) {
2592                     m_info_manager->socket_show_aux_string();
2593                 } else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE) {
2594                     m_info_manager->socket_show_lookup_table();
2595                 } else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE) {
2596                     m_info_manager->socket_show_associate_table();
2597                 } else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING) {
2598                     uint32 target_ic;
2599                     String target_uuid;
2600
2601                     if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2602                         m_info_manager->socket_helper_hide_preedit_string(client_id, target_ic, target_uuid);
2603                     } else {
2604                         LOGW ("wrong format of transaction");
2605                     }
2606                 } else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING) {
2607                     m_info_manager->socket_hide_aux_string();
2608                 } else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE) {
2609                     m_info_manager->socket_hide_lookup_table();
2610                 } else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE) {
2611                     m_info_manager->socket_hide_associate_table();
2612                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2613                     uint32 target_ic;
2614                     String target_uuid;
2615                     WideString preedit;
2616                     WideString commit;
2617                     AttributeList attrs;
2618                     uint32 caret;
2619
2620                     if (m_recv_trans.get_data(target_ic)    &&
2621                         m_recv_trans.get_data(target_uuid)  &&
2622                         m_recv_trans.get_data(preedit) &&
2623                         m_recv_trans.get_data(commit) &&
2624                         m_recv_trans.get_data(attrs) &&
2625                         m_recv_trans.get_data(caret)) {
2626                         m_info_manager->socket_helper_update_preedit_string(client_id, target_ic, target_uuid, preedit, commit, attrs, caret);
2627                     } else {
2628                         LOGW ("wrong format of transaction");
2629                     }
2630                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2631                     uint32 caret;
2632
2633                     if (m_recv_trans.get_data(caret)) {
2634                         m_info_manager->socket_helper_update_preedit_caret(client_id, caret);
2635                     } else {
2636                         LOGW ("wrong format of transaction");
2637                     }
2638                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2639                     String str;
2640                     AttributeList attrs;
2641
2642                     if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2643                         m_info_manager->socket_update_aux_string(str, attrs);
2644                     else
2645                         LOGW ("wrong format of transaction");
2646                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2647                     CommonLookupTable _isf_candidate_table;
2648
2649                     if (m_recv_trans.get_data(_isf_candidate_table)) {
2650                         m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2651                     } else {
2652                         LOGW ("wrong format of transaction");
2653                     }
2654                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2655                     CommonLookupTable _isf_candidate_table;
2656
2657                     if (m_recv_trans.get_data(_isf_candidate_table)) {
2658                         m_info_manager->socket_update_associate_table(_isf_candidate_table);
2659                     } else {
2660                         LOGW ("wrong format of transaction");
2661                     }
2662                 } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT ||
2663                            cmd == SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT) {
2664                     uint32 target_ic;
2665                     String target_uuid;
2666                     KeyEvent key;
2667
2668                     if (m_recv_trans.get_data(target_ic)    &&
2669                         m_recv_trans.get_data(target_uuid)  &&
2670                         m_recv_trans.get_data(key)          &&
2671                         !key.empty()) {
2672                         m_info_manager->socket_helper_send_key_event(client_id, target_ic, target_uuid, key);
2673                     } else {
2674                         LOGW ("wrong format of transaction");
2675                     }
2676                 } else if (cmd == SCIM_TRANS_CMD_FORWARD_KEY_EVENT) {
2677                     uint32 target_ic;
2678                     String target_uuid;
2679                     KeyEvent key;
2680
2681                     if (m_recv_trans.get_data(target_ic)    &&
2682                         m_recv_trans.get_data(target_uuid)  &&
2683                         m_recv_trans.get_data(key)          &&
2684                         !key.empty()) {
2685                         m_info_manager->socket_helper_forward_key_event(client_id, target_ic, target_uuid, key);
2686                     } else {
2687                         LOGW ("wrong format of transaction");
2688                     }
2689                 } else if (cmd == SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT) {
2690                     uint32 target_ic;
2691                     String target_uuid;
2692
2693                     if (m_recv_trans.get_data(target_ic)    &&
2694                         m_recv_trans.get_data(target_uuid)  &&
2695                         m_recv_trans.get_data(m_nest_trans) &&
2696                         m_nest_trans.valid()) {
2697                         m_info_manager->socket_helper_send_imengine_event(client_id, target_ic, target_uuid, m_nest_trans);
2698                     } else {
2699                         LOGW ("wrong format of transaction");
2700                     }
2701                 } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2702                     PropertyList properties;
2703
2704                     if (m_recv_trans.get_data(properties))
2705                         m_info_manager->socket_helper_register_properties(client_id, properties);
2706                     else
2707                         LOGW ("wrong format of transaction");
2708                 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2709                     Property property;
2710
2711                     if (m_recv_trans.get_data(property))
2712                         m_info_manager->socket_helper_update_property(client_id, property);
2713                     else
2714                         LOGW ("wrong format of transaction");
2715                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT) {
2716                     uint32 type;
2717                     uint32 value;
2718
2719                     if (m_recv_trans.get_data(type) && m_recv_trans.get_data(value)) {
2720                         m_info_manager->socket_helper_update_input_context(client_id, type, value);
2721                     } else {
2722                         LOGW ("wrong format of transaction");
2723                     }
2724                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_LANGUAGE_LOCALE) {
2725                     String locale;
2726
2727                     char* data = NULL;
2728                     size_t len;
2729                     if (m_recv_trans.get_data(&data, len)) {
2730                         if (data && len) {
2731                             locale = String(data, len);
2732                             m_info_manager->socket_helper_update_language_locale(client_id, locale);
2733                         } else {
2734                             LOGW("wrong format of transaction : %p %zu", data, len);
2735                         }
2736                     } else {
2737                         LOGW("wrong format of transaction");
2738                     }
2739
2740                     if (data != NULL)
2741                         delete [] data;
2742                 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST) {
2743                     String uuid;
2744
2745                     if (m_recv_trans.get_data(uuid)) {
2746                         m_info_manager->socket_get_keyboard_ise_list(uuid);
2747                     } else {
2748                         LOGW ("wrong format of transaction");
2749                     }
2750                 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2751                     uint32 portrait_line, mode;
2752
2753                     if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2754                         m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2755                     else
2756                         LOGW ("wrong format of transaction");
2757                 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_UI) {
2758                     String uuid;
2759
2760                     if (m_recv_trans.get_data(uuid)) {
2761                         m_info_manager->socket_get_candidate_ui(uuid);
2762                     } else {
2763                         LOGW ("wrong format of transaction");
2764                     }
2765                 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_POSITION) {
2766                     uint32 left, top;
2767
2768                     if (m_recv_trans.get_data(left) && m_recv_trans.get_data(top))
2769                         m_info_manager->socket_set_candidate_position(left, top);
2770                     else
2771                         LOGW ("wrong format of transaction");
2772                 } else if (cmd == ISM_TRANS_CMD_HIDE_CANDIDATE) {
2773                     m_info_manager->socket_hide_candidate();
2774                 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
2775                     String uuid;
2776
2777                     if (m_recv_trans.get_data(uuid)) {
2778                         m_info_manager->socket_get_candidate_geometry(uuid);
2779                     } else {
2780                         LOGW ("wrong format of transaction");
2781                     }
2782                 } else if (cmd == ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE) {
2783                     m_info_manager->reset_keyboard_ise();
2784                 } else if (cmd == ISM_TRANS_CMD_SET_KEYBOARD_ISE_BY_UUID) {
2785                     String uuid;
2786
2787                     if (m_recv_trans.get_data(uuid)) {
2788                         m_info_manager->socket_set_keyboard_ise(uuid);
2789                     } else {
2790                         LOGW ("wrong format of transaction");
2791                     }
2792                 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE) {
2793                     String uuid;
2794
2795                     if (m_recv_trans.get_data(uuid)) {
2796                         m_info_manager->socket_get_keyboard_ise(uuid);
2797                     } else {
2798                         LOGW ("wrong format of transaction");
2799                     }
2800                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY) {
2801                     uint32 x, y, width, height;
2802
2803                     if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) &&
2804                         m_recv_trans.get_data(width) && m_recv_trans.get_data(height)) {
2805                         m_info_manager->socket_helper_update_ise_geometry(client_id, x, y, width, height);
2806                     } else {
2807                         LOGW ("wrong format of transaction");
2808                     }
2809                 } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE) {
2810                     m_info_manager->expand_candidate();
2811                 } else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE) {
2812                     m_info_manager->contract_candidate();
2813                 } else if (cmd == ISM_TRANS_CMD_SELECT_CANDIDATE) {
2814                     uint32 index;
2815
2816                     if (m_recv_trans.get_data(index))
2817                         m_info_manager->socket_helper_select_candidate(index);
2818                     else
2819                         LOGW ("wrong format of transaction");
2820                 } else if (cmd == SCIM_TRANS_CMD_PING) {
2821                     Transaction trans;
2822                     Socket client_socket(client_id);
2823
2824                     trans.clear();
2825                     trans.put_command(SCIM_TRANS_CMD_REPLY);
2826                     trans.put_command(SCIM_TRANS_CMD_OK);
2827                     trans.write_to_socket(client_socket);
2828                 } else if (cmd == SCIM_TRANS_CMD_GET_SURROUNDING_TEXT) {
2829                     String uuid;
2830                     uint32 maxlen_before;
2831                     uint32 maxlen_after;
2832
2833                     if (m_recv_trans.get_data(uuid) &&
2834                         m_recv_trans.get_data(maxlen_before) &&
2835                         m_recv_trans.get_data(maxlen_after)) {
2836                         m_info_manager->socket_helper_get_surrounding_text(client_id, uuid, maxlen_before, maxlen_after);
2837                     } else {
2838                         LOGW ("wrong format of transaction");
2839                     }
2840                 } else if (cmd == SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
2841                     uint32 offset;
2842                     uint32 len;
2843
2844                     if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
2845                         m_info_manager->socket_helper_delete_surrounding_text(client_id, offset, len);
2846                     } else {
2847                         LOGW ("wrong format of transaction");
2848                     }
2849                 } else if (cmd == SCIM_TRANS_CMD_GET_SELECTION) {
2850                     String uuid;
2851
2852                     if (m_recv_trans.get_data(uuid)) {
2853                         m_info_manager->socket_helper_get_selection(client_id, uuid);
2854                     } else {
2855                         LOGW ("wrong format of transaction");
2856                     }
2857                 } else if (cmd == SCIM_TRANS_CMD_SET_SELECTION) {
2858                     uint32 start;
2859                     uint32 end;
2860
2861                     if (m_recv_trans.get_data(start) && m_recv_trans.get_data(end)) {
2862                         m_info_manager->socket_helper_set_selection(client_id, start, end);
2863                     } else {
2864                         LOGW ("wrong format of transaction");
2865                     }
2866                 } else if (cmd == SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND) {
2867                     String command;
2868
2869                     if (m_recv_trans.get_data(command)) {
2870                         m_info_manager->socket_helper_send_private_command(client_id, command);
2871                     } else {
2872                         LOGW ("wrong format of transaction");
2873                     }
2874                 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_EXIT) {
2875                     m_info_manager->UPDATE_ISE_EXIT(client_id);
2876                 } else if (cmd == SCIM_TRANS_CMD_COMMIT_CONTENT) {
2877                     String content;
2878                     String description;
2879                     String mime_types;
2880
2881                     if (m_recv_trans.get_data(content) &&
2882                         m_recv_trans.get_data(description) &&
2883                         m_recv_trans.get_data(mime_types)) {
2884                         m_info_manager->socket_helper_commit_content(client_id, content, description, mime_types);
2885                     } else {
2886                         LOGW ("wrong format of transaction");
2887                     }
2888                 } else if (cmd == ISM_TRANS_CMD_PROCESS_KEY_EVENT_DONE) {
2889                     KeyEvent key;
2890                     uint32 ret;
2891                     uint32 serial;
2892
2893                     if (m_recv_trans.get_data(key) && m_recv_trans.get_data(ret) && m_recv_trans.get_data(serial)) {
2894                         m_info_manager->process_key_event_done(key, ret, serial);
2895                     } else {
2896                         LOGW ("wrong format of transaction");
2897                     }
2898                 } else if (cmd == ISM_TRANS_CMD_REQUEST_ISE_HIDE) {
2899                     m_info_manager->request_ise_hide();
2900                 } else if (cmd == ISM_TRANS_CMD_RECAPTURE_STRING) {
2901                     uint32 target_ic;
2902                     String target_uuid;
2903                     uint32 offset;
2904                     uint32 len;
2905                     WideString preedit;
2906                     WideString commit;
2907                     AttributeList attrs;
2908
2909                     if (m_recv_trans.get_data(target_ic)    &&
2910                         m_recv_trans.get_data(target_uuid)  &&
2911                         m_recv_trans.get_data(offset) &&
2912                         m_recv_trans.get_data(len) &&
2913                         m_recv_trans.get_data(preedit) &&
2914                         m_recv_trans.get_data(commit) &&
2915                         m_recv_trans.get_data(attrs)) {
2916                         m_info_manager->socket_helper_recapture_string(client_id, target_ic, target_uuid, offset, len, preedit, commit, attrs);
2917                     } else {
2918                         LOGW ("wrong format of transaction");
2919                     }
2920                 } else {
2921                     LOGW ("unknown cmd: %d", cmd);
2922                 }
2923             }
2924
2925             socket_transaction_end();
2926         } else if (client_info.type == IMCONTROL_ACT_CLIENT) {
2927             socket_transaction_start();
2928
2929             while (m_recv_trans.get_command(cmd)) {
2930                 LOGD ("PanelAgent::cmd = %d", cmd);
2931
2932                 if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE) {
2933                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2934                         String default_uuid;
2935                         m_info_manager->get_active_ise(client_id, default_uuid);
2936                         Transaction trans;
2937                         Socket client_socket(client_id);
2938
2939                         trans.clear();
2940                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2941                         trans.put_command(SCIM_TRANS_CMD_OK);
2942                         trans.put_data(default_uuid);
2943                         trans.write_to_socket(client_socket);
2944                     }
2945                     else {
2946                         LOGW ("Access denied to get active ise");
2947                         send_fail_reply (client_id);
2948                     }
2949                 } else if (cmd == ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID) {
2950                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2951                         char*   buf = NULL;
2952                         size_t  len;
2953                         bool ret = false;
2954
2955                         if (m_recv_trans.get_data(&buf, len)) {
2956                             ret = m_info_manager->set_active_ise_by_uuid(client_id, buf, len);
2957                         } else {
2958                             LOGW ("wrong format of transaction");
2959                         }
2960
2961                         Transaction trans;
2962                         Socket client_socket(client_id);
2963
2964                         trans.clear();
2965                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2966                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2967                         trans.write_to_socket(client_socket);
2968
2969                         if (NULL != buf)
2970                             delete[] buf;
2971                     }
2972                     else {
2973                         LOGW ("Access denied to set active ise");
2974                         send_fail_reply (client_id);
2975                     }
2976                 } else if (cmd == ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID) {
2977                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2978                         char*   buf = NULL;
2979                         size_t  len;
2980
2981                         //FIXME
2982                         //ret need be checked
2983                         if (m_recv_trans.get_data(&buf, len)) {
2984                             m_info_manager->set_initial_ise_by_uuid(client_id, buf, len);
2985                         } else {
2986                             LOGW ("wrong format of transaction");
2987                         }
2988
2989                         Transaction trans;
2990                         Socket client_socket(client_id);
2991
2992                         trans.clear();
2993                         trans.put_command(SCIM_TRANS_CMD_REPLY);
2994                         trans.put_command(SCIM_TRANS_CMD_OK);
2995                         trans.write_to_socket(client_socket);
2996
2997                         if (NULL != buf)
2998                             delete[] buf;
2999                     }
3000                     else {
3001                         LOGW ("Access denied to set initial ise");
3002                         send_fail_reply (client_id);
3003                     }
3004                 } else if (cmd == ISM_TRANS_CMD_GET_ISE_LIST) {
3005                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3006                         std::vector<String> strlist;
3007                         m_info_manager->get_ise_list(client_id, strlist);
3008                         Transaction trans;
3009                         Socket client_socket(client_id);
3010                         char* buf = NULL;
3011                         size_t len;
3012                         uint32 num;
3013
3014                         trans.clear();
3015                         trans.put_command(SCIM_TRANS_CMD_REPLY);
3016                         trans.put_command(SCIM_TRANS_CMD_OK);
3017
3018                         num = strlist.size();
3019                         trans.put_data(num);
3020
3021                         for (unsigned int i = 0; i < num; i++) {
3022                             buf = const_cast<char*>(strlist[i].c_str());
3023                             len = strlen(buf) + 1;
3024                             trans.put_data(buf, len);
3025                         }
3026
3027                         trans.write_to_socket(client_socket);
3028                     }
3029                     else {
3030                         LOGW ("Access denied to get ise list");
3031                         send_fail_reply (client_id);
3032                     }
3033                 } else if (cmd == ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO) {
3034                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3035                         HELPER_ISE_INFO info;
3036                         m_info_manager->get_all_helper_ise_info(client_id, info);
3037
3038                         do {
3039                             Transaction trans;
3040                             Socket client_socket(client_id);
3041
3042                             trans.clear();
3043                             trans.put_command(SCIM_TRANS_CMD_REPLY);
3044                             trans.put_command(SCIM_TRANS_CMD_OK);
3045
3046                             if (info.appid.size() > 0) {
3047                                 trans.put_data(info.appid);
3048                                 trans.put_data(info.label);
3049                                 trans.put_data(info.is_enabled);
3050                                 trans.put_data(info.is_preinstalled);
3051                                 trans.put_data(info.has_option);
3052                             }
3053
3054                             trans.write_to_socket(client_socket);
3055                         } while (0);
3056                     }
3057                     else {
3058                         LOGW ("Access denied to get all helper ise info");
3059                         send_fail_reply (client_id);
3060                     }
3061                 } else if (cmd == ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO) {
3062                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3063                         String appid;
3064                         uint32 is_enabled;
3065                         bool ret = false;
3066
3067                         if (m_recv_trans.get_data(appid) && appid.length() != 0 && m_recv_trans.get_data(is_enabled)) {
3068                             m_info_manager->set_enable_helper_ise_info(client_id, appid, is_enabled);
3069                             ret = true;
3070                         } else {
3071                             LOGW ("wrong format of transaction");
3072                         }
3073
3074                         Transaction trans;
3075                         Socket client_socket(client_id);
3076
3077                         trans.clear();
3078                         trans.put_command(SCIM_TRANS_CMD_REPLY);
3079                         trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3080                         trans.write_to_socket(client_socket);
3081                     }
3082                     else {
3083                         LOGW ("Access denied to set enable helper ise info");
3084                         send_fail_reply (client_id);
3085                     }
3086                 } else if (cmd == ISM_TRANS_CMD_GET_ISE_INFORMATION) {
3087                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3088                         String strUuid, strName, strLanguage, strModuleName;
3089                         int nType   = 0;
3090                         int nOption = 0;
3091
3092                         if (m_recv_trans.get_data(strUuid)) {
3093                             m_info_manager->get_ise_information(client_id, strUuid, strName, strLanguage, nType, nOption, strModuleName);
3094                         } else {
3095                             LOGW ("wrong format of transaction");
3096                         }
3097
3098                         Transaction trans;
3099                         Socket client_socket(client_id);
3100                         trans.clear();
3101                         trans.put_command(SCIM_TRANS_CMD_REPLY);
3102                         trans.put_command(SCIM_TRANS_CMD_OK);
3103                         trans.put_data(strName);
3104                         trans.put_data(strLanguage);
3105                         trans.put_data(nType);
3106                         trans.put_data(nOption);
3107                         trans.put_data(strModuleName);
3108                         trans.write_to_socket(client_socket);
3109                     }
3110                     else {
3111                         LOGW ("Access denied to get ise information");
3112                         send_fail_reply (client_id);
3113                     }
3114                 } else if (cmd == ISM_TRANS_CMD_RESET_ISE_OPTION) {
3115                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3116                         Transaction trans;
3117                         Socket client_socket(client_id);
3118
3119                         trans.clear();
3120                         trans.put_command(SCIM_TRANS_CMD_REPLY);
3121                         trans.put_command(SCIM_TRANS_CMD_OK);
3122                         trans.write_to_socket(client_socket);
3123                         m_info_manager->show_helper_ise_selector(client_id);
3124                         m_info_manager->reset_ise_option(client_id);
3125                     }
3126                     else {
3127                         LOGW ("Access denied to reset ise option");
3128                         send_fail_reply (client_id);
3129                     }
3130                 } else if (cmd == ISM_TRANS_CMD_RESET_DEFAULT_ISE) {
3131                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3132                         m_info_manager->reset_default_ise(client_id);
3133                     }
3134                     else {
3135                         LOGW ("Access denied to reset default ise");
3136                         send_fail_reply (client_id);
3137                     }
3138                 } else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
3139                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3140                         m_info_manager->show_isf_panel(client_id);
3141                     }
3142                     else {
3143                         LOGW ("Access denied to show isf control");
3144                         send_fail_reply (client_id);
3145                     }
3146                 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
3147                     uint32 caller_pid = 0;
3148                     if (!m_recv_trans.get_data(caller_pid)) {
3149                         LOGW ("Failed to get pid");
3150                     }
3151
3152                     LOGI ("caller PID : %u", caller_pid);
3153                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3154                         m_info_manager->show_ise_option_window(client_id, caller_pid);
3155                     }
3156                     else {
3157                         LOGW ("Access denied to show ise option window");
3158                         send_fail_reply (client_id);
3159                     }
3160                 } else if (cmd == ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW) {
3161                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3162                         m_info_manager->resume_ise_option_window(client_id);
3163                     }
3164                     else {
3165                         LOGW ("Access denied to resume ise option window");
3166                         send_fail_reply (client_id);
3167                     }
3168                 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST) {
3169                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3170                         Transaction trans;
3171                         Socket client_socket(client_id);
3172
3173                         trans.clear();
3174                         trans.put_command(SCIM_TRANS_CMD_REPLY);
3175                         trans.put_command(SCIM_TRANS_CMD_OK);
3176                         trans.write_to_socket(client_socket);
3177
3178                         m_info_manager->show_helper_ise_list(client_id);
3179                     }
3180                     else {
3181                         LOGW ("Access denied to show helper ise list");
3182                         send_fail_reply (client_id);
3183                     }
3184                 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR) {
3185                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3186                         Transaction trans;
3187                         Socket client_socket(client_id);
3188
3189                         trans.clear();
3190                         trans.put_command(SCIM_TRANS_CMD_REPLY);
3191                         trans.put_command(SCIM_TRANS_CMD_OK);
3192                         trans.write_to_socket(client_socket);
3193                         m_info_manager->show_helper_ise_selector(client_id);
3194                     }
3195                     else {
3196                         LOGW ("Access denied to show helper ise selector");
3197                         send_fail_reply (client_id);
3198                     }
3199                 } else if (cmd == ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED) {
3200                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3201                         String strAppid;
3202                         uint32 nEnabled = 0;
3203
3204                         m_info_manager->is_helper_ise_enabled(client_id, strAppid, nEnabled);
3205                         Transaction trans;
3206                         Socket client_socket(client_id);
3207                         trans.clear();
3208                         trans.put_command(SCIM_TRANS_CMD_REPLY);
3209                         trans.put_command(SCIM_TRANS_CMD_OK);
3210                         trans.put_data(static_cast<uint32>(nEnabled));
3211                         trans.write_to_socket(client_socket);
3212                     }
3213                     else {
3214                         LOGW ("Access denied to check helper ise enabled");
3215                         send_fail_reply (client_id);
3216                     }
3217                 } else if (cmd == ISM_TRANS_CMD_GET_ISE_SETTING_APPID) {
3218                     if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3219                         String ime_setting_appid;
3220                         m_info_manager->get_ise_setting_appid(client_id, ime_setting_appid);
3221
3222                         Transaction trans;
3223                         Socket client_socket(client_id);
3224                         trans.clear();
3225                         trans.put_command(SCIM_TRANS_CMD_REPLY);
3226                         trans.put_command(SCIM_TRANS_CMD_OK);
3227                         trans.put_data(ime_setting_appid);
3228                         trans.write_to_socket(client_socket);
3229                     }
3230                     else {
3231                         LOGW ("Access denied to get ise setting appid");
3232                         send_fail_reply (client_id);
3233                     }
3234                 } else if (cmd == ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY) {
3235                     uint32 angle;
3236
3237                     Transaction trans;
3238                     Socket client_socket(client_id);
3239
3240                     trans.clear();
3241                     trans.put_command(SCIM_TRANS_CMD_REPLY);
3242
3243                     if (m_recv_trans.get_data(angle)) {
3244                         struct rectinfo info = {0, 0, 0, 0};
3245                         m_info_manager->get_recent_ise_geometry(client_id, angle, info);
3246
3247                         trans.put_command(SCIM_TRANS_CMD_OK);
3248                         trans.put_data(info.pos_x);
3249                         trans.put_data(info.pos_y);
3250                         trans.put_data(info.width);
3251                         trans.put_data(info.height);
3252                     } else {
3253                         trans.put_command(SCIM_TRANS_CMD_FAIL);
3254                     }
3255
3256                     trans.write_to_socket(client_socket);
3257                 } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
3258                     Transaction trans;
3259                     Socket client_socket(client_id);
3260
3261                     trans.clear();
3262                     trans.put_command(SCIM_TRANS_CMD_REPLY);
3263                     trans.put_command(SCIM_TRANS_CMD_OK);
3264                     trans.write_to_socket(client_socket);
3265                     m_info_manager->hide_helper_ise ();
3266                 } else if (cmd == ISM_TRANS_CMD_PRELAUNCH_ISE) {
3267                     Transaction trans;
3268                     Socket client_socket(client_id);
3269
3270                     trans.clear();
3271                     trans.put_command(SCIM_TRANS_CMD_REPLY);
3272                     trans.put_command(SCIM_TRANS_CMD_OK);
3273                     trans.write_to_socket(client_socket);
3274                     m_info_manager->prelaunch_helper_ise();
3275                 } else {
3276                     LOGW ("unknown cmd: %d", cmd);
3277                 }
3278             }
3279
3280             socket_transaction_end();
3281         } else if (client_info.type == REMOTEINPUT_ACT_CLIENT) {
3282             socket_transaction_start();
3283             while (m_recv_trans.get_command(cmd)) {
3284                 if (cmd == ISM_REMOTE_TRANS_CMD_SEND_INPUT_MESSAGE) {
3285                     char*   buf = NULL;
3286                     size_t  len;
3287                     bool ret = false;
3288
3289                     if (m_recv_trans.get_data(&buf, len)) {
3290                         ret = m_info_manager->remoteinput_send_input_message(client_id, buf, len);
3291                     } else {
3292                         LOGW ("wrong format of transaction");
3293                     }
3294
3295                     Transaction trans;
3296                     Socket client_socket(client_id);
3297
3298                     trans.clear();
3299                     trans.put_command(SCIM_TRANS_CMD_REPLY);
3300                     trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3301                     trans.write_to_socket(client_socket);
3302
3303                     if (NULL != buf)
3304                         delete[] buf;
3305                 } else if (cmd == ISM_REMOTE_TRANS_CMD_CHECK_PRIVILEGE) {
3306                     bool ret = false;
3307
3308                     if (m_info_manager->check_privilege_by_sockfd(client_id, REMOTEINPUT_PRIVILEGE))
3309                         ret = true;
3310
3311                     Transaction trans;
3312                     Socket client_socket(client_id);
3313
3314                     trans.clear();
3315                     trans.put_command(SCIM_TRANS_CMD_REPLY);
3316                     trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3317                     trans.write_to_socket(client_socket);
3318                 } else if (cmd == ISM_REMOTE_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
3319                     uint32 offset;
3320                     uint32 len;
3321                     bool ret = false;
3322
3323                     if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
3324                         ret = m_info_manager->remoteinput_delete_surrounding_text(offset, len);
3325                     } else {
3326                         LOGW ("wrong format of transaction");
3327                     }
3328
3329                     Transaction trans;
3330                     Socket client_socket(client_id);
3331
3332                     trans.clear();
3333                     trans.put_command(SCIM_TRANS_CMD_REPLY);
3334                     trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3335                     trans.write_to_socket(client_socket);
3336                 } else {
3337                     LOGW ("unknown cmd: %d", cmd);
3338                 }
3339             }
3340
3341             socket_transaction_end ();
3342         }
3343     }
3344
3345     void socket_exception_callback(SocketServer*   server,
3346                                    const Socket&   client) {
3347         SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_exception_callback (" << client.get_id() << ")\n";
3348         LOGD ("client id:%d", client.get_id());
3349         socket_close_connection(server, client);
3350     }
3351
3352     bool socket_open_connection(SocketServer*   server,
3353                                 const Socket&   client) {
3354         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_open_connection (" << client.get_id() << ")\n";
3355         LOGD ("client id:%d", client.get_id());
3356         uint32 key;
3357         String type = scim_socket_accept_connection(key,
3358                       String("Panel"),
3359                       String("FrontEnd,FrontEnd_Active,Helper,Helper_Active,IMControl_Active,IMControl_Passive,RemoteInput_Active,RemoteInput_Passive,SocketConfig"),
3360                       client,
3361                       m_socket_timeout);
3362
3363         SCIM_DEBUG_MAIN (3) << "type = " << type << "\n";
3364         if (type.length()) {
3365             ClientType _type = ((type == "FrontEnd") ? FRONTEND_CLIENT :
3366                                ((type == "FrontEnd_Active") ? FRONTEND_ACT_CLIENT :
3367                                ((type == "Helper") ? HELPER_CLIENT :
3368                                ((type == "Helper_Active") ? HELPER_ACT_CLIENT :
3369                                ((type == "IMControl_Active") ? IMCONTROL_ACT_CLIENT :
3370                                ((type == "IMControl_Passive") ? IMCONTROL_CLIENT :
3371                                ((type == "RemoteInput_Active") ? REMOTEINPUT_ACT_CLIENT :
3372                                ((type == "RemoteInput_Passive") ? REMOTEINPUT_CLIENT : CONFIG_CLIENT))))))));
3373             lock();
3374             m_info_manager->add_client(client.get_id(), key, _type);
3375             unlock();
3376             return true;
3377         }
3378         LOGW ("open_connection failed");
3379
3380         SCIM_DEBUG_MAIN(4) << "Close client connection " << client.get_id() << "\n";
3381         server->close_connection(client);
3382         return false;
3383     }
3384
3385     void socket_close_connection(SocketServer*   server,
3386                                  const Socket&   client) {
3387         SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_close_connection (" << client.get_id() << ")\n";
3388         LOGD ("client id:%d", client.get_id());
3389         int i = 0;
3390         std::vector<Ecore_Fd_Handler *>::iterator IterPos;
3391
3392         for (IterPos = _read_handler_list.begin (); IterPos != _read_handler_list.end (); ++IterPos, ++i) {
3393             if (ecore_main_fd_handler_fd_get (_read_handler_list[i]) == client.get_id()) {
3394                 ::close (client.get_id ());
3395                 ecore_main_fd_handler_del (_read_handler_list[i]);
3396                 _read_handler_list.erase (IterPos);
3397                 break;
3398             }
3399         }
3400         m_info_manager->del_client(client.get_id());
3401     }
3402
3403     void socket_transaction_start(void) {
3404         //m_signal_transaction_start ();
3405     }
3406
3407     void socket_transaction_end(void) {
3408         //m_signal_transaction_end ();
3409     }
3410
3411     void lock(void) {
3412         //m_signal_lock ();
3413     }
3414     void unlock(void) {
3415         //m_signal_unlock ();
3416     }
3417 };
3418
3419 } /* namespace scim */
3420
3421 /***************************************************/
3422 /*** Beginning of panel agent interface for ISF ***/
3423 /***************************************************/
3424 static scim::PanelAgentPointer instance;
3425
3426 extern "C" {
3427
3428     EXAPI void scim_module_init(void)
3429     {
3430     }
3431
3432     EXAPI void scim_module_exit(void)
3433     {
3434         instance.reset();
3435     }
3436
3437     EXAPI void scim_panel_agent_module_init(const scim::ConfigPointer& config)
3438     {
3439         LOGD ("");
3440     }
3441
3442     EXAPI scim::PanelAgentPointer scim_panel_agent_module_get_instance()
3443     {
3444         scim::PanelAgentBase* _instance = NULL;
3445         if (instance.null()) {
3446             try {
3447                 _instance = new scim::EcoreSocketPanelAgent();
3448             } catch (...) {
3449                 delete _instance;
3450                 _instance = NULL;
3451             }
3452             if (_instance)
3453                 instance = _instance;
3454         }
3455         return instance;
3456     }
3457 }
3458
3459 /*
3460 vi:ts=4:nowrap:ai:expandtab
3461 */