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