ism/modules/panelagent/ecoresocket/ecore_socket_panel_agent_module.cpp

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