2 * ISF(Input Service Framework)
4 * ISF is based on SCIM 1.4.7 and extended for supporting more mobile fitable.
5 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
7 * Contact: Li Zhang <li2012.zhang@samsung.com>
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)
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.
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
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
37 #include <sys/types.h>
38 #include <sys/times.h>
39 #include <sys/socket.h>
44 #include "scim_private.h"
46 #include "scim_stl_map.h"
47 #include "isf_debug.h"
53 #define LOG_TAG "ISF_ECORE_SOCKET_MODULE"
55 #define IMEMANAGER_PRIVILEGE "http://tizen.org/privilege/imemanager"
56 #define REMOTEINPUT_PRIVILEGE "http://tizen.org/privilege/internal/default/platform"
58 #define SCIM_CONFIG_PANEL_SOCKET_CONFIG_READONLY "/Panel/Socket/ConfigReadOnly"
63 struct HelperClientStub {
67 HelperClientStub(int i = 0, int r = 0) : id(i), ref(r) { }
70 struct IMControlStub {
71 std::vector<ISE_INFO> info;
72 std::vector<int> count;
75 void aul_wakeup_ime_application(int sockfd)
78 socklen_t len = sizeof(struct ucred);
79 if (getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == 0) {
80 int ret = aul_update_freezer_status((long)ucred.pid, "wakeup");
81 LOGD("aul_update_freezer_status : %d %d", ucred.pid, ret);
83 LOGD("getsockopt failed : %d", errno);
86 #define DEFAULT_CONTEXT_VALUE 0xfff
88 #define scim_module_init ecoresocket_LTX_scim_module_init
89 #define scim_module_exit ecoresocket_LTX_scim_module_exit
90 #define scim_panel_agent_module_init ecoresocket_LTX_scim_panel_agent_module_init
91 #define scim_panel_agent_module_get_instance ecoresocket_LTX_scim_panel_agent_module_get_instance
94 //==================================== PanelAgent ===========================
95 class EcoreSocketPanelAgent: public PanelAgentBase
100 String m_socket_address;
101 SocketServer m_socket_server;
103 Transaction m_send_trans;
104 Transaction m_recv_trans;
105 Transaction m_nest_trans;
107 bool m_should_shared_ise;
110 std::vector<Ecore_Fd_Handler*> _read_handler_list;
112 InfoManager* m_info_manager;
115 EcoreSocketPanelAgent()
116 : PanelAgentBase ("ecore_socket"),
117 m_should_exit(false),
118 m_socket_timeout(scim_get_default_socket_timeout()),
119 m_should_shared_ise(false),
120 m_ise_exiting(false),
121 m_info_manager(NULL) {
122 m_socket_server.signal_connect_accept(slot(this, &EcoreSocketPanelAgent::socket_accept_callback));
123 m_socket_server.signal_connect_receive(slot(this, &EcoreSocketPanelAgent::socket_receive_callback));
124 m_socket_server.signal_connect_exception(slot(this, &EcoreSocketPanelAgent::socket_exception_callback));
127 ~EcoreSocketPanelAgent() {
129 for (unsigned int ii = 0; ii < _read_handler_list.size(); ++ii) {
130 ecore_main_fd_handler_del(_read_handler_list[ii]);
132 _read_handler_list.clear();
135 bool initialize(InfoManager* info_manager, const String& display, bool resident) {
136 m_info_manager = info_manager;
137 m_socket_address = scim_get_default_panel_socket_address(display);
139 m_socket_server.shutdown();
141 if (m_socket_server.create(SocketAddress(m_socket_address))) {
142 Ecore_Fd_Handler* panel_agent_read_handler = NULL;
143 panel_agent_read_handler = ecore_main_fd_handler_add(get_server_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
144 _read_handler_list.push_back(panel_agent_read_handler);
147 LOGE("create server failed");
151 bool valid(void) const {
152 return m_socket_server.valid();
156 SCIM_DEBUG_MAIN(1) << "PanelAgent::stop ()\n";
158 m_should_exit = true;
161 if (client.connect(SocketAddress(m_socket_address))) {
166 void update_panel_event(int client, uint32 context_id, int cmd, uint32 nType, uint32 nValue) {
167 LOGD ("client id:%d", client);
168 Socket client_socket(client);
169 m_send_trans.clear();
170 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
171 m_send_trans.put_data(context_id);
172 m_send_trans.put_command(cmd);
173 m_send_trans.put_data(nType);
174 m_send_trans.put_data(nValue);
175 m_send_trans.write_to_socket(client_socket);
178 void move_preedit_caret(int client, uint32 context_id, uint32 position) {
179 SCIM_DEBUG_MAIN(1) << "PanelAgent::move_preedit_caret (" << position << ")\n";
180 LOGD ("client id:%d", client);
181 Socket client_socket(client);
182 m_send_trans.clear();
183 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
184 m_send_trans.put_data((uint32) context_id);
185 m_send_trans.put_command(SCIM_TRANS_CMD_MOVE_PREEDIT_CARET);
186 m_send_trans.put_data((uint32) position);
187 m_send_trans.write_to_socket(client_socket);
192 void request_help(int client_id, uint32 context_id) {
193 SCIM_DEBUG_MAIN(1) << "PanelAgent::request_help ()\n";
194 LOGD ("client id:%d", client_id);
196 Socket client_socket(client_id);
197 m_send_trans.clear();
198 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
199 m_send_trans.put_data((uint32) context_id);
200 m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_REQUEST_HELP);
201 m_send_trans.write_to_socket(client_socket);
204 void request_factory_menu(int client_id, uint32 context_id) {
205 LOGD ("client id:%d", client_id);
206 Socket client_socket(client_id);
207 m_send_trans.clear();
208 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
209 m_send_trans.put_data((uint32) context_id);
210 m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_REQUEST_FACTORY_MENU);
211 m_send_trans.write_to_socket(client_socket);
215 void reset_keyboard_ise(int client, uint32 context_id) {
216 LOGD ("client id:%d", client);
217 Socket client_socket(client);
218 m_send_trans.clear();
219 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
220 m_send_trans.put_data((uint32) context_id);
221 m_send_trans.put_command(ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE);
222 m_send_trans.write_to_socket(client_socket);
225 void update_keyboard_ise_list(int client, uint32 context) {
226 LOGD ("client id:%d", client);
228 Socket client_socket(client);
229 m_send_trans.clear();
230 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
231 m_send_trans.put_data((uint32) context);
232 m_send_trans.put_command(ISM_TRANS_CMD_PANEL_UPDATE_KEYBOARD_ISE);
233 m_send_trans.write_to_socket(client_socket);
236 void change_factory(int client, uint32 context, const String& uuid) {
237 SCIM_DEBUG_MAIN(1) << "PanelAgent::change_factory (" << uuid << ")\n";
238 LOGD ("client id:%d", client);
240 Socket client_socket(client);
241 m_send_trans.clear();
242 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
243 m_send_trans.put_data((uint32) context);
244 m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_CHANGE_FACTORY);
245 m_send_trans.put_data(uuid);
246 m_send_trans.write_to_socket(client_socket);
249 void helper_candidate_show(int client, uint32 context, const String& uuid) {
250 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
251 LOGD ("client id:%d", client);
253 Socket client_socket(client);
255 m_send_trans.clear();
256 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
257 m_send_trans.put_data(context);
258 m_send_trans.put_data(uuid);
259 m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_SHOW);
260 m_send_trans.write_to_socket(client_socket);
263 void helper_candidate_hide(int client, uint32 context, const String& uuid) {
264 LOGD ("client id:%d", client);
266 Socket client_socket(client);
268 m_send_trans.clear();
269 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
270 m_send_trans.put_data(context);
271 m_send_trans.put_data(uuid);
272 m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_HIDE);
273 m_send_trans.write_to_socket(client_socket);
276 void candidate_more_window_show(int client, uint32 context) {
277 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
278 LOGD ("client id:%d", client);
280 Socket client_socket(client);
282 m_send_trans.clear();
283 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
284 m_send_trans.put_data(context);
285 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
286 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
287 m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_SHOW);
288 m_send_trans.write_to_socket(client_socket);
291 void candidate_more_window_hide(int client, uint32 context) {
292 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
293 LOGD ("client id:%d", client);
295 Socket client_socket(client);
297 m_send_trans.clear();
298 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
299 m_send_trans.put_data(context);
300 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
301 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
302 m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_HIDE);
303 m_send_trans.write_to_socket(client_socket);
306 void update_helper_lookup_table(int client, uint32 context, const String& uuid, const LookupTable& table) {
307 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
308 LOGD ("client id:%d", client);
310 Socket client_socket(client);
312 m_send_trans.clear();
313 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
314 m_send_trans.put_data(context);
315 m_send_trans.put_data(uuid);
316 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_LOOKUP_TABLE);
317 m_send_trans.put_data(table);
318 m_send_trans.write_to_socket(client_socket);
321 void select_aux(int client, uint32 contextid, uint32 item) {
322 SCIM_DEBUG_MAIN(1) << "PanelAgent::select_aux (" << item << ")\n";
323 LOGD ("client id:%d", client);
325 Socket client_socket(client);
326 m_send_trans.clear();
327 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
328 m_send_trans.put_data((uint32) contextid);
330 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
331 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
333 m_send_trans.put_command(ISM_TRANS_CMD_SELECT_AUX);
334 m_send_trans.put_data((uint32)item);
335 m_send_trans.write_to_socket(client_socket);
338 void select_candidate(int client, uint32 context, uint32 item) {
339 LOGD ("client id:%d", client);
341 Socket client_socket(client);
342 m_send_trans.clear();
343 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
344 m_send_trans.put_data((uint32) context);
346 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
347 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
349 m_send_trans.put_command(SCIM_TRANS_CMD_SELECT_CANDIDATE);
350 m_send_trans.put_data((uint32)item);
351 m_send_trans.write_to_socket(client_socket);
354 void lookup_table_page_up(int client, uint32 context) {
355 SCIM_DEBUG_MAIN(1) << "PanelAgent::lookup_table_page_up ()\n";
356 LOGD ("client id:%d", client);
358 Socket client_socket(client);
359 m_send_trans.clear();
360 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
361 m_send_trans.put_data((uint32) context);
363 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
364 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
366 m_send_trans.put_command(SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_UP);
367 m_send_trans.write_to_socket(client_socket);
370 void lookup_table_page_down(int client, uint32 context) {
371 LOGD ("client id:%d", client);
373 Socket client_socket(client);
374 m_send_trans.clear();
375 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
376 m_send_trans.put_data((uint32) context);
378 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
379 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
381 m_send_trans.put_command(SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_DOWN);
382 m_send_trans.write_to_socket(client_socket);
385 void update_lookup_table_page_size(int client, uint32 context, uint32 size) {
386 LOGD ("client id:%d", client);
388 Socket client_socket(client);
389 m_send_trans.clear();
390 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
391 m_send_trans.put_data((uint32) context);
393 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
394 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
396 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE_PAGE_SIZE);
397 m_send_trans.put_data(size);
398 m_send_trans.write_to_socket(client_socket);
401 void update_candidate_item_layout(int client, uint32 context, const std::vector<uint32>& row_items) {
402 LOGD ("client id:%d", client);
404 Socket client_socket(client);
405 m_send_trans.clear();
406 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
407 m_send_trans.put_data((uint32) context);
409 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
410 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
412 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_ITEM_LAYOUT);
413 m_send_trans.put_data(row_items);
414 m_send_trans.write_to_socket(client_socket);
417 void select_associate(int client, uint32 context, uint32 item) {
418 LOGD ("client id:%d", client);
420 Socket client_socket(client);
421 m_send_trans.clear();
422 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
423 m_send_trans.put_data((uint32) context);
425 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
426 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
428 m_send_trans.put_command(ISM_TRANS_CMD_SELECT_ASSOCIATE);
429 m_send_trans.put_data((uint32)item);
430 m_send_trans.write_to_socket(client_socket);
433 void associate_table_page_up(int client, uint32 context) {
434 LOGD ("client id:%d", client);
436 Socket client_socket(client);
437 m_send_trans.clear();
438 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
439 m_send_trans.put_data((uint32) context);
441 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
442 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
444 m_send_trans.put_command(ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_UP);
445 m_send_trans.write_to_socket(client_socket);
448 void associate_table_page_down(int client, uint32 context) {
449 LOGD ("client id:%d", client);
451 Socket client_socket(client);
452 m_send_trans.clear();
453 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
454 m_send_trans.put_data((uint32) context);
456 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
457 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
459 m_send_trans.put_command(ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_DOWN);
460 m_send_trans.write_to_socket(client_socket);
463 void update_associate_table_page_size(int client, uint32 context, uint32 size) {
464 LOGD ("client id:%d", client);
466 Socket client_socket(client);
467 m_send_trans.clear();
468 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
469 m_send_trans.put_data((uint32) context);
471 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
472 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
474 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE_PAGE_SIZE);
475 m_send_trans.put_data(size);
476 m_send_trans.write_to_socket(client_socket);
479 void update_displayed_candidate_number(int client, uint32 context, uint32 size) {
480 LOGD ("client id:%d", client);
482 Socket client_socket(client);
483 m_send_trans.clear();
484 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
485 m_send_trans.put_data((uint32) context);
487 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
488 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
490 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_DISPLAYED_CANDIDATE);
491 m_send_trans.put_data(size);
492 m_send_trans.write_to_socket(client_socket);
495 void send_longpress_event(int client, uint32 context, int index) {
496 LOGD ("client id:%d", client);
498 Socket client_socket(client);
499 m_send_trans.clear();
500 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
501 m_send_trans.put_data((uint32) context);
503 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
504 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
506 m_send_trans.put_command(ISM_TRANS_CMD_LONGPRESS_CANDIDATE);
507 m_send_trans.put_data(index);
508 m_send_trans.write_to_socket(client_socket);
511 void trigger_property(int client, uint32 context, const String& property) {
512 LOGD ("client id:%d", client);
514 Socket client_socket(client);
515 m_send_trans.clear();
516 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
517 m_send_trans.put_data((uint32) context);
519 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
520 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
522 m_send_trans.put_command(SCIM_TRANS_CMD_TRIGGER_PROPERTY);
523 m_send_trans.put_data(property);
524 m_send_trans.write_to_socket(client_socket);
527 void focus_out_helper(int client, uint32 context, const String& uuid) {
528 LOGD ("client id:%d", client);
530 Socket client_socket(client);
531 m_send_trans.clear();
532 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
533 m_send_trans.put_data(context);
534 m_send_trans.put_data(uuid);
535 m_send_trans.put_command(SCIM_TRANS_CMD_FOCUS_OUT);
536 m_send_trans.write_to_socket(client_socket);
539 void focus_in_helper(int client, uint32 context, const String& uuid) {
540 LOGD ("client id:%d", client);
542 Socket client_socket(client);
543 m_send_trans.clear();
544 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
545 m_send_trans.put_data(context);
546 m_send_trans.put_data(uuid);
547 m_send_trans.put_command(SCIM_TRANS_CMD_FOCUS_IN);
548 m_send_trans.write_to_socket(client_socket);
551 void show_helper(int client, uint32 context, const String& uuid, char* data, size_t& len) {
552 LOGD ("client id:%d", client);
554 Socket client_socket(client);
556 aul_wakeup_ime_application(client_socket.get_id());
558 m_send_trans.clear();
559 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
560 m_send_trans.put_data(context);
561 m_send_trans.put_data(uuid);
562 m_send_trans.put_command(ISM_TRANS_CMD_SHOW_ISE_PANEL);
563 m_send_trans.put_data(data, len);
564 m_send_trans.write_to_socket(client_socket);
567 void hide_helper(int client, uint32 context, const String& uuid) {
568 LOGD ("client id:%d", client);
570 Socket client_socket(client);
571 m_send_trans.clear();
572 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
573 m_send_trans.put_data(context);
574 m_send_trans.put_data(uuid);
575 m_send_trans.put_command(ISM_TRANS_CMD_HIDE_ISE_PANEL);
576 m_send_trans.write_to_socket(client_socket);
579 void set_helper_mode(int client, uint32 context, const String& uuid, uint32& mode) {
580 LOGD ("client id:%d", client);
582 Socket client_socket(client);
583 m_send_trans.clear();
584 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
585 m_send_trans.put_data(context);
586 m_send_trans.put_data(uuid);
587 m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_MODE);
588 m_send_trans.put_data(mode);
589 m_send_trans.write_to_socket(client_socket);
592 void set_helper_language(int client, uint32 context, const String& uuid, uint32& language) {
593 LOGD ("client id:%d", client);
595 Socket client_socket(client);
596 m_send_trans.clear();
597 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
598 m_send_trans.put_data(context);
599 m_send_trans.put_data(uuid);
600 m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_LANGUAGE);
601 m_send_trans.put_data(language);
602 m_send_trans.write_to_socket(client_socket);
605 void set_helper_imdata(int client, uint32 context, const String& uuid, const char* imdata, size_t& len) {
606 LOGD ("client id:%d", client);
608 Socket client_socket(client);
609 m_send_trans.clear();
610 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
611 m_send_trans.put_data(context);
612 m_send_trans.put_data(uuid);
613 m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_IMDATA);
614 m_send_trans.put_data(imdata, len);
615 m_send_trans.write_to_socket(client_socket);
618 void set_helper_return_key_type(int client, uint32 context, const String& uuid, uint32 type) {
619 LOGD ("client id:%d", client);
621 Socket client_socket(client);
622 m_send_trans.clear();
623 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
624 m_send_trans.put_data(context);
625 m_send_trans.put_data(uuid);
626 m_send_trans.put_command(ISM_TRANS_CMD_SET_RETURN_KEY_TYPE);
627 m_send_trans.put_data(type);
628 m_send_trans.write_to_socket(client_socket);
631 void get_helper_return_key_type(int client, uint32 context, const String& uuid, _OUT_ uint32& type) {
632 LOGD ("client id:%d", client);
634 Socket client_socket(client);
637 trans.put_command(SCIM_TRANS_CMD_REPLY);
638 trans.put_data(context);
639 trans.put_data(uuid);
640 trans.put_command(ISM_TRANS_CMD_GET_RETURN_KEY_TYPE);
644 if (trans.write_to_socket(client_socket)
645 && trans.read_from_socket(client_socket)
646 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
647 && trans.get_data(type)) {
648 SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
651 LOGW ("read failed");
655 void set_helper_return_key_disable(int client, uint32 context, const String& uuid, uint32 disabled) {
656 LOGD ("client id:%d", client);
658 Socket client_socket(client);
659 m_send_trans.clear();
660 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
661 m_send_trans.put_data(context);
662 m_send_trans.put_data(uuid);
663 m_send_trans.put_command(ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE);
664 m_send_trans.put_data(disabled);
665 m_send_trans.write_to_socket(client_socket);
668 void get_helper_return_key_disable(int client, uint32 context, const String& uuid, _OUT_ uint32& disabled) {
669 Socket client_socket(client);
670 LOGD ("client id:%d", client);
675 trans.put_command(SCIM_TRANS_CMD_REPLY);
676 trans.put_data(context);
677 trans.put_data(uuid);
678 trans.put_command(ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE);
682 if (trans.write_to_socket(client_socket)
683 && trans.read_from_socket(client_socket)
684 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
685 && trans.get_data(disabled)) {
686 SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
689 LOGW ("read failed");
693 void set_helper_layout(int client, uint32 context, const String& uuid, uint32& layout) {
694 LOGD ("client id:%d", client);
696 Socket client_socket(client);
697 m_send_trans.clear();
698 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
699 m_send_trans.put_data(context);
700 m_send_trans.put_data(uuid);
701 m_send_trans.put_command(ISM_TRANS_CMD_SET_LAYOUT);
702 m_send_trans.put_data(layout);
703 m_send_trans.write_to_socket(client_socket);
706 void set_helper_input_mode(int client, uint32 context, const String& uuid, uint32& mode) {
707 LOGD ("client id:%d", client);
709 Socket client_socket(client);
710 m_send_trans.clear();
711 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
712 m_send_trans.put_data(context);
713 m_send_trans.put_data(uuid);
714 m_send_trans.put_command(ISM_TRANS_CMD_SET_INPUT_MODE);
715 m_send_trans.put_data(mode);
716 m_send_trans.write_to_socket(client_socket);
719 void set_helper_input_hint(int client, uint32 context, const String& uuid, uint32& hint) {
720 LOGD ("client id:%d", client);
722 Socket client_socket(client);
723 m_send_trans.clear();
724 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
725 m_send_trans.put_data(context);
726 m_send_trans.put_data(uuid);
727 m_send_trans.put_command(ISM_TRANS_CMD_SET_INPUT_HINT);
728 m_send_trans.put_data(hint);
729 m_send_trans.write_to_socket(client_socket);
732 void set_helper_bidi_direction(int client, uint32 context, const String& uuid, uint32& direction) {
733 LOGD ("client id:%d", client);
735 Socket client_socket(client);
736 m_send_trans.clear();
737 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
738 m_send_trans.put_data(context);
739 m_send_trans.put_data(uuid);
740 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION);
741 m_send_trans.put_data(direction);
742 m_send_trans.write_to_socket(client_socket);
745 void set_helper_caps_mode(int client, uint32 context, const String& uuid, uint32& mode) {
746 LOGD ("client id:%d", client);
748 Socket client_socket(client);
749 m_send_trans.clear();
750 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
751 m_send_trans.put_data(context);
752 m_send_trans.put_data(uuid);
753 m_send_trans.put_command(ISM_TRANS_CMD_SET_CAPS_MODE);
754 m_send_trans.put_data(mode);
755 m_send_trans.write_to_socket(client_socket);
758 void show_helper_option_window(int client, uint32 context, const String& uuid, uint32 caller_pid, uint32 ime_pid) {
759 LOGD ("client id:%d", client);
761 Socket client_socket(client);
763 aul_wakeup_ime_application(client_socket.get_id());
765 m_send_trans.clear();
766 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
767 m_send_trans.put_data(context);
768 m_send_trans.put_data(uuid);
769 m_send_trans.put_command(ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW);
770 m_send_trans.write_to_socket(client_socket);
773 void resume_helper_option_window(int client, uint32 context, const String& uuid) {
774 LOGD ("client id:%d", client);
776 Socket client_socket(client);
778 aul_wakeup_ime_application(client_socket.get_id());
780 m_send_trans.clear();
781 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
782 m_send_trans.put_data(context);
783 m_send_trans.put_data(uuid);
784 m_send_trans.put_command(ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW);
785 m_send_trans.write_to_socket(client_socket);
788 void set_helper_keyboard_mode(int client, uint32 context, const String& uuid, uint32& mode) {
789 LOGD ("client id:%d", client);
791 Socket client_socket(client);
792 m_send_trans.clear();
793 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
794 m_send_trans.put_data(context);
795 m_send_trans.put_data(uuid);
796 m_send_trans.put_command(ISM_TRANS_CMD_SET_KEYBOARD_MODE);
797 m_send_trans.put_data(mode);
798 m_send_trans.write_to_socket(client_socket);
801 void set_helper_prediction_hint(int client, uint32 context, const String& uuid, String& prediction_hint) {
802 LOGD ("client id:%d", client);
804 Socket client_socket(client);
805 m_send_trans.clear();
806 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
807 m_send_trans.put_data(context);
808 m_send_trans.put_data(uuid);
809 m_send_trans.put_command(ISM_TRANS_CMD_SET_PREDICTION_HINT);
810 m_send_trans.put_data(prediction_hint);
811 m_send_trans.write_to_socket(client_socket);
814 void set_helper_mime_type(int client, uint32 context, const String& uuid, String& mime_type) {
815 LOGD ("client id:%d", client);
817 Socket client_socket(client);
818 m_send_trans.clear();
819 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
820 m_send_trans.put_data(context);
821 m_send_trans.put_data(uuid);
822 m_send_trans.put_command(ISM_TRANS_CMD_SET_MIME_TYPE);
823 m_send_trans.put_data(mime_type);
824 m_send_trans.write_to_socket(client_socket);
827 void set_helper_prediction_hint_data(int client, uint32 context, const String& uuid, String& key, String &value) {
828 Socket client_socket(client);
829 m_send_trans.clear();
830 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
831 m_send_trans.put_data(context);
832 m_send_trans.put_data(uuid);
833 m_send_trans.put_command(ISM_TRANS_CMD_SET_PREDICTION_HINT_DATA);
834 m_send_trans.put_data(key);
835 m_send_trans.put_data(value);
836 m_send_trans.write_to_socket(client_socket);
839 void set_helper_optimization_hint(int client, uint32 context, const String& uuid, uint32& hint) {
840 Socket client_socket(client);
841 m_send_trans.clear();
842 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
843 m_send_trans.put_data(context);
844 m_send_trans.put_data(uuid);
845 m_send_trans.put_command(ISM_TRANS_CMD_SET_OPTIMIZATION_HINT);
846 m_send_trans.put_data(hint);
847 m_send_trans.write_to_socket(client_socket);
850 void finalize_content_helper(int client, uint32 context, const String& uuid, String& text, uint32& cursor_pos) {
851 LOGD("client id:%d", client);
853 Socket client_socket(client);
854 m_send_trans.clear();
855 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
856 m_send_trans.put_data(context);
857 m_send_trans.put_data(uuid);
858 m_send_trans.put_command(ISM_TRANS_CMD_FINALIZE_CONTENT);
859 m_send_trans.put_data(text);
860 m_send_trans.put_data(cursor_pos);
861 m_send_trans.write_to_socket(client_socket);
864 bool process_key_event(int client, uint32 context, const String& uuid, KeyEvent& key, uint32 serial, uint32 keycode) {
865 LOGD ("client id:%d", client);
867 Socket client_socket(client);
872 trans.put_command(SCIM_TRANS_CMD_REPLY);
873 trans.put_data(context);
874 trans.put_data(uuid);
875 trans.put_command(SCIM_TRANS_CMD_PROCESS_KEY_EVENT);
877 trans.put_data(serial);
878 trans.put_data(keycode);
880 if (trans.write_to_socket(client_socket)) {
881 SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
884 LOGW ("read failed");
890 bool get_helper_geometry(int client, uint32 context, String& uuid, _OUT_ struct rectinfo& info) {
891 LOGD ("client id:%d", client);
893 Socket client_socket(client);
897 trans.put_command(SCIM_TRANS_CMD_REPLY);
898 trans.put_data(context);
899 trans.put_data(uuid);
900 trans.put_command(ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY);
902 if (trans.write_to_socket(client_socket)) {
907 if (trans.read_from_socket(client_socket)
908 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
909 && trans.get_data(info.pos_x)
910 && trans.get_data(info.pos_y)
911 && trans.get_data(info.width)
912 && trans.get_data(info.height)) {
913 SCIM_DEBUG_MAIN(1) << __func__ << " is successful\n";
916 LOGW ("read failed");
918 LOGW ("write failed");
923 void get_helper_imdata(int client, uint32 context, String& uuid, char** imdata, size_t& len) {
924 LOGD ("client id:%d", client);
925 Socket client_socket(client);
929 trans.put_command(SCIM_TRANS_CMD_REPLY);
930 trans.put_data(context);
931 trans.put_data(uuid);
932 trans.put_command(ISM_TRANS_CMD_GET_ISE_IMDATA);
936 if (trans.write_to_socket(client_socket)
937 && trans.read_from_socket(client_socket)
938 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
939 && trans.get_data(imdata, len)) {
940 LOGD ("length of imdata is %zu", len);
942 LOGW ("read imdata failed");
946 void get_helper_layout(int client, uint32 context, String& uuid, uint32& layout) {
947 LOGD ("client id:%d", client);
949 Socket client_socket(client);
953 trans.put_command(SCIM_TRANS_CMD_REPLY);
954 trans.put_data(context);
955 trans.put_data(uuid);
956 trans.put_command(ISM_TRANS_CMD_GET_LAYOUT);
960 if (trans.write_to_socket(client_socket)
961 && trans.read_from_socket(client_socket)
962 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
963 && trans.get_data(layout)) {
964 SCIM_DEBUG_MAIN(1) << "get_helper_layout success\n";
969 void get_ise_language_locale(int client, uint32 context, String& uuid, char** data, size_t& len) {
970 SCIM_DEBUG_MAIN(4) << __func__ << "\n";
971 LOGD ("client id:%d", client);
976 trans.put_command(SCIM_TRANS_CMD_REPLY);
977 trans.put_data(context);
978 trans.put_data(uuid);
979 trans.put_command(ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE);
982 Socket client_socket(client);
984 if (trans.write_to_socket(client_socket)
985 && trans.read_from_socket(client_socket)
986 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
987 && trans.get_data(data, len)) {
993 void check_option_window(int client, uint32 context, String& uuid, _OUT_ uint32& avail) {
994 LOGD ("client id:%d", client);
997 Socket client_socket(client);
1002 trans.put_command(SCIM_TRANS_CMD_REPLY);
1003 trans.put_data(context);
1004 trans.put_data(uuid);
1005 trans.put_command(ISM_TRANS_CMD_CHECK_OPTION_WINDOW);
1006 trans.write_to_socket(client_socket);
1008 if (!trans.read_from_socket(client_socket, m_socket_timeout) ||
1009 !trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REPLY ||
1010 !trans.get_data(avail)) {
1011 LOGW ("ISM_TRANS_CMD_CHECK_OPTION_WINDOW failed");
1015 void reset_ise_option(int client, uint32 context) {
1016 LOGD ("client id:%d", client);
1018 Socket client_socket(client);
1019 m_send_trans.clear();
1020 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1021 m_send_trans.put_data((uint32) context);
1022 m_send_trans.put_command(ISM_TRANS_CMD_RESET_ISE_OPTION);
1023 m_send_trans.write_to_socket(client_socket);
1026 void reset_helper_context(int client, uint32 context, const String& uuid) {
1027 LOGD ("client id:%d", client);
1029 Socket client_socket(client);
1030 m_send_trans.clear();
1031 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1032 m_send_trans.put_data(context);
1033 m_send_trans.put_data(uuid);
1034 m_send_trans.put_command(ISM_TRANS_CMD_RESET_ISE_CONTEXT);
1035 m_send_trans.write_to_socket(client_socket);
1038 void reload_config(int client) {
1039 SCIM_DEBUG_MAIN(1) << "PanelAgent::reload_config ()\n";
1040 LOGD ("client id:%d", client);
1042 m_send_trans.clear();
1043 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1044 m_send_trans.put_command(SCIM_TRANS_CMD_RELOAD_CONFIG);
1046 Socket client_socket(client);
1047 m_send_trans.write_to_socket(client_socket);
1050 void exit(int client, uint32 context) {
1051 SCIM_DEBUG_MAIN(1) << "PanelAgent::exit ()\n";
1052 LOGD ("client id:%d", client);
1054 m_send_trans.clear();
1055 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1057 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT) {
1058 m_send_trans.put_data(context);
1059 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
1062 m_send_trans.put_command(SCIM_TRANS_CMD_EXIT);
1064 Socket client_socket(client);
1065 m_send_trans.write_to_socket(client_socket);
1067 m_info_manager->del_client(client_socket.get_id());
1070 bool process_input_device_event(int client, uint32 context, const String& uuid, uint32 type, const char *data, size_t len, _OUT_ uint32& result) {
1071 LOGD("client id:%d", client);
1073 Socket client_socket(client);
1078 trans.put_command(SCIM_TRANS_CMD_REPLY);
1079 trans.put_data(context);
1080 trans.put_data(uuid);
1081 trans.put_command(ISM_TRANS_CMD_PROCESS_INPUT_DEVICE_EVENT);
1082 trans.put_data(type);
1083 trans.put_data(data, len);
1085 if (trans.write_to_socket(client_socket)) {
1086 SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
1090 LOGW("read failed");
1096 void socket_update_surrounding_text(int client, uint32 context, const String& uuid, String& text, uint32 cursor) {
1097 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1098 LOGD ("client id:%d", client);
1100 Socket client_socket(client);
1102 m_send_trans.clear();
1103 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1104 m_send_trans.put_data(context);
1105 m_send_trans.put_data(uuid);
1106 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT);
1107 m_send_trans.put_data(text);
1108 m_send_trans.put_data(cursor);
1109 m_send_trans.write_to_socket(client_socket);
1111 m_send_trans.clear();
1112 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1113 m_send_trans.put_command(ISM_TRANS_CMD_FLUSH_BUFFER);
1114 m_send_trans.write_to_socket(client_socket);
1117 void socket_remoteinput_focus_in (int client) {
1118 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1119 LOGD ("client id:%d", client);
1122 ret = (client == -1) ? false : true;
1125 Socket client_socket(client);
1127 m_send_trans.clear();
1128 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1129 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_FOCUS_IN);
1130 m_send_trans.write_to_socket(client_socket);
1134 void socket_remoteinput_focus_out (int client) {
1135 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1136 LOGD ("client id:%d", client);
1139 ret = (client == -1) ? false : true;
1142 Socket client_socket(client);
1144 m_send_trans.clear();
1145 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1146 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_FOCUS_OUT);
1147 m_send_trans.write_to_socket(client_socket);
1151 void socket_remoteinput_entry_metadata (int client, uint32 hint, uint32 layout, int variation, uint32 autocapital_type, int return_key_disabled, uint32 return_key_type) {
1152 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1153 LOGD ("client id:%d", client);
1156 ret = (client == -1) ? false : true;
1159 Socket client_socket(client);
1161 m_send_trans.clear();
1162 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1163 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_ENTRY_METADATA);
1164 m_send_trans.put_data(hint);
1165 m_send_trans.put_data(layout);
1166 m_send_trans.put_data(variation);
1167 m_send_trans.put_data(autocapital_type);
1168 m_send_trans.put_data(return_key_disabled);
1169 m_send_trans.put_data(return_key_type);
1170 m_send_trans.write_to_socket(client_socket);
1174 void socket_remoteinput_surrounding_text (int client, String& text, uint32 cursor) {
1175 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1176 LOGD ("client id:%d", client);
1179 ret = (client == -1) ? false : true;
1182 Socket client_socket(client);
1184 m_send_trans.clear();
1185 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1186 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_SURROUNDING_TEXT);
1187 m_send_trans.put_data(text);
1188 m_send_trans.put_data(cursor);
1189 m_send_trans.write_to_socket(client_socket);
1193 void socket_remoteinput_input_resource (int client, uint32 input_resource) {
1194 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1195 LOGD ("client id:%d", client);
1198 ret = (client == -1) ? false : true;
1201 Socket client_socket(client);
1203 m_send_trans.clear();
1204 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1205 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_INPUT_RESOURCE);
1206 m_send_trans.put_data(input_resource);
1207 m_send_trans.write_to_socket(client_socket);
1211 void socket_update_selection(int client, uint32 context, String& uuid, String text) {
1212 LOGD ("client id:%d", client);
1214 Socket client_socket(client);
1216 m_send_trans.clear();
1217 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1218 m_send_trans.put_data(context);
1219 m_send_trans.put_data(uuid);
1220 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SELECTION);
1221 m_send_trans.put_data(text);
1222 m_send_trans.write_to_socket(client_socket);
1224 m_send_trans.clear();
1225 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1226 m_send_trans.put_command(ISM_TRANS_CMD_FLUSH_BUFFER);
1227 m_send_trans.write_to_socket(client_socket);
1230 void socket_get_keyboard_ise_list(int client, uint32 context, const String& uuid, std::vector<String>& list) {
1231 LOGD ("client id:%d", client);
1233 Socket socket_client(client);
1234 m_send_trans.clear();
1235 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1236 m_send_trans.put_data(context);
1237 m_send_trans.put_data(uuid);
1238 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE_LIST);
1239 m_send_trans.put_data(list.size());
1241 for (unsigned int i = 0; i < list.size(); i++)
1242 m_send_trans.put_data(list[i]);
1244 m_send_trans.write_to_socket(socket_client);
1247 void socket_get_candidate_ui(int client, uint32 context, const String& uuid, int style, int mode) {
1248 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_get_candidate_ui ()\n";
1250 LOGD ("client id:%d", client);
1252 Socket socket_client(client);
1253 m_send_trans.clear();
1254 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1255 m_send_trans.put_data(context);
1256 m_send_trans.put_data(uuid);
1257 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_UI);
1258 m_send_trans.put_data(style);
1259 m_send_trans.put_data(mode);
1260 m_send_trans.write_to_socket(socket_client);
1263 void socket_get_candidate_geometry(int client, uint32 context, const String& uuid, struct rectinfo& info) {
1264 SCIM_DEBUG_MAIN(4) << __func__ << " \n";
1266 LOGD ("client id:%d", client);
1268 Socket socket_client(client);
1269 m_send_trans.clear();
1270 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1271 m_send_trans.put_data(context);
1272 m_send_trans.put_data(uuid);
1273 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_GEOMETRY);
1274 m_send_trans.put_data(info.pos_x);
1275 m_send_trans.put_data(info.pos_y);
1276 m_send_trans.put_data(info.width);
1277 m_send_trans.put_data(info.height);
1278 m_send_trans.write_to_socket(socket_client);
1281 void socket_get_keyboard_ise(int client, uint32 context, const String& uuid, String& ise_name, String& ise_uuid) {
1282 LOGD ("client id:%d", client);
1284 Socket socket_client(client);
1285 m_send_trans.clear();
1286 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1287 m_send_trans.put_data(context);
1288 m_send_trans.put_data(uuid);
1289 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE);
1290 m_send_trans.put_data(ise_name);
1291 m_send_trans.put_data(ise_uuid);
1292 m_send_trans.write_to_socket(socket_client);
1295 void socket_start_helper(int client, uint32 context, const String& ic_uuid) {
1296 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_start_helper ()\n";
1298 LOGD ("client id:%d", client);
1300 Socket client_socket(client);
1301 m_send_trans.clear();
1302 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1303 m_send_trans.put_data(context);
1304 m_send_trans.put_data(ic_uuid);
1305 m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1306 m_send_trans.write_to_socket(client_socket);
1309 void helper_detach_input_context(int client, uint32 context, const String& ic_uuid) {
1310 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_stop_helper ()\n";
1312 LOGD ("client id:%d", client);
1314 Socket client_socket(client);
1315 m_send_trans.clear();
1316 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1317 m_send_trans.put_data(context);
1318 m_send_trans.put_data(ic_uuid);
1319 m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_DETACH_INPUT_CONTEXT);
1320 m_send_trans.write_to_socket(client_socket);
1323 void helper_process_imengine_event(int client, uint32 context, const String& ic_uuid, const Transaction& _nest_trans) {
1324 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_send_helper_event ()\n";
1325 LOGD ("client id:%d", client);
1327 Socket client_socket(client);
1331 m_send_trans.clear();
1332 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1334 /* FIXME: We presume that client and context are both less than 65536.
1335 * Hopefully, it should be true in any UNIXs.
1336 * So it's ok to combine client and context into one uint32. */
1337 m_send_trans.put_data(context);
1338 m_send_trans.put_data(ic_uuid);
1339 m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_PROCESS_IMENGINE_EVENT);
1340 m_send_trans.put_data(_nest_trans);
1341 m_send_trans.write_to_socket(client_socket);
1346 void process_helper_event(int client, uint32 context, String target_uuid, String active_uuid, Transaction& nest_trans) {
1347 LOGD ("client id:%d", client);
1349 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_helper_send_imengine_event (" << client << ")\n";
1350 Socket socket_client(client);
1352 m_send_trans.clear();
1353 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1354 m_send_trans.put_data(context);
1355 m_send_trans.put_command(SCIM_TRANS_CMD_PROCESS_HELPER_EVENT);
1356 m_send_trans.put_data(target_uuid);
1357 m_send_trans.put_data(active_uuid);
1358 m_send_trans.put_data(nest_trans);
1359 m_send_trans.write_to_socket(socket_client);
1363 void socket_helper_key_event(int client, uint32 context, int cmd, KeyEvent& key) {
1364 LOGD ("client id:%d", client);
1366 Socket socket_client(client);
1368 m_send_trans.clear();
1369 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1370 m_send_trans.put_data(context);
1371 m_send_trans.put_command(cmd);
1372 m_send_trans.put_data(key);
1373 m_send_trans.write_to_socket(socket_client);
1377 void commit_string(int client, uint32 target_context, const WideString& wstr) {
1378 LOGD ("client id:%d", client);
1380 Socket socket_client(client);
1382 m_send_trans.clear();
1383 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1384 m_send_trans.put_data(target_context);
1385 m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_STRING);
1386 m_send_trans.put_data(wstr);
1387 m_send_trans.write_to_socket(socket_client);
1391 void socket_helper_get_surrounding_text(int client, uint32 context_id, uint32 maxlen_before, uint32 maxlen_after) {
1392 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1393 LOGD ("client id:%d", client);
1395 Socket socket_client(client);
1397 m_send_trans.clear();
1398 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1399 m_send_trans.put_data(context_id);
1400 m_send_trans.put_command(SCIM_TRANS_CMD_GET_SURROUNDING_TEXT);
1401 m_send_trans.put_data(maxlen_before);
1402 m_send_trans.put_data(maxlen_after);
1403 m_send_trans.write_to_socket(socket_client);
1407 void socket_helper_delete_surrounding_text(int client, uint32 context_id, uint32 offset, uint32 len) {
1408 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1409 LOGD ("client id:%d", client);
1411 Socket socket_client(client);
1413 m_send_trans.clear();
1414 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1415 m_send_trans.put_data(context_id);
1416 m_send_trans.put_command(SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT);
1417 m_send_trans.put_data(offset);
1418 m_send_trans.put_data(len);
1419 m_send_trans.write_to_socket(socket_client);
1423 void socket_helper_get_selection(int client, uint32 context_id) {
1424 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1425 LOGD ("client id:%d", client);
1428 Socket socket_client(client);
1430 m_send_trans.clear();
1431 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1432 m_send_trans.put_data(context_id);
1433 m_send_trans.put_command(SCIM_TRANS_CMD_GET_SELECTION);
1434 m_send_trans.write_to_socket(socket_client);
1438 void socket_helper_set_selection(int client, uint32 context_id, uint32 start, uint32 end) {
1439 LOGD ("client id:%d", client);
1441 Socket socket_client(client);
1443 m_send_trans.clear();
1444 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1445 m_send_trans.put_data(context_id);
1446 m_send_trans.put_command(SCIM_TRANS_CMD_SET_SELECTION);
1447 m_send_trans.put_data(start);
1448 m_send_trans.put_data(end);
1449 m_send_trans.write_to_socket(socket_client);
1453 void show_preedit_string(int client, uint32 target_context) {
1454 LOGD ("client id:%d", client);
1456 Socket socket_client(client);
1458 m_send_trans.clear();
1459 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1460 m_send_trans.put_data(target_context);
1461 m_send_trans.put_command(SCIM_TRANS_CMD_SHOW_PREEDIT_STRING);
1462 m_send_trans.write_to_socket(socket_client);
1466 void hide_preedit_string(int client, uint32 target_context) {
1467 LOGD ("client id:%d", client);
1469 Socket socket_client(client);
1471 m_send_trans.clear();
1472 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1473 m_send_trans.put_data(target_context);
1474 m_send_trans.put_command(SCIM_TRANS_CMD_HIDE_PREEDIT_STRING);
1475 m_send_trans.write_to_socket(socket_client);
1479 void update_preedit_string(int client, uint32 target_context, WideString preedit, WideString commit, AttributeList& attrs, uint32 caret) {
1480 LOGD ("client id:%d", client);
1482 Socket socket_client(client);
1484 m_send_trans.clear();
1485 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1486 m_send_trans.put_data(target_context);
1487 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
1488 m_send_trans.put_data(preedit);
1489 m_send_trans.put_data(commit);
1490 m_send_trans.put_data(attrs);
1491 m_send_trans.put_data(caret);
1492 m_send_trans.write_to_socket(socket_client);
1496 void update_preedit_caret(int client, uint32 focused_context, uint32 caret) {
1497 LOGD ("client id:%d", client);
1499 Socket socket_client(client);
1501 m_send_trans.clear();
1502 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1503 m_send_trans.put_data(focused_context);
1504 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET);
1505 m_send_trans.put_data(caret);
1506 m_send_trans.write_to_socket(socket_client);
1510 void helper_attach_input_context_and_update_screen(int client, std::vector < std::pair <uint32, String> >& helper_ic_index, uint32 current_screen) {
1511 LOGD ("client id:%d", client);
1513 Socket socket_client(client);
1514 m_send_trans.clear();
1515 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1516 m_send_trans.put_command(SCIM_TRANS_CMD_OK);
1517 m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1519 for (size_t i = 0; i < helper_ic_index.size(); ++i) {
1520 m_send_trans.put_data(helper_ic_index[i].first);
1521 m_send_trans.put_data(helper_ic_index[i].second);
1524 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1525 m_send_trans.put_data((uint32)current_screen);
1526 m_send_trans.write_to_socket(socket_client);
1529 void update_ise_input_context(int client, uint32 focused_context, uint32 type, uint32 value) {
1530 LOGD ("client id:%d", client);
1532 Socket client_socket(client);
1533 m_send_trans.clear();
1534 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1535 m_send_trans.put_data(focused_context);
1536 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT);
1537 m_send_trans.put_data(type);
1538 m_send_trans.put_data(value);
1539 m_send_trans.write_to_socket(client_socket);
1542 void send_private_command(int client, uint32 focused_context, String command) {
1543 LOGD ("client id:%d", client);
1545 Socket socket_client(client);
1547 m_send_trans.clear();
1548 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1549 m_send_trans.put_data(focused_context);
1550 m_send_trans.put_command(SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND);
1551 m_send_trans.put_data(command);
1552 m_send_trans.write_to_socket(socket_client);
1555 void commit_content(int client, uint32 focused_context, String content, String description, String mime_types) {
1556 LOGD ("client id:%d", client);
1558 Socket socket_client(client);
1560 m_send_trans.clear();
1561 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1562 m_send_trans.put_data(focused_context);
1563 m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_CONTENT);
1564 m_send_trans.put_data(content);
1565 m_send_trans.put_data(description);
1566 m_send_trans.put_data(mime_types);
1567 m_send_trans.write_to_socket(socket_client);
1570 void helper_all_update_spot_location(int client, uint32 context_id, String uuid, int x, int y) {
1571 LOGD ("client id:%d", client);
1573 m_send_trans.clear();
1574 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1576 /* FIXME: We presume that client and context are both less than 65536.
1577 * Hopefully, it should be true in any UNIXs.
1578 * So it's ok to combine client and context into one uint32. */
1579 m_send_trans.put_data(context_id);
1580 m_send_trans.put_data(uuid);
1581 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION);
1582 m_send_trans.put_data((uint32) x);
1583 m_send_trans.put_data((uint32) y);
1585 Socket client_socket(client);
1586 m_send_trans.write_to_socket(client_socket);
1589 void helper_all_update_cursor_position(int client, uint32 context_id, String uuid, int cursor_pos) {
1590 LOGD ("client id:%d", client);
1592 m_send_trans.clear();
1593 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1594 m_send_trans.put_data(context_id);
1595 m_send_trans.put_data(uuid);
1596 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CURSOR_POSITION);
1597 m_send_trans.put_data((uint32) cursor_pos);
1599 Socket client_socket(client);
1600 m_send_trans.write_to_socket(client_socket);
1603 void helper_all_update_screen(int client, uint32 context_id, String uuid, int screen) {
1604 LOGD ("client id:%d", client);
1606 m_send_trans.clear();
1607 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1609 /* FIXME: We presume that client and context are both less than 65536.
1610 * Hopefully, it should be true in any UNIXs.
1611 * So it's ok to combine client and context into one uint32. */
1612 m_send_trans.put_data(context_id);
1613 m_send_trans.put_data(uuid);
1614 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1615 m_send_trans.put_data((uint32) screen);
1617 Socket client_socket(client);
1618 m_send_trans.write_to_socket(client_socket);
1621 void set_autocapital_type(int client, uint32 context, String uuid, int mode) {
1622 m_send_trans.clear();
1623 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1625 m_send_trans.put_data(context);
1626 m_send_trans.put_data(uuid);
1627 m_send_trans.put_command(SCIM_TRANS_CMD_SET_AUTOCAPITAL_TYPE);
1628 m_send_trans.put_data((uint32) mode);
1630 Socket client_socket(client);
1631 m_send_trans.write_to_socket(client_socket);
1634 void remote_update_preedit_string (int client, uint32 target_context, const WideString str, const WideString commit, const AttributeList &attrs, uint32 caret) {
1635 Socket client_socket(client);
1637 m_send_trans.clear();
1638 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1639 m_send_trans.put_data(target_context);
1640 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
1641 m_send_trans.put_data(str);
1642 m_send_trans.put_data(commit);
1643 m_send_trans.put_data(attrs);
1644 m_send_trans.put_data(caret);
1645 m_send_trans.write_to_socket(client_socket);
1649 void remote_send_key_event (int client, uint32 target_context, const KeyEvent &key) {
1650 Socket client_socket(client);
1652 m_send_trans.clear ();
1653 m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
1654 m_send_trans.put_data (target_context);
1655 m_send_trans.put_command (SCIM_TRANS_CMD_PROCESS_KEY_EVENT);
1656 m_send_trans.put_data (key);
1657 m_send_trans.write_to_socket (client_socket);
1661 void remote_forward_key_event (int client, uint32 target_context, const KeyEvent &key) {
1662 Socket client_socket(client);
1664 m_send_trans.clear ();
1665 m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
1666 m_send_trans.put_data (target_context);
1667 m_send_trans.put_command (SCIM_TRANS_CMD_FORWARD_KEY_EVENT);
1668 m_send_trans.put_data (key);
1669 m_send_trans.write_to_socket (client_socket);
1673 void remote_commit_string (int client, uint32 target_context, const WideString& wstr) {
1674 LOGD ("client id:%d", client);
1676 Socket socket_client(client);
1678 m_send_trans.clear();
1679 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1680 m_send_trans.put_data(target_context);
1681 m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_STRING);
1682 m_send_trans.put_data(wstr);
1683 m_send_trans.write_to_socket(socket_client);
1687 void remote_delete_surrounding_text (int client, uint32 context_id, uint32 offset, uint32 len) {
1688 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1689 LOGD ("client id:%d", client);
1691 Socket socket_client(client);
1693 m_send_trans.clear();
1694 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1695 m_send_trans.put_data(context_id);
1696 m_send_trans.put_command(SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT);
1697 m_send_trans.put_data(offset);
1698 m_send_trans.put_data(len);
1699 m_send_trans.write_to_socket(socket_client);
1703 void set_prediction_allow (int client, uint32 context, String uuid, int mode) {
1704 LOGD ("client id:%d", client);
1706 m_send_trans.clear();
1707 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1709 m_send_trans.put_data(context);
1710 m_send_trans.put_data(uuid);
1711 m_send_trans.put_command(ISM_TRANS_CMD_SET_PREDICTION_ALLOW);
1712 m_send_trans.put_data((uint32) mode);
1714 Socket client_socket(client);
1715 m_send_trans.write_to_socket(client_socket);
1718 void send_fail_reply (int client)
1720 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1721 LOGD ("client id:%d", client);
1723 Socket client_socket (client);
1726 trans.put_command (SCIM_TRANS_CMD_REPLY);
1727 trans.put_command (SCIM_TRANS_CMD_FAIL);
1728 trans.write_to_socket (client_socket);
1733 bool filter_event(int fd) {
1734 SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_event ()\n";
1736 return m_socket_server.filter_event(fd);
1739 bool filter_exception_event(int fd) {
1740 SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_exception_event ()\n";
1742 return m_socket_server.filter_exception_event(fd);
1745 int get_server_id() {
1746 SCIM_DEBUG_MAIN(1) << "PanelAgent::get_server_id ()\n";
1748 return m_socket_server.get_id();
1751 bool socket_check_client_connection(const Socket& client) {
1752 SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_check_client_connection (" << client.get_id() << ")\n";
1754 unsigned char buf [sizeof(uint32)];
1756 int nbytes = client.read_with_timeout(buf, sizeof(uint32), m_socket_timeout);
1758 if (nbytes == sizeof(uint32))
1762 LOGW ("Error occurred when reading socket: %s", client.get_error_message().c_str());
1764 LOGW ("Timeout when reading socket");
1771 * @brief Callback function for ecore fd handler.
1773 * @param data The data to pass to this callback.
1774 * @param fd_handler The ecore fd handler.
1776 * @return ECORE_CALLBACK_RENEW
1778 static Eina_Bool panel_agent_handler(void* data, Ecore_Fd_Handler* fd_handler) {
1779 if (fd_handler == NULL || data == NULL)
1780 return ECORE_CALLBACK_RENEW;
1782 EcoreSocketPanelAgent* _agent = (EcoreSocketPanelAgent*)data;
1784 int fd = ecore_main_fd_handler_fd_get(fd_handler);
1786 return ECORE_CALLBACK_RENEW;
1788 for (unsigned int i = 0; i < _agent->_read_handler_list.size(); i++) {
1789 if (fd_handler == _agent->_read_handler_list [i]) {
1790 if (!_agent->filter_event(fd)) {
1791 std::cerr << "_panel_agent->filter_event () is failed!!!\n";
1793 ecore_main_fd_handler_del(fd_handler);
1795 ISF_SAVE_LOG("_panel_agent->filter_event (fd=%d) is failed!!!", fd);
1798 return ECORE_CALLBACK_RENEW;
1802 std::cerr << "panel_agent_handler () has received exception event!!!\n";
1803 _agent->filter_exception_event(fd);
1804 ecore_main_fd_handler_del(fd_handler);
1806 ISF_SAVE_LOG("Received exception event (fd=%d)!!!", fd);
1807 return ECORE_CALLBACK_RENEW;
1810 void socket_accept_callback(SocketServer* server,
1811 const Socket& client) {
1812 SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_accept_callback (" << client.get_id() << ")\n";
1816 if (m_should_exit) {
1817 SCIM_DEBUG_MAIN(3) << "Exit Socket Server Thread.\n";
1820 //m_signal_accept_connection (client.get_id ());
1821 Ecore_Fd_Handler* panel_agent_read_handler = ecore_main_fd_handler_add(client.get_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
1822 _read_handler_list.push_back(panel_agent_read_handler);
1828 void socket_receive_callback(SocketServer* server,
1829 const Socket& client) {
1830 int client_id = client.get_id();
1836 ClientInfo client_info;
1838 SCIM_DEBUG_MAIN(1) << "PanelAgent::socket_receive_callback (" << client_id << ")\n";
1840 /* If the connection is closed then close this client. */
1841 if (!socket_check_client_connection(client)) {
1842 LOGW ("check client connection failed");
1843 socket_close_connection(server, client);
1847 client_info = m_info_manager->socket_get_client_info(client_id);
1849 /* If it's a new client, then request to open the connection first. */
1850 if (client_info.type == UNKNOWN_CLIENT) {
1851 socket_open_connection(server, client);
1855 /* If can not read the transaction,
1856 * or the transaction is not started with SCIM_TRANS_CMD_REQUEST,
1857 * or the key is mismatch,
1859 if (!m_recv_trans.read_from_socket(client, m_socket_timeout) ||
1860 !m_recv_trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REQUEST ||
1861 !m_recv_trans.get_data(key) || key != (uint32) client_info.key) {
1862 LOGW ("cmd:%d key:%d client info key: %d", cmd, key, client_info.key);
1866 if (client_info.type == FRONTEND_ACT_CLIENT) {
1867 if (m_recv_trans.get_data(context)) {
1868 SCIM_DEBUG_MAIN(1) << "PanelAgent::FrontEnd Client, context = " << context << "\n";
1869 socket_transaction_start();
1871 while (m_recv_trans.get_command(cmd)) {
1872 LOGD ("PanelAgent::cmd = %d", cmd);
1874 if (cmd == ISM_TRANS_CMD_REGISTER_PANEL_CLIENT) {
1877 if (m_recv_trans.get_data(id)) {
1878 m_info_manager->register_panel_client(client_id, id);
1880 LOGW ("wrong format of transaction");
1885 else if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_INPUT_CONTEXT) {
1886 if (m_recv_trans.get_data(uuid)) {
1887 m_info_manager->register_input_context(client_id, context, uuid);
1889 LOGW ("wrong format of transaction");
1894 else if (cmd == SCIM_TRANS_CMD_PANEL_REMOVE_INPUT_CONTEXT) {
1895 m_info_manager->remove_input_context(client_id, context);
1898 else if (cmd == SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT) {
1899 m_info_manager->socket_reset_input_context(client_id, context);
1902 else if (cmd == SCIM_TRANS_CMD_FOCUS_IN) {
1903 SCIM_DEBUG_MAIN(4) << " SCIM_TRANS_CMD_FOCUS_IN (" << "client:" << client_id << " context:" << context << ")\n";
1905 if (m_recv_trans.get_data(uuid)) {
1906 m_info_manager->focus_in(client_id, context, uuid);
1908 LOGW ("wrong format of transaction");
1913 else if (cmd == ISM_TRANS_CMD_TURN_ON_LOG) {
1916 if (m_recv_trans.get_data(isOn)) {
1917 m_info_manager->socket_turn_on_log(isOn);
1919 LOGW ("wrong format of transaction");
1924 else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
1925 m_info_manager->show_isf_panel(client_id);
1927 } else if (cmd == ISM_TRANS_CMD_HIDE_ISF_CONTROL) {
1928 m_info_manager->hide_isf_panel(client_id);
1930 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_PANEL) {
1931 uint32 target_client;
1932 uint32 target_context;
1937 if (m_recv_trans.get_data(target_client) && m_recv_trans.get_data(target_context) && m_recv_trans.get_data(&data, len)) {
1940 LOGW ("wrong format of transaction");
1944 Socket client_socket(client_id);
1947 trans.put_command(SCIM_TRANS_CMD_REPLY);
1948 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
1949 trans.put_data(ret);
1950 trans.write_to_socket(client_socket);
1953 m_info_manager->show_ise_panel(client_id, target_client, target_context, data, len);
1959 } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
1960 uint32 target_client;
1961 uint32 target_context;
1963 if (m_recv_trans.get_data(target_client) && m_recv_trans.get_data(target_context)) {
1964 m_info_manager->hide_ise_panel(client_id, target_client, target_context);
1966 LOGW ("wrong format of transaction");
1970 } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY) {
1971 struct rectinfo info;
1972 m_info_manager->get_input_panel_geometry(client_id, info);
1974 Socket client_socket(client_id);
1977 trans.put_command(SCIM_TRANS_CMD_REPLY);
1978 trans.put_command(SCIM_TRANS_CMD_OK);
1979 trans.put_data(info.pos_x);
1980 trans.put_data(info.pos_y);
1981 trans.put_data(info.width);
1982 trans.put_data(info.height);
1983 trans.write_to_socket(client_socket);
1985 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
1986 struct rectinfo info;
1987 m_info_manager->get_candidate_window_geometry(client_id, info);
1989 Socket client_socket(client_id);
1992 trans.put_command(SCIM_TRANS_CMD_REPLY);
1993 trans.put_command(SCIM_TRANS_CMD_OK);
1994 trans.put_data(info.pos_x);
1995 trans.put_data(info.pos_y);
1996 trans.put_data(info.width);
1997 trans.put_data(info.height);
1998 trans.write_to_socket(client_socket);
2000 } else if (cmd == ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE) {
2003 m_info_manager->get_ise_language_locale(client_id, &data, len);
2006 trans.put_command(SCIM_TRANS_CMD_REPLY);
2008 if (data != NULL && len > 0) {
2009 trans.put_command(SCIM_TRANS_CMD_OK);
2010 trans.put_data(data, len);
2012 trans.put_command(SCIM_TRANS_CMD_FAIL);
2015 Socket client_socket(client_id);
2016 trans.write_to_socket(client_socket);
2022 } else if (cmd == ISM_TRANS_CMD_SET_ISE_LANGUAGE) {
2025 if (m_recv_trans.get_data(language)) {
2026 m_info_manager->set_ise_language(client_id, language);
2028 LOGW ("wrong format of transaction");
2032 } else if (cmd == ISM_TRANS_CMD_SET_ISE_IMDATA) {
2033 char* imdata = NULL;
2036 if (m_recv_trans.get_data(&imdata, len)) {
2037 m_info_manager->set_ise_imdata(client_id, imdata, len);
2039 LOGW ("wrong format of transaction");
2046 } else if (cmd == ISM_TRANS_CMD_GET_ISE_IMDATA) {
2047 char* imdata = NULL;
2049 m_info_manager->get_ise_imdata(client_id, &imdata, len);
2051 Socket client_socket(client_id);
2054 trans.put_command(SCIM_TRANS_CMD_REPLY);
2057 trans.put_command(SCIM_TRANS_CMD_OK);
2058 trans.put_data(imdata, len);
2060 trans.put_command(SCIM_TRANS_CMD_FAIL);
2063 trans.write_to_socket(client_socket);
2069 } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_TYPE) {
2072 if (m_recv_trans.get_data(type)) {
2073 m_info_manager->set_ise_return_key_type(client_id, type);
2075 LOGW ("wrong format of transaction");
2079 } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_TYPE) {
2081 bool ret = m_info_manager->get_ise_return_key_type(client_id, type);
2083 Socket client_socket(client_id);
2086 trans.put_command(SCIM_TRANS_CMD_REPLY);
2089 trans.put_command(SCIM_TRANS_CMD_OK);
2090 trans.put_data(type);
2092 trans.put_command(SCIM_TRANS_CMD_FAIL);
2095 trans.write_to_socket(client_socket);
2097 } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE) {
2100 if (m_recv_trans.get_data(disabled)) {
2101 m_info_manager->set_ise_return_key_disable(client_id, disabled);
2103 LOGW ("wrong format of transaction");
2107 } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE) {
2110 ret = m_info_manager->get_ise_return_key_disable(client_id, disabled);
2112 Socket client_socket(client_id);
2115 trans.put_command(SCIM_TRANS_CMD_REPLY);
2118 trans.put_command(SCIM_TRANS_CMD_OK);
2119 trans.put_data(disabled);
2121 trans.put_command(SCIM_TRANS_CMD_FAIL);
2124 trans.write_to_socket(client_socket);
2126 } else if (cmd == ISM_TRANS_CMD_GET_LAYOUT) {
2128 bool ret = m_info_manager->get_ise_layout(client_id, layout);
2130 Socket client_socket(client_id);
2133 trans.put_command(SCIM_TRANS_CMD_REPLY);
2136 trans.put_command(SCIM_TRANS_CMD_OK);
2137 trans.put_data(layout);
2139 trans.put_command(SCIM_TRANS_CMD_FAIL);
2142 trans.write_to_socket(client_socket);
2144 } else if (cmd == ISM_TRANS_CMD_SET_LAYOUT) {
2147 if (m_recv_trans.get_data(layout)) {
2148 m_info_manager->set_ise_layout(client_id, layout);
2150 LOGW ("wrong format of transaction");
2154 } else if (cmd == ISM_TRANS_CMD_SET_CAPS_MODE) {
2157 if (m_recv_trans.get_data(mode)) {
2158 m_info_manager->set_ise_caps_mode(client_id, mode);
2160 LOGW ("wrong format of transaction");
2164 } else if (cmd == ISM_TRANS_CMD_SEND_WILL_SHOW_ACK) {
2165 m_info_manager->will_show_ack(client_id);
2167 } else if (cmd == ISM_TRANS_CMD_SEND_WILL_HIDE_ACK) {
2168 m_info_manager->will_hide_ack(client_id);
2170 } else if (cmd == ISM_TRANS_CMD_SET_HARDWARE_KEYBOARD_MODE) {
2173 if (m_recv_trans.get_data(mode)) {
2174 m_info_manager->set_keyboard_mode(client_id, mode);
2176 LOGW ("wrong format of transaction");
2180 } else if (cmd == ISM_TRANS_CMD_SEND_CANDIDATE_WILL_HIDE_ACK) {
2181 m_info_manager->candidate_will_hide_ack(client_id);
2183 } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT) {
2189 if (m_recv_trans.get_data(key)) {
2191 m_info_manager->process_key_event(key, result, 0);
2193 LOGW ("wrong format of transaction");
2197 Socket client_socket(client_id);
2200 trans.put_command(SCIM_TRANS_CMD_REPLY);
2203 trans.put_command(SCIM_TRANS_CMD_OK);
2204 trans.put_data(result);
2206 trans.put_command(SCIM_TRANS_CMD_FAIL);
2209 trans.write_to_socket(client_socket);
2211 } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_HELPER_OPTION) {
2213 m_info_manager->get_active_helper_option(client_id, option);
2215 Socket client_socket(client_id);
2218 trans.put_command(SCIM_TRANS_CMD_REPLY);
2219 trans.put_command(SCIM_TRANS_CMD_OK);
2220 trans.put_data(option);
2221 SCIM_DEBUG_MAIN(4) << __func__ << " option " << option << "\n";
2222 trans.write_to_socket(client_socket);
2224 } else if (cmd == ISM_TRANS_CMD_GET_ISE_STATE) {
2226 m_info_manager->get_ise_state(client_id, state);
2228 Socket client_socket(client_id);
2231 trans.put_command(SCIM_TRANS_CMD_REPLY);
2232 trans.put_command(SCIM_TRANS_CMD_OK);
2233 trans.put_data(state);
2234 trans.write_to_socket(client_socket);
2236 } else if (cmd == ISM_TRANS_CMD_SET_INPUT_MODE) {
2239 if (m_recv_trans.get_data(input_mode)) {
2240 m_info_manager->set_ise_input_mode(client_id, input_mode);
2242 LOGW ("wrong format of transaction");
2246 } else if (cmd == ISM_TRANS_CMD_SET_INPUT_HINT) {
2249 if (m_recv_trans.get_data(input_hint)) {
2250 m_info_manager->set_ise_input_hint(client_id, input_hint);
2252 LOGW ("wrong format of transaction");
2256 } else if (cmd == ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION) {
2257 uint32 bidi_direction;
2259 if (m_recv_trans.get_data(bidi_direction)) {
2260 m_info_manager->update_ise_bidi_direction(client_id, bidi_direction);
2262 LOGW ("wrong format of transaction");
2266 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
2267 uint32 caller_pid = 0;
2268 if (!m_recv_trans.get_data(caller_pid)) {
2269 LOGW ("Failed to get pid");
2272 LOGI ("caller PID : %u", caller_pid);
2273 m_info_manager->show_ise_option_window(client_id, caller_pid);
2275 } else if (cmd == ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW) {
2276 m_info_manager->resume_ise_option_window(client_id);
2283 else if (cmd == SCIM_TRANS_CMD_START_HELPER) {
2286 if (m_recv_trans.get_data(uuid) && uuid.length()) {
2287 m_info_manager->socket_start_helper(client_id, context, uuid);
2289 LOGW ("wrong format of transaction");
2293 } else if (cmd == SCIM_TRANS_CMD_SEND_HELPER_EVENT) {
2296 if (m_recv_trans.get_data(uuid) && m_recv_trans.get_data(m_nest_trans) &&
2297 uuid.length() && m_nest_trans.valid()) {
2298 m_info_manager->socket_send_helper_event(client_id, context, uuid, m_nest_trans);
2300 LOGW ("wrong format of transaction");
2304 } else if (cmd == SCIM_TRANS_CMD_STOP_HELPER) {
2307 if (m_recv_trans.get_data(uuid) && uuid.length()) {
2308 m_info_manager->socket_stop_helper(client_id, context, uuid);
2310 LOGW ("wrong format of transaction");
2319 /* Client must focus in before do any other things. */
2320 else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_ON)
2321 m_info_manager->socket_turn_on();
2322 else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_OFF)
2323 m_info_manager->socket_turn_off();
2324 else if (cmd == SCIM_TRANS_CMD_UPDATE_SCREEN) {
2327 if (m_recv_trans.get_data(num))
2328 m_info_manager->socket_update_screen(client_id, num);
2330 LOGW ("wrong format of transaction");
2331 } else if (cmd == SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION) {
2334 if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) && m_recv_trans.get_data(top_y)) {
2335 m_info_manager->socket_update_spot_location(x, y, top_y);
2337 LOGW ("wrong format of transaction");
2339 } else if (cmd == ISM_TRANS_CMD_UPDATE_CURSOR_POSITION) {
2342 if (m_recv_trans.get_data(cursor_pos)) {
2343 m_info_manager->socket_update_cursor_position(cursor_pos);
2345 LOGW ("wrong format of transaction");
2347 } else if (cmd == ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT) {
2351 if (m_recv_trans.get_data(text) && m_recv_trans.get_data(cursor)) {
2352 m_info_manager->socket_update_surrounding_text(text, cursor);
2354 LOGW ("wrong format of transaction");
2356 } else if (cmd == ISM_TRANS_CMD_UPDATE_SELECTION) {
2359 if (m_recv_trans.get_data(text)) {
2360 m_info_manager->socket_update_selection(text);
2362 LOGW ("wrong format of transaction");
2364 } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE)
2365 m_info_manager->expand_candidate();
2366 else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE)
2367 m_info_manager->contract_candidate();
2368 else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2369 uint32 portrait_line, mode;
2371 if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2372 m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2374 LOGW ("wrong format of transaction");
2375 } else if (cmd == SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO) {
2376 PanelFactoryInfo info;
2378 if (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2379 m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2380 m_info_manager->socket_update_factory_info(info);
2382 LOGW ("wrong format of transaction");
2384 } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING)
2385 m_info_manager->socket_show_preedit_string();
2386 else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING)
2387 m_info_manager->socket_show_aux_string();
2388 else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE)
2389 m_info_manager->socket_show_lookup_table();
2390 else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE)
2391 m_info_manager->socket_show_associate_table();
2392 else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING)
2393 m_info_manager->socket_hide_preedit_string();
2394 else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING)
2395 m_info_manager->socket_hide_aux_string();
2396 else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE)
2397 m_info_manager->socket_hide_lookup_table();
2398 else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE)
2399 m_info_manager->socket_hide_associate_table();
2400 else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2402 AttributeList attrs;
2405 if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs) && m_recv_trans.get_data(caret))
2406 m_info_manager->socket_update_preedit_string(str, attrs, caret);
2408 LOGW ("wrong format of transaction");
2409 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2412 if (m_recv_trans.get_data(caret))
2413 m_info_manager->socket_update_preedit_caret(caret);
2415 LOGW ("wrong format of transaction");
2416 } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2418 AttributeList attrs;
2420 if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2421 m_info_manager->socket_update_aux_string(str, attrs);
2423 LOGW ("wrong format of transaction");
2424 } else if (cmd == ISM_TRANS_CMD_RECAPTURE_STRING) {
2431 AttributeList attrs;
2433 if (m_recv_trans.get_data(target_ic) &&
2434 m_recv_trans.get_data(target_uuid) &&
2435 m_recv_trans.get_data(offset) &&
2436 m_recv_trans.get_data(len) &&
2437 m_recv_trans.get_data(preedit) &&
2438 m_recv_trans.get_data(commit) &&
2439 m_recv_trans.get_data(attrs)) {
2440 m_info_manager->socket_helper_recapture_string(client_id, target_ic, target_uuid, offset, len, preedit, commit, attrs);
2442 LOGW ("wrong format of transaction");
2444 } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2445 CommonLookupTable _isf_candidate_table;
2447 if (m_recv_trans.get_data(_isf_candidate_table))
2448 m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2450 LOGW ("wrong format of transaction");
2452 } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2453 CommonLookupTable table;
2455 if (m_recv_trans.get_data(table))
2456 m_info_manager->socket_update_associate_table(table);
2458 LOGW ("wrong format of transaction");
2459 } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2460 PropertyList properties;
2462 if (m_recv_trans.get_data(properties))
2463 m_info_manager->socket_register_properties(properties);
2465 LOGW ("wrong format of transaction");
2466 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2469 if (m_recv_trans.get_data(property))
2470 m_info_manager->socket_update_property(property);
2472 LOGW ("wrong format of transaction");
2473 } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_HELP) {
2476 if (m_recv_trans.get_data(help))
2477 m_info_manager->socket_show_help(help);
2479 LOGW ("wrong format of transaction");
2480 } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU) {
2481 PanelFactoryInfo info;
2482 std::vector <PanelFactoryInfo> vec;
2484 while (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2485 m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2486 info.lang = scim_get_normalized_language(info.lang);
2487 vec.push_back(info);
2490 m_info_manager->socket_show_factory_menu(vec);
2491 } else if (cmd == SCIM_TRANS_CMD_FOCUS_OUT) {
2492 m_info_manager->focus_out(client_id, context);
2494 LOGW ("unknown cmd: %d", cmd);
2498 socket_transaction_end();
2500 } else if (client_info.type == FRONTEND_CLIENT) {
2501 if (m_recv_trans.get_data(context)) {
2502 SCIM_DEBUG_MAIN(1) << "client_info.type == FRONTEND_CLIENT\n";
2503 socket_transaction_start();
2505 while (m_recv_trans.get_command(cmd)) {
2506 LOGD ("PanelAgent::cmd = %d", cmd);
2508 if (cmd == ISM_TRANS_CMD_GET_PANEL_CLIENT_ID) {
2509 Socket client_socket(client_id);
2513 trans.put_command(SCIM_TRANS_CMD_REPLY);
2514 trans.put_command(SCIM_TRANS_CMD_OK);
2515 trans.put_data(client_id);
2516 trans.write_to_socket(client_socket);
2519 LOGW ("unknown cmd: %d", cmd);
2523 socket_transaction_end();
2525 } else if (client_info.type == HELPER_CLIENT) {
2526 socket_transaction_start();
2528 while (m_recv_trans.get_command(cmd)) {
2529 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_HELPER) {
2532 if (m_recv_trans.get_data(info.uuid) &&
2533 m_recv_trans.get_data(info.name) &&
2534 m_recv_trans.get_data(info.icon) &&
2535 m_recv_trans.get_data(info.description) &&
2536 m_recv_trans.get_data(info.option) &&
2537 info.uuid.length()) {
2538 m_info_manager->socket_helper_register_helper(client_id, info);
2541 LOGW ("unknown cmd: %d", cmd);
2545 socket_transaction_end();
2546 } else if (client_info.type == HELPER_ACT_CLIENT) {
2547 socket_transaction_start();
2549 while (m_recv_trans.get_command(cmd)) {
2550 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER) {
2553 if (m_recv_trans.get_data(info.uuid) &&
2554 m_recv_trans.get_data(info.name) &&
2555 m_recv_trans.get_data(info.icon) &&
2556 m_recv_trans.get_data(info.description) &&
2557 m_recv_trans.get_data(info.option) &&
2558 info.uuid.length()) {
2559 m_info_manager->socket_helper_register_helper_passive(client_id, info);
2561 LOGW ("wrong format of transaction");
2564 /* Check whether application already requested the focus_in and showing input_panel
2565 * If so, Input FW request focus_in and show input_panel again to helper IME.
2566 * Because Helper IME couldn't receive these events during the launch.
2568 m_info_manager->reshow_input_panel ();
2569 } else if (cmd == SCIM_TRANS_CMD_COMMIT_STRING) {
2574 if (m_recv_trans.get_data(target_ic) &&
2575 m_recv_trans.get_data(target_uuid) &&
2576 m_recv_trans.get_data(wstr) &&
2578 m_info_manager->socket_helper_commit_string(client_id, target_ic, target_uuid, wstr);
2580 LOGW ("wrong format of transaction");
2582 } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING) {
2586 if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2587 m_info_manager->socket_helper_show_preedit_string(client_id, target_ic, target_uuid);
2589 LOGW ("wrong format of transaction");
2591 } else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING) {
2592 m_info_manager->socket_show_aux_string();
2593 } else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE) {
2594 m_info_manager->socket_show_lookup_table();
2595 } else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE) {
2596 m_info_manager->socket_show_associate_table();
2597 } else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING) {
2601 if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2602 m_info_manager->socket_helper_hide_preedit_string(client_id, target_ic, target_uuid);
2604 LOGW ("wrong format of transaction");
2606 } else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING) {
2607 m_info_manager->socket_hide_aux_string();
2608 } else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE) {
2609 m_info_manager->socket_hide_lookup_table();
2610 } else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE) {
2611 m_info_manager->socket_hide_associate_table();
2612 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2617 AttributeList attrs;
2620 if (m_recv_trans.get_data(target_ic) &&
2621 m_recv_trans.get_data(target_uuid) &&
2622 m_recv_trans.get_data(preedit) &&
2623 m_recv_trans.get_data(commit) &&
2624 m_recv_trans.get_data(attrs) &&
2625 m_recv_trans.get_data(caret)) {
2626 m_info_manager->socket_helper_update_preedit_string(client_id, target_ic, target_uuid, preedit, commit, attrs, caret);
2628 LOGW ("wrong format of transaction");
2630 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2633 if (m_recv_trans.get_data(caret)) {
2634 m_info_manager->socket_helper_update_preedit_caret(client_id, caret);
2636 LOGW ("wrong format of transaction");
2638 } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2640 AttributeList attrs;
2642 if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2643 m_info_manager->socket_update_aux_string(str, attrs);
2645 LOGW ("wrong format of transaction");
2646 } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2647 CommonLookupTable _isf_candidate_table;
2649 if (m_recv_trans.get_data(_isf_candidate_table)) {
2650 m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2652 LOGW ("wrong format of transaction");
2654 } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2655 CommonLookupTable _isf_candidate_table;
2657 if (m_recv_trans.get_data(_isf_candidate_table)) {
2658 m_info_manager->socket_update_associate_table(_isf_candidate_table);
2660 LOGW ("wrong format of transaction");
2662 } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT ||
2663 cmd == SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT) {
2668 if (m_recv_trans.get_data(target_ic) &&
2669 m_recv_trans.get_data(target_uuid) &&
2670 m_recv_trans.get_data(key) &&
2672 m_info_manager->socket_helper_send_key_event(client_id, target_ic, target_uuid, key);
2674 LOGW ("wrong format of transaction");
2676 } else if (cmd == SCIM_TRANS_CMD_FORWARD_KEY_EVENT) {
2681 if (m_recv_trans.get_data(target_ic) &&
2682 m_recv_trans.get_data(target_uuid) &&
2683 m_recv_trans.get_data(key) &&
2685 m_info_manager->socket_helper_forward_key_event(client_id, target_ic, target_uuid, key);
2687 LOGW ("wrong format of transaction");
2689 } else if (cmd == SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT) {
2693 if (m_recv_trans.get_data(target_ic) &&
2694 m_recv_trans.get_data(target_uuid) &&
2695 m_recv_trans.get_data(m_nest_trans) &&
2696 m_nest_trans.valid()) {
2697 m_info_manager->socket_helper_send_imengine_event(client_id, target_ic, target_uuid, m_nest_trans);
2699 LOGW ("wrong format of transaction");
2701 } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2702 PropertyList properties;
2704 if (m_recv_trans.get_data(properties))
2705 m_info_manager->socket_helper_register_properties(client_id, properties);
2707 LOGW ("wrong format of transaction");
2708 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2711 if (m_recv_trans.get_data(property))
2712 m_info_manager->socket_helper_update_property(client_id, property);
2714 LOGW ("wrong format of transaction");
2715 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT) {
2719 if (m_recv_trans.get_data(type) && m_recv_trans.get_data(value)) {
2720 m_info_manager->socket_helper_update_input_context(client_id, type, value);
2722 LOGW ("wrong format of transaction");
2724 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_LANGUAGE_LOCALE) {
2729 if (m_recv_trans.get_data(&data, len)) {
2731 locale = String(data, len);
2732 m_info_manager->socket_helper_update_language_locale(client_id, locale);
2734 LOGW("wrong format of transaction : %p %zu", data, len);
2737 LOGW("wrong format of transaction");
2742 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST) {
2745 if (m_recv_trans.get_data(uuid)) {
2746 m_info_manager->socket_get_keyboard_ise_list(uuid);
2748 LOGW ("wrong format of transaction");
2750 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2751 uint32 portrait_line, mode;
2753 if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2754 m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2756 LOGW ("wrong format of transaction");
2757 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_UI) {
2760 if (m_recv_trans.get_data(uuid)) {
2761 m_info_manager->socket_get_candidate_ui(uuid);
2763 LOGW ("wrong format of transaction");
2765 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_POSITION) {
2768 if (m_recv_trans.get_data(left) && m_recv_trans.get_data(top))
2769 m_info_manager->socket_set_candidate_position(left, top);
2771 LOGW ("wrong format of transaction");
2772 } else if (cmd == ISM_TRANS_CMD_HIDE_CANDIDATE) {
2773 m_info_manager->socket_hide_candidate();
2774 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
2777 if (m_recv_trans.get_data(uuid)) {
2778 m_info_manager->socket_get_candidate_geometry(uuid);
2780 LOGW ("wrong format of transaction");
2782 } else if (cmd == ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE) {
2783 m_info_manager->reset_keyboard_ise();
2784 } else if (cmd == ISM_TRANS_CMD_SET_KEYBOARD_ISE_BY_UUID) {
2787 if (m_recv_trans.get_data(uuid)) {
2788 m_info_manager->socket_set_keyboard_ise(uuid);
2790 LOGW ("wrong format of transaction");
2792 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE) {
2795 if (m_recv_trans.get_data(uuid)) {
2796 m_info_manager->socket_get_keyboard_ise(uuid);
2798 LOGW ("wrong format of transaction");
2800 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY) {
2801 uint32 x, y, width, height;
2803 if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) &&
2804 m_recv_trans.get_data(width) && m_recv_trans.get_data(height)) {
2805 m_info_manager->socket_helper_update_ise_geometry(client_id, x, y, width, height);
2807 LOGW ("wrong format of transaction");
2809 } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE) {
2810 m_info_manager->expand_candidate();
2811 } else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE) {
2812 m_info_manager->contract_candidate();
2813 } else if (cmd == ISM_TRANS_CMD_SELECT_CANDIDATE) {
2816 if (m_recv_trans.get_data(index))
2817 m_info_manager->socket_helper_select_candidate(index);
2819 LOGW ("wrong format of transaction");
2820 } else if (cmd == SCIM_TRANS_CMD_PING) {
2822 Socket client_socket(client_id);
2825 trans.put_command(SCIM_TRANS_CMD_REPLY);
2826 trans.put_command(SCIM_TRANS_CMD_OK);
2827 trans.write_to_socket(client_socket);
2828 } else if (cmd == SCIM_TRANS_CMD_GET_SURROUNDING_TEXT) {
2830 uint32 maxlen_before;
2831 uint32 maxlen_after;
2833 if (m_recv_trans.get_data(uuid) &&
2834 m_recv_trans.get_data(maxlen_before) &&
2835 m_recv_trans.get_data(maxlen_after)) {
2836 m_info_manager->socket_helper_get_surrounding_text(client_id, uuid, maxlen_before, maxlen_after);
2838 LOGW ("wrong format of transaction");
2840 } else if (cmd == SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
2844 if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
2845 m_info_manager->socket_helper_delete_surrounding_text(client_id, offset, len);
2847 LOGW ("wrong format of transaction");
2849 } else if (cmd == SCIM_TRANS_CMD_GET_SELECTION) {
2852 if (m_recv_trans.get_data(uuid)) {
2853 m_info_manager->socket_helper_get_selection(client_id, uuid);
2855 LOGW ("wrong format of transaction");
2857 } else if (cmd == SCIM_TRANS_CMD_SET_SELECTION) {
2861 if (m_recv_trans.get_data(start) && m_recv_trans.get_data(end)) {
2862 m_info_manager->socket_helper_set_selection(client_id, start, end);
2864 LOGW ("wrong format of transaction");
2866 } else if (cmd == SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND) {
2869 if (m_recv_trans.get_data(command)) {
2870 m_info_manager->socket_helper_send_private_command(client_id, command);
2872 LOGW ("wrong format of transaction");
2874 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_EXIT) {
2875 m_info_manager->UPDATE_ISE_EXIT(client_id);
2876 } else if (cmd == SCIM_TRANS_CMD_COMMIT_CONTENT) {
2881 if (m_recv_trans.get_data(content) &&
2882 m_recv_trans.get_data(description) &&
2883 m_recv_trans.get_data(mime_types)) {
2884 m_info_manager->socket_helper_commit_content(client_id, content, description, mime_types);
2886 LOGW ("wrong format of transaction");
2888 } else if (cmd == ISM_TRANS_CMD_PROCESS_KEY_EVENT_DONE) {
2893 if (m_recv_trans.get_data(key) && m_recv_trans.get_data(ret) && m_recv_trans.get_data(serial)) {
2894 m_info_manager->process_key_event_done(key, ret, serial);
2896 LOGW ("wrong format of transaction");
2898 } else if (cmd == ISM_TRANS_CMD_REQUEST_ISE_HIDE) {
2899 m_info_manager->request_ise_hide();
2900 } else if (cmd == ISM_TRANS_CMD_RECAPTURE_STRING) {
2907 AttributeList attrs;
2909 if (m_recv_trans.get_data(target_ic) &&
2910 m_recv_trans.get_data(target_uuid) &&
2911 m_recv_trans.get_data(offset) &&
2912 m_recv_trans.get_data(len) &&
2913 m_recv_trans.get_data(preedit) &&
2914 m_recv_trans.get_data(commit) &&
2915 m_recv_trans.get_data(attrs)) {
2916 m_info_manager->socket_helper_recapture_string(client_id, target_ic, target_uuid, offset, len, preedit, commit, attrs);
2918 LOGW ("wrong format of transaction");
2920 } else if (cmd == ISM_TRANS_CMD_SET_FLOATING_MODE) {
2921 uint32 floating_mode;
2923 if (m_recv_trans.get_data(floating_mode)) {
2924 m_info_manager->set_floating_mode(floating_mode);
2926 LOGW ("wrong format of transaction");
2928 } else if (cmd == ISM_TRANS_CMD_SET_FLOATING_DRAG_ENABLED) {
2931 if (m_recv_trans.get_data(enabled)) {
2932 m_info_manager->set_floating_drag_enabled(enabled);
2934 LOGW ("wrong format of transaction");
2937 LOGW ("unknown cmd: %d", cmd);
2941 socket_transaction_end();
2942 } else if (client_info.type == IMCONTROL_ACT_CLIENT) {
2943 socket_transaction_start();
2945 while (m_recv_trans.get_command(cmd)) {
2946 LOGD ("PanelAgent::cmd = %d", cmd);
2948 if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE) {
2949 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2950 String default_uuid;
2951 m_info_manager->get_active_ise(client_id, default_uuid);
2953 Socket client_socket(client_id);
2956 trans.put_command(SCIM_TRANS_CMD_REPLY);
2957 trans.put_command(SCIM_TRANS_CMD_OK);
2958 trans.put_data(default_uuid);
2959 trans.write_to_socket(client_socket);
2962 LOGW ("Access denied to get active ise");
2963 send_fail_reply (client_id);
2965 } else if (cmd == ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID) {
2966 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2971 if (m_recv_trans.get_data(&buf, len)) {
2972 ret = m_info_manager->set_active_ise_by_uuid(client_id, buf, len);
2974 LOGW ("wrong format of transaction");
2978 Socket client_socket(client_id);
2981 trans.put_command(SCIM_TRANS_CMD_REPLY);
2982 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2983 trans.write_to_socket(client_socket);
2989 LOGW ("Access denied to set active ise");
2990 send_fail_reply (client_id);
2992 } else if (cmd == ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID) {
2993 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2998 //ret need be checked
2999 if (m_recv_trans.get_data(&buf, len)) {
3000 m_info_manager->set_initial_ise_by_uuid(client_id, buf, len);
3002 LOGW ("wrong format of transaction");
3006 Socket client_socket(client_id);
3009 trans.put_command(SCIM_TRANS_CMD_REPLY);
3010 trans.put_command(SCIM_TRANS_CMD_OK);
3011 trans.write_to_socket(client_socket);
3017 LOGW ("Access denied to set initial ise");
3018 send_fail_reply (client_id);
3020 } else if (cmd == ISM_TRANS_CMD_GET_ISE_LIST) {
3021 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3022 std::vector<String> strlist;
3023 m_info_manager->get_ise_list(client_id, strlist);
3025 Socket client_socket(client_id);
3031 trans.put_command(SCIM_TRANS_CMD_REPLY);
3032 trans.put_command(SCIM_TRANS_CMD_OK);
3034 num = strlist.size();
3035 trans.put_data(num);
3037 for (unsigned int i = 0; i < num; i++) {
3038 buf = const_cast<char*>(strlist[i].c_str());
3039 len = strlen(buf) + 1;
3040 trans.put_data(buf, len);
3043 trans.write_to_socket(client_socket);
3046 LOGW ("Access denied to get ise list");
3047 send_fail_reply (client_id);
3049 } else if (cmd == ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO) {
3050 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3051 HELPER_ISE_INFO info;
3052 m_info_manager->get_all_helper_ise_info(client_id, info);
3056 Socket client_socket(client_id);
3059 trans.put_command(SCIM_TRANS_CMD_REPLY);
3060 trans.put_command(SCIM_TRANS_CMD_OK);
3062 if (info.appid.size() > 0) {
3063 trans.put_data(info.appid);
3064 trans.put_data(info.label);
3065 trans.put_data(info.is_enabled);
3066 trans.put_data(info.is_preinstalled);
3067 trans.put_data(info.has_option);
3070 trans.write_to_socket(client_socket);
3074 LOGW ("Access denied to get all helper ise info");
3075 send_fail_reply (client_id);
3077 } else if (cmd == ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO) {
3078 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3083 if (m_recv_trans.get_data(appid) && appid.length() != 0 && m_recv_trans.get_data(is_enabled)) {
3084 m_info_manager->set_enable_helper_ise_info(client_id, appid, is_enabled);
3087 LOGW ("wrong format of transaction");
3091 Socket client_socket(client_id);
3094 trans.put_command(SCIM_TRANS_CMD_REPLY);
3095 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3096 trans.write_to_socket(client_socket);
3099 LOGW ("Access denied to set enable helper ise info");
3100 send_fail_reply (client_id);
3102 } else if (cmd == ISM_TRANS_CMD_GET_ISE_INFORMATION) {
3103 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3104 String strUuid, strName, strLanguage, strModuleName;
3108 if (m_recv_trans.get_data(strUuid)) {
3109 m_info_manager->get_ise_information(client_id, strUuid, strName, strLanguage, nType, nOption, strModuleName);
3111 LOGW ("wrong format of transaction");
3115 Socket client_socket(client_id);
3117 trans.put_command(SCIM_TRANS_CMD_REPLY);
3118 trans.put_command(SCIM_TRANS_CMD_OK);
3119 trans.put_data(strName);
3120 trans.put_data(strLanguage);
3121 trans.put_data(nType);
3122 trans.put_data(nOption);
3123 trans.put_data(strModuleName);
3124 trans.write_to_socket(client_socket);
3127 LOGW ("Access denied to get ise information");
3128 send_fail_reply (client_id);
3130 } else if (cmd == ISM_TRANS_CMD_RESET_ISE_OPTION) {
3131 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3133 Socket client_socket(client_id);
3136 trans.put_command(SCIM_TRANS_CMD_REPLY);
3137 trans.put_command(SCIM_TRANS_CMD_OK);
3138 trans.write_to_socket(client_socket);
3139 m_info_manager->show_helper_ise_selector(client_id);
3140 m_info_manager->reset_ise_option(client_id);
3143 LOGW ("Access denied to reset ise option");
3144 send_fail_reply (client_id);
3146 } else if (cmd == ISM_TRANS_CMD_RESET_DEFAULT_ISE) {
3147 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3148 m_info_manager->reset_default_ise(client_id);
3151 LOGW ("Access denied to reset default ise");
3152 send_fail_reply (client_id);
3154 } else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
3155 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3156 m_info_manager->show_isf_panel(client_id);
3159 LOGW ("Access denied to show isf control");
3160 send_fail_reply (client_id);
3162 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
3163 uint32 caller_pid = 0;
3164 if (!m_recv_trans.get_data(caller_pid)) {
3165 LOGW ("Failed to get pid");
3168 LOGI ("caller PID : %u", caller_pid);
3169 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3170 m_info_manager->show_ise_option_window(client_id, caller_pid);
3173 LOGW ("Access denied to show ise option window");
3174 send_fail_reply (client_id);
3176 } else if (cmd == ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW) {
3177 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3178 m_info_manager->resume_ise_option_window(client_id);
3181 LOGW ("Access denied to resume ise option window");
3182 send_fail_reply (client_id);
3184 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST) {
3185 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3187 Socket client_socket(client_id);
3190 trans.put_command(SCIM_TRANS_CMD_REPLY);
3191 trans.put_command(SCIM_TRANS_CMD_OK);
3192 trans.write_to_socket(client_socket);
3194 m_info_manager->show_helper_ise_list(client_id);
3197 LOGW ("Access denied to show helper ise list");
3198 send_fail_reply (client_id);
3200 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR) {
3201 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3203 Socket client_socket(client_id);
3206 trans.put_command(SCIM_TRANS_CMD_REPLY);
3207 trans.put_command(SCIM_TRANS_CMD_OK);
3208 trans.write_to_socket(client_socket);
3209 m_info_manager->show_helper_ise_selector(client_id);
3212 LOGW ("Access denied to show helper ise selector");
3213 send_fail_reply (client_id);
3215 } else if (cmd == ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED) {
3216 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3218 uint32 nEnabled = 0;
3220 m_info_manager->is_helper_ise_enabled(client_id, strAppid, nEnabled);
3222 Socket client_socket(client_id);
3224 trans.put_command(SCIM_TRANS_CMD_REPLY);
3225 trans.put_command(SCIM_TRANS_CMD_OK);
3226 trans.put_data(static_cast<uint32>(nEnabled));
3227 trans.write_to_socket(client_socket);
3230 LOGW ("Access denied to check helper ise enabled");
3231 send_fail_reply (client_id);
3233 } else if (cmd == ISM_TRANS_CMD_GET_ISE_SETTING_APPID) {
3234 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3235 String ime_setting_appid;
3236 m_info_manager->get_ise_setting_appid(client_id, ime_setting_appid);
3239 Socket client_socket(client_id);
3241 trans.put_command(SCIM_TRANS_CMD_REPLY);
3242 trans.put_command(SCIM_TRANS_CMD_OK);
3243 trans.put_data(ime_setting_appid);
3244 trans.write_to_socket(client_socket);
3247 LOGW ("Access denied to get ise setting appid");
3248 send_fail_reply (client_id);
3250 } else if (cmd == ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY) {
3254 Socket client_socket(client_id);
3257 trans.put_command(SCIM_TRANS_CMD_REPLY);
3259 if (m_recv_trans.get_data(angle)) {
3260 struct rectinfo info = {0, 0, 0, 0};
3261 m_info_manager->get_recent_ise_geometry(client_id, angle, info);
3263 trans.put_command(SCIM_TRANS_CMD_OK);
3264 trans.put_data(info.pos_x);
3265 trans.put_data(info.pos_y);
3266 trans.put_data(info.width);
3267 trans.put_data(info.height);
3269 trans.put_command(SCIM_TRANS_CMD_FAIL);
3272 trans.write_to_socket(client_socket);
3273 } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
3275 Socket client_socket(client_id);
3278 trans.put_command(SCIM_TRANS_CMD_REPLY);
3279 trans.put_command(SCIM_TRANS_CMD_OK);
3280 trans.write_to_socket(client_socket);
3281 m_info_manager->hide_helper_ise ();
3282 } else if (cmd == ISM_TRANS_CMD_PRELAUNCH_ISE) {
3284 Socket client_socket(client_id);
3287 trans.put_command(SCIM_TRANS_CMD_REPLY);
3288 trans.put_command(SCIM_TRANS_CMD_OK);
3289 trans.write_to_socket(client_socket);
3290 m_info_manager->prelaunch_helper_ise();
3292 LOGW ("unknown cmd: %d", cmd);
3296 socket_transaction_end();
3297 } else if (client_info.type == REMOTEINPUT_ACT_CLIENT) {
3298 socket_transaction_start();
3299 while (m_recv_trans.get_command(cmd)) {
3300 if (cmd == ISM_REMOTE_TRANS_CMD_SEND_INPUT_MESSAGE) {
3305 if (m_recv_trans.get_data(&buf, len)) {
3306 ret = m_info_manager->remoteinput_send_input_message(client_id, buf, len);
3308 LOGW ("wrong format of transaction");
3312 Socket client_socket(client_id);
3315 trans.put_command(SCIM_TRANS_CMD_REPLY);
3316 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3317 trans.write_to_socket(client_socket);
3321 } else if (cmd == ISM_REMOTE_TRANS_CMD_CHECK_PRIVILEGE) {
3324 if (m_info_manager->check_privilege_by_sockfd(client_id, REMOTEINPUT_PRIVILEGE))
3328 Socket client_socket(client_id);
3331 trans.put_command(SCIM_TRANS_CMD_REPLY);
3332 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3333 trans.write_to_socket(client_socket);
3334 } else if (cmd == ISM_REMOTE_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
3339 if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
3340 ret = m_info_manager->remoteinput_delete_surrounding_text(offset, len);
3342 LOGW ("wrong format of transaction");
3346 Socket client_socket(client_id);
3349 trans.put_command(SCIM_TRANS_CMD_REPLY);
3350 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3351 trans.write_to_socket(client_socket);
3353 LOGW ("unknown cmd: %d", cmd);
3357 socket_transaction_end ();
3361 void socket_exception_callback(SocketServer* server,
3362 const Socket& client) {
3363 SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_exception_callback (" << client.get_id() << ")\n";
3364 LOGD ("client id:%d", client.get_id());
3365 socket_close_connection(server, client);
3368 bool socket_open_connection(SocketServer* server,
3369 const Socket& client) {
3370 SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_open_connection (" << client.get_id() << ")\n";
3371 LOGD ("client id:%d", client.get_id());
3373 String type = scim_socket_accept_connection(key,
3375 String("FrontEnd,FrontEnd_Active,Helper,Helper_Active,IMControl_Active,IMControl_Passive,RemoteInput_Active,RemoteInput_Passive,SocketConfig"),
3379 SCIM_DEBUG_MAIN (3) << "type = " << type << "\n";
3380 if (type.length()) {
3381 ClientType _type = ((type == "FrontEnd") ? FRONTEND_CLIENT :
3382 ((type == "FrontEnd_Active") ? FRONTEND_ACT_CLIENT :
3383 ((type == "Helper") ? HELPER_CLIENT :
3384 ((type == "Helper_Active") ? HELPER_ACT_CLIENT :
3385 ((type == "IMControl_Active") ? IMCONTROL_ACT_CLIENT :
3386 ((type == "IMControl_Passive") ? IMCONTROL_CLIENT :
3387 ((type == "RemoteInput_Active") ? REMOTEINPUT_ACT_CLIENT :
3388 ((type == "RemoteInput_Passive") ? REMOTEINPUT_CLIENT : CONFIG_CLIENT))))))));
3390 m_info_manager->add_client(client.get_id(), key, _type);
3394 LOGW ("open_connection failed");
3396 SCIM_DEBUG_MAIN(4) << "Close client connection " << client.get_id() << "\n";
3397 server->close_connection(client);
3401 void socket_close_connection(SocketServer* server,
3402 const Socket& client) {
3403 SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_close_connection (" << client.get_id() << ")\n";
3404 LOGD ("client id:%d", client.get_id());
3406 std::vector<Ecore_Fd_Handler *>::iterator IterPos;
3408 for (IterPos = _read_handler_list.begin (); IterPos != _read_handler_list.end (); ++IterPos, ++i) {
3409 if (ecore_main_fd_handler_fd_get (_read_handler_list[i]) == client.get_id()) {
3410 ::close (client.get_id ());
3411 ecore_main_fd_handler_del (_read_handler_list[i]);
3412 _read_handler_list.erase (IterPos);
3416 m_info_manager->del_client(client.get_id());
3419 void socket_transaction_start(void) {
3420 //m_signal_transaction_start ();
3423 void socket_transaction_end(void) {
3424 //m_signal_transaction_end ();
3431 //m_signal_unlock ();
3435 } /* namespace scim */
3437 /***************************************************/
3438 /*** Beginning of panel agent interface for ISF ***/
3439 /***************************************************/
3440 static scim::PanelAgentPointer instance;
3444 EXAPI void scim_module_init(void)
3448 EXAPI void scim_module_exit(void)
3453 EXAPI void scim_panel_agent_module_init(const scim::ConfigPointer& config)
3458 EXAPI scim::PanelAgentPointer scim_panel_agent_module_get_instance()
3460 scim::PanelAgentBase* _instance = NULL;
3461 if (instance.null()) {
3463 _instance = new scim::EcoreSocketPanelAgent();
3469 instance = _instance;
3476 vi:ts=4:nowrap:ai:expandtab