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