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