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 MIN_REPEAT_TIME 2.0
57 #define IMEMANAGER_PRIVILEGE "http://tizen.org/privilege/imemanager"
59 #define SCIM_CONFIG_PANEL_SOCKET_CONFIG_READONLY "/Panel/Socket/ConfigReadOnly"
64 struct HelperClientStub {
68 HelperClientStub(int i = 0, int r = 0) : id(i), ref(r) { }
71 struct IMControlStub {
72 std::vector<ISE_INFO> info;
73 std::vector<int> count;
76 void aul_wakeup_ime_application(int sockfd)
79 socklen_t len = sizeof(struct ucred);
80 if (getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == 0) {
81 int ret = aul_update_freezer_status((long)ucred.pid, "wakeup");
82 LOGD("aul_update_freezer_status : %d %d\n", ucred.pid, ret);
84 LOGD("getsockopt failed : %d\n", errno);
87 #define DEFAULT_CONTEXT_VALUE 0xfff
89 #define scim_module_init ecoresocket_LTX_scim_module_init
90 #define scim_module_exit ecoresocket_LTX_scim_module_exit
91 #define scim_panel_agent_module_init ecoresocket_LTX_scim_panel_agent_module_init
92 #define scim_panel_agent_module_get_instance ecoresocket_LTX_scim_panel_agent_module_get_instance
95 //==================================== PanelAgent ===========================
96 class EcoreSocketPanelAgent: public PanelAgentBase
100 int m_socket_timeout;
101 String m_socket_address;
102 SocketServer m_socket_server;
104 Transaction m_send_trans;
105 Transaction m_recv_trans;
106 Transaction m_nest_trans;
108 bool m_should_shared_ise;
111 std::vector<Ecore_Fd_Handler*> _read_handler_list;
113 InfoManager* m_info_manager;
116 EcoreSocketPanelAgent()
117 : PanelAgentBase ("ecore_socket"),
118 m_should_exit(false),
119 m_socket_timeout(scim_get_default_socket_timeout()),
120 m_should_shared_ise(false),
121 m_ise_exiting(false) {
122 m_socket_server.signal_connect_accept(slot(this, &EcoreSocketPanelAgent::socket_accept_callback));
123 m_socket_server.signal_connect_receive(slot(this, &EcoreSocketPanelAgent::socket_receive_callback));
124 m_socket_server.signal_connect_exception(slot(this, &EcoreSocketPanelAgent::socket_exception_callback));
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) {
137 m_info_manager = info_manager;
138 m_socket_address = scim_get_default_panel_socket_address(display);
140 m_socket_server.shutdown();
142 if (m_socket_server.create(SocketAddress(m_socket_address))) {
143 Ecore_Fd_Handler* panel_agent_read_handler = NULL;
144 panel_agent_read_handler = ecore_main_fd_handler_add(get_server_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
145 _read_handler_list.push_back(panel_agent_read_handler);
148 LOGE("create server failed\n");
152 bool valid(void) const {
153 return m_socket_server.valid();
157 SCIM_DEBUG_MAIN(1) << "PanelAgent::stop ()\n";
160 m_should_exit = true;
163 if (client.connect(SocketAddress(m_socket_address))) {
168 void update_panel_event(int client, uint32 context_id, int cmd, uint32 nType, uint32 nValue) {
169 LOGD ("client id:%d\n", client);
170 Socket client_socket(client);
171 m_send_trans.clear();
172 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
173 m_send_trans.put_data(context_id);
174 m_send_trans.put_command(cmd);
175 m_send_trans.put_data(nType);
176 m_send_trans.put_data(nValue);
177 m_send_trans.write_to_socket(client_socket);
180 void move_preedit_caret(int client, uint32 context_id, uint32 position) {
181 SCIM_DEBUG_MAIN(1) << "PanelAgent::move_preedit_caret (" << position << ")\n";
182 LOGD ("client id:%d\n", client);
183 Socket client_socket(client);
184 m_send_trans.clear();
185 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
186 m_send_trans.put_data((uint32) context_id);
187 m_send_trans.put_command(SCIM_TRANS_CMD_MOVE_PREEDIT_CARET);
188 m_send_trans.put_data((uint32) position);
189 m_send_trans.write_to_socket(client_socket);
194 void request_help(int client_id, uint32 context_id) {
195 SCIM_DEBUG_MAIN(1) << "PanelAgent::request_help ()\n";
196 LOGD ("client id:%d", client_id);
198 Socket client_socket(client_id);
199 m_send_trans.clear();
200 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
201 m_send_trans.put_data((uint32) context_id);
202 m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_REQUEST_HELP);
203 m_send_trans.write_to_socket(client_socket);
207 void request_factory_menu(int client_id, uint32 context_id) {
208 LOGD ("client id:%d", client_id);
209 Socket client_socket(client_id);
210 m_send_trans.clear();
211 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
212 m_send_trans.put_data((uint32) context_id);
213 m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_REQUEST_FACTORY_MENU);
214 m_send_trans.write_to_socket(client_socket);
218 void reset_keyboard_ise(int client, uint32 context_id) {
219 LOGD ("client id:%d\n", client);
220 Socket client_socket(client);
221 m_send_trans.clear();
222 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
223 m_send_trans.put_data((uint32) context_id);
224 m_send_trans.put_command(ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE);
225 m_send_trans.write_to_socket(client_socket);
228 void update_keyboard_ise_list(int client, uint32 context) {
229 LOGD ("client id:%d\n", client);
231 Socket client_socket(client);
232 m_send_trans.clear();
233 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
234 m_send_trans.put_data((uint32) context);
235 m_send_trans.put_command(ISM_TRANS_CMD_PANEL_UPDATE_KEYBOARD_ISE);
236 m_send_trans.write_to_socket(client_socket);
239 void change_factory(int client, uint32 context, const String& uuid) {
240 SCIM_DEBUG_MAIN(1) << "PanelAgent::change_factory (" << uuid << ")\n";
241 LOGD ("client id:%d\n", client);
243 Socket client_socket(client);
244 m_send_trans.clear();
245 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
246 m_send_trans.put_data((uint32) context);
247 m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_CHANGE_FACTORY);
248 m_send_trans.put_data(uuid);
249 m_send_trans.write_to_socket(client_socket);
252 void helper_candidate_show(int client, uint32 context, const String& uuid) {
253 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
254 LOGD ("client id:%d\n", client);
257 Socket client_socket(client);
259 m_send_trans.clear();
260 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
261 m_send_trans.put_data(context);
262 m_send_trans.put_data(uuid);
263 m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_SHOW);
264 m_send_trans.write_to_socket(client_socket);
267 void helper_candidate_hide(int client, uint32 context, const String& uuid) {
268 LOGD ("client id:%d\n", client);
270 Socket client_socket(client);
272 m_send_trans.clear();
273 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
274 m_send_trans.put_data(context);
275 m_send_trans.put_data(uuid);
276 m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_HIDE);
277 m_send_trans.write_to_socket(client_socket);
280 void candidate_more_window_show(int client, uint32 context) {
281 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
282 LOGD ("client id:%d\n", client);
285 Socket client_socket(client);
287 m_send_trans.clear();
288 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
289 m_send_trans.put_data(context);
290 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
291 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
292 m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_SHOW);
293 m_send_trans.write_to_socket(client_socket);
296 void candidate_more_window_hide(int client, uint32 context) {
297 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
298 LOGD ("client id:%d\n", client);
300 Socket client_socket(client);
302 m_send_trans.clear();
303 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
304 m_send_trans.put_data(context);
305 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
306 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
307 m_send_trans.put_command(ISM_TRANS_CMD_CANDIDATE_MORE_WINDOW_HIDE);
308 m_send_trans.write_to_socket(client_socket);
311 void update_helper_lookup_table(int client, uint32 context, const String& uuid, const LookupTable& table) {
312 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
313 LOGD ("client id:%d\n", client);
315 Socket client_socket(client);
317 m_send_trans.clear();
318 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
319 m_send_trans.put_data(context);
320 m_send_trans.put_data(uuid);
321 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_LOOKUP_TABLE);
322 m_send_trans.put_data(table);
323 m_send_trans.write_to_socket(client_socket);
326 void select_aux(int client, uint32 contextid, uint32 item) {
327 SCIM_DEBUG_MAIN(1) << "PanelAgent::select_aux (" << item << ")\n";
328 LOGD ("client id:%d\n", client);
330 Socket client_socket(client);
331 m_send_trans.clear();
332 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
333 m_send_trans.put_data((uint32) contextid);
335 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
336 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
338 m_send_trans.put_command(ISM_TRANS_CMD_SELECT_AUX);
339 m_send_trans.put_data((uint32)item);
340 m_send_trans.write_to_socket(client_socket);
343 void select_candidate(int client, uint32 context, uint32 item) {
344 LOGD ("client id:%d\n", client);
346 Socket client_socket(client);
347 m_send_trans.clear();
348 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
349 m_send_trans.put_data((uint32) context);
351 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
352 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
354 m_send_trans.put_command(SCIM_TRANS_CMD_SELECT_CANDIDATE);
355 m_send_trans.put_data((uint32)item);
356 m_send_trans.write_to_socket(client_socket);
359 void lookup_table_page_up(int client, uint32 context) {
360 SCIM_DEBUG_MAIN(1) << "PanelAgent::lookup_table_page_up ()\n";
361 LOGD ("client id:%d\n", client);
363 Socket client_socket(client);
364 m_send_trans.clear();
365 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
366 m_send_trans.put_data((uint32) context);
368 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
369 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
371 m_send_trans.put_command(SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_UP);
372 m_send_trans.write_to_socket(client_socket);
375 void lookup_table_page_down(int client, uint32 context) {
376 LOGD ("client id:%d\n", client);
378 Socket client_socket(client);
379 m_send_trans.clear();
380 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
381 m_send_trans.put_data((uint32) context);
383 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
384 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
386 m_send_trans.put_command(SCIM_TRANS_CMD_LOOKUP_TABLE_PAGE_DOWN);
387 m_send_trans.write_to_socket(client_socket);
390 void update_lookup_table_page_size(int client, uint32 context, uint32 size) {
391 LOGD ("client id:%d\n", client);
393 Socket client_socket(client);
394 m_send_trans.clear();
395 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
396 m_send_trans.put_data((uint32) context);
398 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
399 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
401 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE_PAGE_SIZE);
402 m_send_trans.put_data(size);
403 m_send_trans.write_to_socket(client_socket);
406 void update_candidate_item_layout(int client, uint32 context, const std::vector<uint32>& row_items) {
407 LOGD ("client id:%d\n", client);
409 Socket client_socket(client);
410 m_send_trans.clear();
411 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
412 m_send_trans.put_data((uint32) context);
414 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
415 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
417 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_ITEM_LAYOUT);
418 m_send_trans.put_data(row_items);
419 m_send_trans.write_to_socket(client_socket);
422 void select_associate(int client, uint32 context, uint32 item) {
423 LOGD ("client id:%d\n", client);
425 Socket client_socket(client);
426 m_send_trans.clear();
427 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
428 m_send_trans.put_data((uint32) context);
430 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
431 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
433 m_send_trans.put_command(ISM_TRANS_CMD_SELECT_ASSOCIATE);
434 m_send_trans.put_data((uint32)item);
435 m_send_trans.write_to_socket(client_socket);
438 void associate_table_page_up(int client, uint32 context) {
439 LOGD ("client id:%d\n", client);
441 Socket client_socket(client);
442 m_send_trans.clear();
443 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
444 m_send_trans.put_data((uint32) context);
446 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
447 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
449 m_send_trans.put_command(ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_UP);
450 m_send_trans.write_to_socket(client_socket);
453 void associate_table_page_down(int client, uint32 context) {
454 LOGD ("client id:%d\n", client);
456 Socket client_socket(client);
457 m_send_trans.clear();
458 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
459 m_send_trans.put_data((uint32) context);
461 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
462 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
464 m_send_trans.put_command(ISM_TRANS_CMD_ASSOCIATE_TABLE_PAGE_DOWN);
465 m_send_trans.write_to_socket(client_socket);
468 void update_associate_table_page_size(int client, uint32 context, uint32 size) {
469 LOGD ("client id:%d\n", client);
471 Socket client_socket(client);
472 m_send_trans.clear();
473 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
474 m_send_trans.put_data((uint32) context);
476 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
477 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
479 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE_PAGE_SIZE);
480 m_send_trans.put_data(size);
481 m_send_trans.write_to_socket(client_socket);
484 void update_displayed_candidate_number(int client, uint32 context, uint32 size) {
485 LOGD ("client id:%d\n", client);
487 Socket client_socket(client);
488 m_send_trans.clear();
489 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
490 m_send_trans.put_data((uint32) context);
492 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
493 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
495 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_DISPLAYED_CANDIDATE);
496 m_send_trans.put_data(size);
497 m_send_trans.write_to_socket(client_socket);
500 void send_longpress_event(int client, uint32 context, int index) {
501 LOGD ("client id:%d\n", client);
503 Socket client_socket(client);
504 m_send_trans.clear();
505 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
506 m_send_trans.put_data((uint32) context);
508 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
509 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
511 m_send_trans.put_command(ISM_TRANS_CMD_LONGPRESS_CANDIDATE);
512 m_send_trans.put_data(index);
513 m_send_trans.write_to_socket(client_socket);
516 void trigger_property(int client, uint32 context, const String& property) {
517 LOGD ("client id:%d\n", client);
519 Socket client_socket(client);
520 m_send_trans.clear();
521 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
522 m_send_trans.put_data((uint32) context);
524 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT)
525 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
527 m_send_trans.put_command(SCIM_TRANS_CMD_TRIGGER_PROPERTY);
528 m_send_trans.put_data(property);
529 m_send_trans.write_to_socket(client_socket);
532 void focus_out_helper(int client, uint32 context, const String& uuid) {
533 LOGD ("client id:%d\n", client);
535 Socket client_socket(client);
536 m_send_trans.clear();
537 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
538 m_send_trans.put_data(context);
539 m_send_trans.put_data(uuid);
540 m_send_trans.put_command(SCIM_TRANS_CMD_FOCUS_OUT);
541 m_send_trans.write_to_socket(client_socket);
544 void focus_in_helper(int client, uint32 context, const String& uuid) {
545 LOGD ("client id:%d\n", client);
547 Socket client_socket(client);
548 m_send_trans.clear();
549 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
550 m_send_trans.put_data(context);
551 m_send_trans.put_data(uuid);
552 m_send_trans.put_command(SCIM_TRANS_CMD_FOCUS_IN);
553 m_send_trans.write_to_socket(client_socket);
556 void show_helper(int client, uint32 context, const String& uuid, char* data, size_t& len) {
557 LOGD ("client id:%d\n", client);
559 Socket client_socket(client);
561 aul_wakeup_ime_application(client_socket.get_id());
563 m_send_trans.clear();
564 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
565 m_send_trans.put_data(context);
566 m_send_trans.put_data(uuid);
567 m_send_trans.put_command(ISM_TRANS_CMD_SHOW_ISE_PANEL);
568 m_send_trans.put_data(data, len);
569 m_send_trans.write_to_socket(client_socket);
572 void hide_helper(int client, uint32 context, const String& uuid) {
573 LOGD ("client id:%d\n", client);
575 Socket client_socket(client);
576 m_send_trans.clear();
577 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
578 m_send_trans.put_data(context);
579 m_send_trans.put_data(uuid);
580 m_send_trans.put_command(ISM_TRANS_CMD_HIDE_ISE_PANEL);
581 m_send_trans.write_to_socket(client_socket);
584 void set_helper_mode(int client, uint32 context, const String& uuid, uint32& mode) {
585 LOGD ("client id:%d\n", client);
587 Socket client_socket(client);
588 m_send_trans.clear();
589 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
590 m_send_trans.put_data(context);
591 m_send_trans.put_data(uuid);
592 m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_MODE);
593 m_send_trans.put_data(mode);
594 m_send_trans.write_to_socket(client_socket);
597 void set_helper_language(int client, uint32 context, const String& uuid, uint32& language) {
598 LOGD ("client id:%d\n", client);
600 Socket client_socket(client);
601 m_send_trans.clear();
602 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
603 m_send_trans.put_data(context);
604 m_send_trans.put_data(uuid);
605 m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_LANGUAGE);
606 m_send_trans.put_data(language);
607 m_send_trans.write_to_socket(client_socket);
610 void set_helper_imdata(int client, uint32 context, const String& uuid, const char* imdata, size_t& len) {
611 LOGD ("client id:%d\n", client);
613 Socket client_socket(client);
614 m_send_trans.clear();
615 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
616 m_send_trans.put_data(context);
617 m_send_trans.put_data(uuid);
618 m_send_trans.put_command(ISM_TRANS_CMD_SET_ISE_IMDATA);
619 m_send_trans.put_data(imdata, len);
620 m_send_trans.write_to_socket(client_socket);
623 void set_helper_return_key_type(int client, uint32 context, const String& uuid, uint32 type) {
624 LOGD ("client id:%d\n", client);
626 Socket client_socket(client);
627 m_send_trans.clear();
628 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
629 m_send_trans.put_data(context);
630 m_send_trans.put_data(uuid);
631 m_send_trans.put_command(ISM_TRANS_CMD_SET_RETURN_KEY_TYPE);
632 m_send_trans.put_data(type);
633 m_send_trans.write_to_socket(client_socket);
636 void get_helper_return_key_type(int client, uint32 context, const String& uuid, _OUT_ uint32& type) {
637 LOGD ("client id:%d\n", client);
639 Socket client_socket(client);
642 trans.put_command(SCIM_TRANS_CMD_REPLY);
643 trans.put_data(context);
644 trans.put_data(uuid);
645 trans.put_command(ISM_TRANS_CMD_GET_RETURN_KEY_TYPE);
649 if (trans.write_to_socket(client_socket)
650 && trans.read_from_socket(client_socket)
651 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
652 && trans.get_data(type)) {
653 SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
656 LOGW ("read failed\n");
660 void set_helper_return_key_disable(int client, uint32 context, const String& uuid, uint32 disabled) {
661 LOGD ("client id:%d\n", client);
663 Socket client_socket(client);
664 m_send_trans.clear();
665 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
666 m_send_trans.put_data(context);
667 m_send_trans.put_data(uuid);
668 m_send_trans.put_command(ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE);
669 m_send_trans.put_data(disabled);
670 m_send_trans.write_to_socket(client_socket);
673 void get_helper_return_key_disable(int client, uint32 context, const String& uuid, _OUT_ uint32& disabled) {
675 Socket client_socket(client);
676 LOGD ("client id:%d", client);
681 trans.put_command(SCIM_TRANS_CMD_REPLY);
682 trans.put_data(context);
683 trans.put_data(uuid);
684 trans.put_command(ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE);
688 if (trans.write_to_socket(client_socket)
689 && trans.read_from_socket(client_socket)
690 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
691 && trans.get_data(disabled)) {
692 SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
695 LOGW ("read failed");
699 void set_helper_layout(int client, uint32 context, const String& uuid, uint32& layout) {
700 LOGD ("client id:%d\n", client);
702 Socket client_socket(client);
703 m_send_trans.clear();
704 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
705 m_send_trans.put_data(context);
706 m_send_trans.put_data(uuid);
707 m_send_trans.put_command(ISM_TRANS_CMD_SET_LAYOUT);
708 m_send_trans.put_data(layout);
709 m_send_trans.write_to_socket(client_socket);
712 void set_helper_input_mode(int client, uint32 context, const String& uuid, uint32& mode) {
713 LOGD ("client id:%d\n", client);
715 Socket client_socket(client);
716 m_send_trans.clear();
717 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
718 m_send_trans.put_data(context);
719 m_send_trans.put_data(uuid);
720 m_send_trans.put_command(ISM_TRANS_CMD_SET_INPUT_MODE);
721 m_send_trans.put_data(mode);
722 m_send_trans.write_to_socket(client_socket);
725 void set_helper_input_hint(int client, uint32 context, const String& uuid, uint32& hint) {
726 LOGD ("client id:%d\n", client);
728 Socket client_socket(client);
729 m_send_trans.clear();
730 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
731 m_send_trans.put_data(context);
732 m_send_trans.put_data(uuid);
733 m_send_trans.put_command(ISM_TRANS_CMD_SET_INPUT_HINT);
734 m_send_trans.put_data(hint);
735 m_send_trans.write_to_socket(client_socket);
738 void set_helper_bidi_direction(int client, uint32 context, const String& uuid, uint32& direction) {
739 LOGD ("client id:%d\n", client);
741 Socket client_socket(client);
742 m_send_trans.clear();
743 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
744 m_send_trans.put_data(context);
745 m_send_trans.put_data(uuid);
746 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION);
747 m_send_trans.put_data(direction);
748 m_send_trans.write_to_socket(client_socket);
751 void set_helper_caps_mode(int client, uint32 context, const String& uuid, uint32& mode) {
752 LOGD ("client id:%d\n", client);
754 Socket client_socket(client);
755 m_send_trans.clear();
756 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
757 m_send_trans.put_data(context);
758 m_send_trans.put_data(uuid);
759 m_send_trans.put_command(ISM_TRANS_CMD_SET_CAPS_MODE);
760 m_send_trans.put_data(mode);
761 m_send_trans.write_to_socket(client_socket);
764 void show_helper_option_window(int client, uint32 context, const String& uuid) {
765 LOGD ("client id:%d\n", client);
767 Socket client_socket(client);
769 aul_wakeup_ime_application(client_socket.get_id());
771 m_send_trans.clear();
772 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
773 m_send_trans.put_data(context);
774 m_send_trans.put_data(uuid);
775 m_send_trans.put_command(ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW);
776 m_send_trans.write_to_socket(client_socket);
779 void resume_helper_option_window(int client, uint32 context, const String& uuid) {
780 LOGD ("client id:%d\n", client);
782 Socket client_socket(client);
784 aul_wakeup_ime_application(client_socket.get_id());
786 m_send_trans.clear();
787 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
788 m_send_trans.put_data(context);
789 m_send_trans.put_data(uuid);
790 m_send_trans.put_command(ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW);
791 m_send_trans.write_to_socket(client_socket);
794 bool process_key_event(int client, uint32 context, const String& uuid, KeyEvent& key, uint32 serial) {
795 LOGD ("client id:%d\n", client);
797 Socket client_socket(client);
802 trans.put_command(SCIM_TRANS_CMD_REPLY);
803 trans.put_data(context);
804 trans.put_data(uuid);
805 trans.put_command(SCIM_TRANS_CMD_PROCESS_KEY_EVENT);
807 trans.put_data(serial);
809 if (trans.write_to_socket(client_socket)) {
810 SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
813 LOGW ("read failed\n");
819 bool get_helper_geometry(int client, uint32 context, String& uuid, _OUT_ struct rectinfo& info) {
820 LOGD ("client id:%d\n", client);
822 Socket client_socket(client);
826 trans.put_command(SCIM_TRANS_CMD_REPLY);
827 trans.put_data(context);
828 trans.put_data(uuid);
829 trans.put_command(ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY);
831 if (trans.write_to_socket(client_socket)) {
836 if (trans.read_from_socket(client_socket)
837 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
838 && trans.get_data(info.pos_x)
839 && trans.get_data(info.pos_y)
840 && trans.get_data(info.width)
841 && trans.get_data(info.height)) {
842 SCIM_DEBUG_MAIN(1) << __func__ << " is successful\n";
845 LOGW ("read failed\n");
847 LOGW ("write failed\n");
852 void get_helper_imdata(int client, uint32 context, String& uuid, char** imdata, size_t& len) {
853 LOGD ("client id:%d\n", client);
854 Socket client_socket(client);
858 trans.put_command(SCIM_TRANS_CMD_REPLY);
859 trans.put_data(context);
860 trans.put_data(uuid);
861 trans.put_command(ISM_TRANS_CMD_GET_ISE_IMDATA);
865 if (trans.write_to_socket(client_socket)
866 && trans.read_from_socket(client_socket)
867 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY) {
868 trans.get_data(imdata, len);
869 LOGD ("length of imdata is %d", len);
871 LOGW ("read imdata failed\n");
875 void get_helper_layout(int client, uint32 context, String& uuid, uint32& layout) {
876 LOGD ("client id:%d\n", client);
878 Socket client_socket(client);
882 trans.put_command(SCIM_TRANS_CMD_REPLY);
883 trans.put_data(context);
884 trans.put_data(uuid);
885 trans.put_command(ISM_TRANS_CMD_GET_LAYOUT);
889 if (trans.write_to_socket(client_socket)
890 && trans.read_from_socket(client_socket)
891 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
892 && trans.get_data(layout)) {
893 SCIM_DEBUG_MAIN(1) << "get_helper_layout success\n";
898 void get_ise_language_locale(int client, uint32 context, String& uuid, char** data, size_t& len) {
899 SCIM_DEBUG_MAIN(4) << __func__ << "\n";
900 LOGD ("client id:%d\n", client);
905 trans.put_command(SCIM_TRANS_CMD_REPLY);
906 trans.put_data(context);
907 trans.put_data(uuid);
908 trans.put_command(ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE);
911 Socket client_socket(client);
913 if (trans.write_to_socket(client_socket)
914 && trans.read_from_socket(client_socket)
915 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
916 && trans.get_data(data, len)) {
922 void check_option_window(int client, uint32 context, String& uuid, _OUT_ uint32& avail) {
923 LOGD ("client id:%d\n", client);
926 Socket client_socket(client);
931 trans.put_command(SCIM_TRANS_CMD_REPLY);
932 trans.put_data(context);
933 trans.put_data(uuid);
934 trans.put_command(ISM_TRANS_CMD_CHECK_OPTION_WINDOW);
935 trans.write_to_socket(client_socket);
937 if (!trans.read_from_socket(client_socket, m_socket_timeout) ||
938 !trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REPLY ||
939 !trans.get_data(avail)) {
940 LOGW ("ISM_TRANS_CMD_CHECK_OPTION_WINDOW failed\n");
944 void reset_ise_option(int client, uint32 context) {
945 LOGD ("client id:%d\n", client);
947 Socket client_socket(client);
948 m_send_trans.clear();
949 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
950 m_send_trans.put_data((uint32) context);
951 m_send_trans.put_command(ISM_TRANS_CMD_RESET_ISE_OPTION);
952 m_send_trans.write_to_socket(client_socket);
955 void reset_helper_context(int client, uint32 context, const String& uuid) {
956 LOGD ("client id:%d\n", client);
958 Socket client_socket(client);
959 m_send_trans.clear();
960 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
961 m_send_trans.put_data(context);
962 m_send_trans.put_data(uuid);
963 m_send_trans.put_command(ISM_TRANS_CMD_RESET_ISE_CONTEXT);
964 m_send_trans.write_to_socket(client_socket);
967 void reload_config(int client) {
968 SCIM_DEBUG_MAIN(1) << "PanelAgent::reload_config ()\n";
969 LOGD ("client id:%d\n", client);
971 m_send_trans.clear();
972 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
973 m_send_trans.put_command(SCIM_TRANS_CMD_RELOAD_CONFIG);
975 Socket client_socket(client);
976 m_send_trans.write_to_socket(client_socket);
979 void exit(int client, uint32 context) {
980 SCIM_DEBUG_MAIN(1) << "PanelAgent::exit ()\n";
981 LOGD ("client id:%d\n", client);
983 m_send_trans.clear();
984 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
986 if (m_info_manager->socket_get_client_info(client).type == HELPER_CLIENT) {
987 m_send_trans.put_data(context);
988 m_send_trans.put_data(m_info_manager->get_current_helper_uuid());
991 m_send_trans.put_command(SCIM_TRANS_CMD_EXIT);
993 Socket client_socket(client);
994 m_send_trans.write_to_socket(client_socket);
997 bool process_input_device_event(int client, uint32 context, const String& uuid, uint32 type, const char *data, size_t len, _OUT_ uint32& result) {
998 LOGD("client id:%d\n", client);
1000 Socket client_socket(client);
1005 trans.put_command(SCIM_TRANS_CMD_REPLY);
1006 trans.put_data(context);
1007 trans.put_data(uuid);
1008 trans.put_command(ISM_TRANS_CMD_PROCESS_INPUT_DEVICE_EVENT);
1009 trans.put_data(type);
1010 trans.put_data(data, len);
1013 if (trans.write_to_socket(client_socket)
1014 && trans.read_from_socket(client_socket)
1015 && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
1016 && trans.get_data(result)) {
1017 SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
1021 LOGW("read failed\n");
1027 void socket_update_surrounding_text(int client, uint32 context, const String& uuid, String& text, uint32 cursor) {
1028 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1029 LOGD ("client id:%d\n", client);
1031 Socket client_socket(client);
1033 m_send_trans.clear();
1034 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1035 m_send_trans.put_data(context);
1036 m_send_trans.put_data(uuid);
1037 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT);
1038 m_send_trans.put_data(text);
1039 m_send_trans.put_data(cursor);
1040 m_send_trans.write_to_socket(client_socket);
1043 void socket_remoteinput_focus_in (int client) {
1044 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1045 LOGD ("client id:%d\n", client);
1048 ret = (client == -1) ? false : true;
1051 Socket client_socket(client);
1053 m_send_trans.clear();
1054 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1055 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_FOCUS_IN);
1056 m_send_trans.write_to_socket(client_socket);
1060 void socket_remoteinput_focus_out (int client) {
1061 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1062 LOGD ("client id:%d\n", client);
1065 ret = (client == -1) ? false : true;
1068 Socket client_socket(client);
1070 m_send_trans.clear();
1071 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1072 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_FOCUS_OUT);
1073 m_send_trans.write_to_socket(client_socket);
1077 void socket_remoteinput_entry_metadata (int client, uint32 hint, uint32 layout, int variation, uint32 autocapital_type, int return_key_disabled) {
1078 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1079 LOGD ("client id:%d\n", client);
1082 ret = (client == -1) ? false : true;
1085 Socket client_socket(client);
1087 m_send_trans.clear();
1088 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1089 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_ENTRY_METADATA);
1090 m_send_trans.put_data(hint);
1091 m_send_trans.put_data(layout);
1092 m_send_trans.put_data(variation);
1093 m_send_trans.put_data(autocapital_type);
1094 m_send_trans.put_data(return_key_disabled);
1095 m_send_trans.write_to_socket(client_socket);
1099 void socket_remoteinput_surrounding_text (int client, String& text, uint32 cursor) {
1100 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1101 LOGD ("client id:%d\n", client);
1104 ret = (client == -1) ? false : true;
1107 Socket client_socket(client);
1109 m_send_trans.clear();
1110 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1111 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_SURROUNDING_TEXT);
1112 m_send_trans.put_data(text);
1113 m_send_trans.put_data(cursor);
1114 m_send_trans.write_to_socket(client_socket);
1118 void socket_remoteinput_input_resource (int client, uint32 input_resource) {
1119 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
1120 LOGD ("client id:%d\n", client);
1123 ret = (client == -1) ? false : true;
1126 Socket client_socket(client);
1128 m_send_trans.clear();
1129 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1130 m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_INPUT_RESOURCE);
1131 m_send_trans.put_data(input_resource);
1132 m_send_trans.write_to_socket(client_socket);
1136 void socket_update_selection(int client, uint32 context, String& uuid, String text) {
1137 LOGD ("client id:%d\n", client);
1139 Socket client_socket(client);
1141 m_send_trans.clear();
1142 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1143 m_send_trans.put_data(context);
1144 m_send_trans.put_data(uuid);
1145 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SELECTION);
1146 m_send_trans.put_data(text);
1147 m_send_trans.write_to_socket(client_socket);
1150 void socket_get_keyboard_ise_list(int client, uint32 context, const String& uuid, std::vector<String>& list) {
1151 LOGD ("client id:%d\n", client);
1153 Socket socket_client(client);
1154 m_send_trans.clear();
1155 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1156 m_send_trans.put_data(context);
1157 m_send_trans.put_data(uuid);
1158 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE_LIST);
1159 m_send_trans.put_data(list.size());
1161 for (unsigned int i = 0; i < list.size(); i++)
1162 m_send_trans.put_data(list[i]);
1164 m_send_trans.write_to_socket(socket_client);
1167 void socket_get_candidate_ui(int client, uint32 context, const String& uuid, int style, int mode) {
1168 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_get_candidate_ui ()\n";
1170 LOGD ("client id:%d\n", client);
1172 Socket socket_client(client);
1173 m_send_trans.clear();
1174 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1175 m_send_trans.put_data(context);
1176 m_send_trans.put_data(uuid);
1177 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_UI);
1178 m_send_trans.put_data(style);
1179 m_send_trans.put_data(mode);
1180 m_send_trans.write_to_socket(socket_client);
1183 void socket_get_candidate_geometry(int client, uint32 context, const String& uuid, struct rectinfo& info) {
1184 SCIM_DEBUG_MAIN(4) << __func__ << " \n";
1186 LOGD ("client id:%d\n", client);
1188 Socket socket_client(client);
1189 m_send_trans.clear();
1190 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1191 m_send_trans.put_data(context);
1192 m_send_trans.put_data(uuid);
1193 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CANDIDATE_GEOMETRY);
1194 m_send_trans.put_data(info.pos_x);
1195 m_send_trans.put_data(info.pos_y);
1196 m_send_trans.put_data(info.width);
1197 m_send_trans.put_data(info.height);
1198 m_send_trans.write_to_socket(socket_client);
1201 void socket_get_keyboard_ise(int client, uint32 context, const String& uuid, String& ise_name, String& ise_uuid) {
1202 LOGD ("client id:%d\n", client);
1204 Socket socket_client(client);
1205 m_send_trans.clear();
1206 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1207 m_send_trans.put_data(context);
1208 m_send_trans.put_data(uuid);
1209 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_KEYBOARD_ISE);
1210 m_send_trans.put_data(ise_name);
1211 m_send_trans.put_data(ise_uuid);
1212 m_send_trans.write_to_socket(socket_client);
1215 void socket_start_helper(int client, uint32 context, const String& ic_uuid) {
1216 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_start_helper ()\n";
1218 LOGD ("client id:%d\n", client);
1220 Socket client_socket(client);
1221 m_send_trans.clear();
1222 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1223 m_send_trans.put_data(context);
1224 m_send_trans.put_data(ic_uuid);
1225 m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1226 m_send_trans.write_to_socket(client_socket);
1229 void helper_detach_input_context(int client, uint32 context, const String& ic_uuid) {
1230 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_stop_helper ()\n";
1232 LOGD ("client id:%d\n", client);
1234 Socket client_socket(client);
1235 m_send_trans.clear();
1236 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1237 m_send_trans.put_data(context);
1238 m_send_trans.put_data(ic_uuid);
1239 m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_DETACH_INPUT_CONTEXT);
1240 m_send_trans.write_to_socket(client_socket);
1243 void helper_process_imengine_event(int client, uint32 context, const String& ic_uuid, const Transaction& _nest_trans) {
1244 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_send_helper_event ()\n";
1245 LOGD ("client id:%d\n", client);
1247 Socket client_socket(client);
1251 m_send_trans.clear();
1252 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1254 /* FIXME: We presume that client and context are both less than 65536.
1255 * Hopefully, it should be true in any UNIXs.
1256 * So it's ok to combine client and context into one uint32. */
1257 m_send_trans.put_data(context);
1258 m_send_trans.put_data(ic_uuid);
1259 m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_PROCESS_IMENGINE_EVENT);
1260 m_send_trans.put_data(_nest_trans);
1261 m_send_trans.write_to_socket(client_socket);
1266 void process_helper_event(int client, uint32 context, String target_uuid, String active_uuid, Transaction& nest_trans) {
1267 LOGD ("client id:%d\n", client);
1269 SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_helper_send_imengine_event (" << client << ")\n";
1270 Socket socket_client(client);
1272 m_send_trans.clear();
1273 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1274 m_send_trans.put_data(context);
1275 m_send_trans.put_command(SCIM_TRANS_CMD_PROCESS_HELPER_EVENT);
1276 m_send_trans.put_data(target_uuid);
1277 m_send_trans.put_data(active_uuid);
1278 m_send_trans.put_data(nest_trans);
1279 m_send_trans.write_to_socket(socket_client);
1284 void socket_helper_key_event(int client, uint32 context, int cmd, KeyEvent& key) {
1285 LOGD ("client id:%d\n", client);
1287 Socket socket_client(client);
1289 m_send_trans.clear();
1290 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1291 m_send_trans.put_data(context);
1292 m_send_trans.put_command(cmd);
1293 m_send_trans.put_data(key);
1294 m_send_trans.write_to_socket(socket_client);
1298 void commit_string(int client, uint32 target_context, const WideString& wstr) {
1299 LOGD ("client id:%d\n", client);
1301 Socket socket_client(client);
1303 m_send_trans.clear();
1304 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1305 m_send_trans.put_data(target_context);
1306 m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_STRING);
1307 m_send_trans.put_data(wstr);
1308 m_send_trans.write_to_socket(socket_client);
1312 void socket_helper_get_surrounding_text(int client, uint32 context_id, uint32 maxlen_before, uint32 maxlen_after) {
1313 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1314 LOGD ("client id:%d\n", client);
1316 Socket socket_client(client);
1318 m_send_trans.clear();
1319 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1320 m_send_trans.put_data(context_id);
1321 m_send_trans.put_command(SCIM_TRANS_CMD_GET_SURROUNDING_TEXT);
1322 m_send_trans.put_data(maxlen_before);
1323 m_send_trans.put_data(maxlen_after);
1324 m_send_trans.write_to_socket(socket_client);
1328 void socket_helper_delete_surrounding_text(int client, uint32 context_id, uint32 offset, uint32 len) {
1329 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1330 LOGD ("client id:%d\n", client);
1332 Socket socket_client(client);
1334 m_send_trans.clear();
1335 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1336 m_send_trans.put_data(context_id);
1337 m_send_trans.put_command(SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT);
1338 m_send_trans.put_data(offset);
1339 m_send_trans.put_data(len);
1340 m_send_trans.write_to_socket(socket_client);
1344 void socket_helper_get_selection(int client, uint32 context_id) {
1345 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1346 LOGD ("client id:%d\n", client);
1349 Socket socket_client(client);
1351 m_send_trans.clear();
1352 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1353 m_send_trans.put_data(context_id);
1354 m_send_trans.put_command(SCIM_TRANS_CMD_GET_SELECTION);
1355 m_send_trans.write_to_socket(socket_client);
1359 void socket_helper_set_selection(int client, uint32 context_id, uint32 start, uint32 end) {
1360 LOGD ("client id:%d\n", client);
1362 Socket socket_client(client);
1364 m_send_trans.clear();
1365 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1366 m_send_trans.put_data(context_id);
1367 m_send_trans.put_command(SCIM_TRANS_CMD_SET_SELECTION);
1368 m_send_trans.put_data(start);
1369 m_send_trans.put_data(end);
1370 m_send_trans.write_to_socket(socket_client);
1374 void show_preedit_string(int client, uint32 target_context) {
1375 LOGD ("client id:%d\n", client);
1377 Socket socket_client(client);
1379 m_send_trans.clear();
1380 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1381 m_send_trans.put_data(target_context);
1382 m_send_trans.put_command(SCIM_TRANS_CMD_SHOW_PREEDIT_STRING);
1383 m_send_trans.write_to_socket(socket_client);
1387 void hide_preedit_string(int client, uint32 target_context) {
1388 LOGD ("client id:%d\n", client);
1390 Socket socket_client(client);
1392 m_send_trans.clear();
1393 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1394 m_send_trans.put_data(target_context);
1395 m_send_trans.put_command(SCIM_TRANS_CMD_HIDE_PREEDIT_STRING);
1396 m_send_trans.write_to_socket(socket_client);
1400 void update_preedit_string(int client, uint32 target_context, WideString preedit, WideString commit, AttributeList& attrs, uint32 caret) {
1401 LOGD ("client id:%d\n", client);
1403 Socket socket_client(client);
1405 m_send_trans.clear();
1406 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1407 m_send_trans.put_data(target_context);
1408 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
1409 m_send_trans.put_data(preedit);
1410 m_send_trans.put_data(commit);
1411 m_send_trans.put_data(attrs);
1412 m_send_trans.put_data(caret);
1413 m_send_trans.write_to_socket(socket_client);
1418 void update_preedit_caret(int client, uint32 focused_context, uint32 caret) {
1420 LOGD ("client id:%d\n", client);
1422 Socket socket_client(client);
1424 m_send_trans.clear();
1425 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1426 m_send_trans.put_data(focused_context);
1427 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET);
1428 m_send_trans.put_data(caret);
1429 m_send_trans.write_to_socket(socket_client);
1434 void helper_attach_input_context_and_update_screen(int client, std::vector < std::pair <uint32, String> >& helper_ic_index, uint32 current_screen) {
1435 LOGD ("client id:%d\n", client);
1437 Socket socket_client(client);
1438 m_send_trans.clear();
1439 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1440 m_send_trans.put_command(SCIM_TRANS_CMD_OK);
1441 m_send_trans.put_command(SCIM_TRANS_CMD_HELPER_ATTACH_INPUT_CONTEXT);
1443 for (size_t i = 0; i < helper_ic_index.size(); ++i) {
1444 m_send_trans.put_data(helper_ic_index[i].first);
1445 m_send_trans.put_data(helper_ic_index[i].second);
1448 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1449 m_send_trans.put_data((uint32)current_screen);
1450 m_send_trans.write_to_socket(socket_client);
1453 void update_ise_input_context(int client, uint32 focused_context, uint32 type, uint32 value) {
1454 LOGD ("client id:%d\n", client);
1456 Socket client_socket(client);
1457 m_send_trans.clear();
1458 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1459 m_send_trans.put_data(focused_context);
1460 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT);
1461 m_send_trans.put_data(type);
1462 m_send_trans.put_data(value);
1463 m_send_trans.write_to_socket(client_socket);
1467 void send_private_command(int client, uint32 focused_context, String command) {
1468 LOGD ("client id:%d\n", client);
1470 Socket socket_client(client);
1472 m_send_trans.clear();
1473 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1474 m_send_trans.put_data(focused_context);
1475 m_send_trans.put_command(SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND);
1476 m_send_trans.put_data(command);
1477 m_send_trans.write_to_socket(socket_client);
1481 void helper_all_update_spot_location(int client, uint32 context_id, String uuid, int x, int y) {
1482 LOGD ("client id:%d\n", client);
1484 m_send_trans.clear();
1485 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1487 /* FIXME: We presume that client and context are both less than 65536.
1488 * Hopefully, it should be true in any UNIXs.
1489 * So it's ok to combine client and context into one uint32. */
1490 m_send_trans.put_data(context_id);
1491 m_send_trans.put_data(uuid);
1492 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION);
1493 m_send_trans.put_data((uint32) x);
1494 m_send_trans.put_data((uint32) y);
1496 Socket client_socket(client);
1497 m_send_trans.write_to_socket(client_socket);
1501 void helper_all_update_cursor_position(int client, uint32 context_id, String uuid, int cursor_pos) {
1502 LOGD ("client id:%d\n", client);
1504 m_send_trans.clear();
1505 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1506 m_send_trans.put_data(context_id);
1507 m_send_trans.put_data(uuid);
1508 m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CURSOR_POSITION);
1509 m_send_trans.put_data((uint32) cursor_pos);
1511 Socket client_socket(client);
1512 m_send_trans.write_to_socket(client_socket);
1516 void helper_all_update_screen(int client, uint32 context_id, String uuid, int screen) {
1517 LOGD ("client id:%d\n", client);
1519 m_send_trans.clear();
1520 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1522 /* FIXME: We presume that client and context are both less than 65536.
1523 * Hopefully, it should be true in any UNIXs.
1524 * So it's ok to combine client and context into one uint32. */
1525 m_send_trans.put_data(context_id);
1526 m_send_trans.put_data(uuid);
1527 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
1528 m_send_trans.put_data((uint32) screen);
1530 Socket client_socket(client);
1531 m_send_trans.write_to_socket(client_socket);
1535 void set_autocapital_type(int client, uint32 context, String uuid, int mode) {
1536 LOGD ("client id:%d\n", client);
1538 m_send_trans.clear();
1539 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1541 m_send_trans.put_data(context);
1542 m_send_trans.put_data(uuid);
1543 m_send_trans.put_command(SCIM_TRANS_CMD_SET_AUTOCAPITAL_TYPE);
1544 m_send_trans.put_data((uint32) mode);
1546 Socket client_socket(client);
1547 m_send_trans.write_to_socket(client_socket);
1550 void remote_update_preedit_string (int client, uint32 target_context, const WideString str, const WideString commit, const AttributeList &attrs, uint32 caret) {
1551 LOGD("client id:%d\n", client);
1553 Socket client_socket(client);
1555 m_send_trans.clear();
1556 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1557 m_send_trans.put_data(target_context);
1558 m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
1559 m_send_trans.put_data(str);
1560 m_send_trans.put_data(commit);
1561 m_send_trans.put_data(attrs);
1562 m_send_trans.put_data(caret);
1563 m_send_trans.write_to_socket(client_socket);
1567 void remote_send_key_event (int client, uint32 target_context, const KeyEvent &key) {
1568 LOGD("client id:%d\n", client);
1570 Socket client_socket(client);
1572 m_send_trans.clear ();
1573 m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
1574 m_send_trans.put_data (target_context);
1575 m_send_trans.put_command (SCIM_TRANS_CMD_PROCESS_KEY_EVENT);
1576 m_send_trans.put_data (key);
1577 m_send_trans.write_to_socket (client_socket);
1581 void remote_forward_key_event (int client, uint32 target_context, const KeyEvent &key) {
1582 LOGD("client id:%d\n", client);
1584 Socket client_socket(client);
1586 m_send_trans.clear ();
1587 m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
1588 m_send_trans.put_data (target_context);
1589 m_send_trans.put_command (SCIM_TRANS_CMD_FORWARD_KEY_EVENT);
1590 m_send_trans.put_data (key);
1591 m_send_trans.write_to_socket (client_socket);
1595 void remote_commit_string (int client, uint32 target_context, const WideString& wstr) {
1596 LOGD ("client id:%d\n", client);
1598 Socket socket_client(client);
1600 m_send_trans.clear();
1601 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1602 m_send_trans.put_data(target_context);
1603 m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_STRING);
1604 m_send_trans.put_data(wstr);
1605 m_send_trans.write_to_socket(socket_client);
1609 void remote_delete_surrounding_text (int client, uint32 context_id, uint32 offset, uint32 len) {
1610 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1611 LOGD ("client id:%d\n", client);
1613 Socket socket_client(client);
1615 m_send_trans.clear();
1616 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1617 m_send_trans.put_data(context_id);
1618 m_send_trans.put_command(SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT);
1619 m_send_trans.put_data(offset);
1620 m_send_trans.put_data(len);
1621 m_send_trans.write_to_socket(socket_client);
1625 void set_prediction_allow (int client, uint32 context, String uuid, int mode) {
1626 LOGD ("client id:%d\n", client);
1628 m_send_trans.clear();
1629 m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
1631 m_send_trans.put_data(context);
1632 m_send_trans.put_data(uuid);
1633 m_send_trans.put_command(ISM_TRANS_CMD_SET_PREDICTION_ALLOW);
1634 m_send_trans.put_data((uint32) mode);
1636 Socket client_socket(client);
1637 m_send_trans.write_to_socket(client_socket);
1640 void send_fail_reply (int client)
1642 SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
1643 LOGD ("client id:%d\n", client);
1645 Socket client_socket (client);
1648 trans.put_command (SCIM_TRANS_CMD_REPLY);
1649 trans.put_command (SCIM_TRANS_CMD_FAIL);
1650 trans.write_to_socket (client_socket);
1655 bool filter_event(int fd) {
1656 SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_event ()\n";
1658 return m_socket_server.filter_event(fd);
1661 bool filter_exception_event(int fd) {
1662 SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_exception_event ()\n";
1664 return m_socket_server.filter_exception_event(fd);
1667 int get_server_id() {
1668 SCIM_DEBUG_MAIN(1) << "PanelAgent::get_server_id ()\n";
1670 return m_socket_server.get_id();
1673 bool socket_check_client_connection(const Socket& client) {
1674 SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_check_client_connection (" << client.get_id() << ")\n";
1676 unsigned char buf [sizeof(uint32)];
1678 int nbytes = client.read_with_timeout(buf, sizeof(uint32), m_socket_timeout);
1680 if (nbytes == sizeof(uint32))
1684 LOGW ("Error occurred when reading socket: %s\n", client.get_error_message().c_str());
1686 LOGW ("Timeout when reading socket\n");
1693 * @brief Callback function for ecore fd handler.
1695 * @param data The data to pass to this callback.
1696 * @param fd_handler The ecore fd handler.
1698 * @return ECORE_CALLBACK_RENEW
1700 static Eina_Bool panel_agent_handler(void* data, Ecore_Fd_Handler* fd_handler) {
1701 if (fd_handler == NULL || data == NULL)
1702 return ECORE_CALLBACK_RENEW;
1704 EcoreSocketPanelAgent* _agent = (EcoreSocketPanelAgent*)data;
1706 int fd = ecore_main_fd_handler_fd_get(fd_handler);
1708 for (unsigned int i = 0; i < _agent->_read_handler_list.size(); i++) {
1709 if (fd_handler == _agent->_read_handler_list [i]) {
1710 if (!_agent->filter_event(fd)) {
1711 std::cerr << "_panel_agent->filter_event () is failed!!!\n";
1713 ecore_main_fd_handler_del(fd_handler);
1715 ISF_SAVE_LOG("_panel_agent->filter_event (fd=%d) is failed!!!\n", fd);
1718 return ECORE_CALLBACK_RENEW;
1722 std::cerr << "panel_agent_handler () has received exception event!!!\n";
1723 _agent->filter_exception_event(fd);
1725 ecore_main_fd_handler_del(fd_handler);
1727 ISF_SAVE_LOG("Received exception event (fd=%d)!!!\n", fd);
1728 return ECORE_CALLBACK_RENEW;
1731 void socket_accept_callback(SocketServer* server,
1732 const Socket& client) {
1733 SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_accept_callback (" << client.get_id() << ")\n";
1737 if (m_should_exit) {
1738 SCIM_DEBUG_MAIN(3) << "Exit Socket Server Thread.\n";
1741 //m_signal_accept_connection (client.get_id ());
1742 Ecore_Fd_Handler* panel_agent_read_handler = ecore_main_fd_handler_add(client.get_id(), ECORE_FD_READ, panel_agent_handler, this, NULL, NULL);
1743 _read_handler_list.push_back(panel_agent_read_handler);
1749 void socket_receive_callback(SocketServer* server,
1750 const Socket& client) {
1751 int client_id = client.get_id();
1757 ClientInfo client_info;
1759 SCIM_DEBUG_MAIN(1) << "PanelAgent::socket_receive_callback (" << client_id << ")\n";
1761 /* If the connection is closed then close this client. */
1762 if (!socket_check_client_connection(client)) {
1763 LOGW ("check client connection failed\n");
1764 socket_close_connection(server, client);
1768 client_info = m_info_manager->socket_get_client_info(client_id);
1770 /* If it's a new client, then request to open the connection first. */
1771 if (client_info.type == UNKNOWN_CLIENT) {
1772 socket_open_connection(server, client);
1776 /* If can not read the transaction,
1777 * or the transaction is not started with SCIM_TRANS_CMD_REQUEST,
1778 * or the key is mismatch,
1780 if (!m_recv_trans.read_from_socket(client, m_socket_timeout) ||
1781 !m_recv_trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REQUEST ||
1782 !m_recv_trans.get_data(key) || key != (uint32) client_info.key) {
1783 LOGW ("cmd:%d key:%d client info key: %d\n", cmd, key, client_info.key);
1787 if (client_info.type == FRONTEND_ACT_CLIENT) {
1788 if (m_recv_trans.get_data(context)) {
1789 SCIM_DEBUG_MAIN(1) << "PanelAgent::FrontEnd Client, context = " << context << "\n";
1790 socket_transaction_start();
1792 while (m_recv_trans.get_command(cmd)) {
1793 LOGD ("PanelAgent::cmd = %d\n", cmd);
1795 if (cmd == ISM_TRANS_CMD_REGISTER_PANEL_CLIENT) {
1798 if (m_recv_trans.get_data(id)) {
1799 m_info_manager->register_panel_client(client_id, id);
1801 LOGW ("wrong format of transaction\n");
1807 else if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_INPUT_CONTEXT) {
1808 if (m_recv_trans.get_data(uuid)) {
1809 m_info_manager->register_input_context(client_id, context, uuid);
1811 LOGW ("wrong format of transaction\n");
1817 else if (cmd == SCIM_TRANS_CMD_PANEL_REMOVE_INPUT_CONTEXT) {
1818 m_info_manager->remove_input_context(client_id, context);
1822 else if (cmd == SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT) {
1823 m_info_manager->socket_reset_input_context(client_id, context);
1827 else if (cmd == SCIM_TRANS_CMD_FOCUS_IN) {
1828 SCIM_DEBUG_MAIN(4) << " SCIM_TRANS_CMD_FOCUS_IN (" << "client:" << client_id << " context:" << context << ")\n";
1830 if (m_recv_trans.get_data(uuid)) {
1831 m_info_manager->focus_in(client_id, context, uuid);
1833 LOGW ("wrong format of transaction\n");
1839 else if (cmd == ISM_TRANS_CMD_TURN_ON_LOG) {
1842 if (m_recv_trans.get_data(isOn)) {
1843 m_info_manager->socket_turn_on_log(isOn);
1845 LOGW ("wrong format of transaction\n");
1851 else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
1852 m_info_manager->show_isf_panel(client_id);
1854 } else if (cmd == ISM_TRANS_CMD_HIDE_ISF_CONTROL) {
1855 m_info_manager->hide_isf_panel(client_id);
1857 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_PANEL) {
1864 if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context) && m_recv_trans.get_data(&data, len)) {
1867 LOGW ("wrong format of transaction\n");
1871 Socket client_socket(client_id);
1874 trans.put_command(SCIM_TRANS_CMD_REPLY);
1875 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
1876 trans.put_data(ret);
1877 trans.write_to_socket(client_socket);
1883 m_info_manager->show_ise_panel(client_id, client, context, data, len);
1886 } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
1890 if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context)) {
1891 m_info_manager->hide_ise_panel(client_id, client, context);
1893 LOGW ("wrong format of transaction\n");
1897 } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE_GEOMETRY) {
1898 struct rectinfo info;
1899 m_info_manager->get_input_panel_geometry(client_id, info);
1901 Socket client_socket(client_id);
1904 trans.put_command(SCIM_TRANS_CMD_REPLY);
1905 trans.put_command(SCIM_TRANS_CMD_OK);
1906 trans.put_data(info.pos_x);
1907 trans.put_data(info.pos_y);
1908 trans.put_data(info.width);
1909 trans.put_data(info.height);
1910 trans.write_to_socket(client_socket);
1912 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
1913 struct rectinfo info;
1914 m_info_manager->get_candidate_window_geometry(client_id, info);
1916 Socket client_socket(client_id);
1919 trans.put_command(SCIM_TRANS_CMD_REPLY);
1920 trans.put_command(SCIM_TRANS_CMD_OK);
1921 trans.put_data(info.pos_x);
1922 trans.put_data(info.pos_y);
1923 trans.put_data(info.width);
1924 trans.put_data(info.height);
1925 trans.write_to_socket(client_socket);
1927 } else if (cmd == ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE) {
1930 m_info_manager->get_ise_language_locale(client_id, &data, len);
1933 trans.put_command(SCIM_TRANS_CMD_REPLY);
1935 if (data != NULL && len > 0) {
1936 trans.put_command(SCIM_TRANS_CMD_OK);
1937 trans.put_data(data, len);
1939 trans.put_command(SCIM_TRANS_CMD_FAIL);
1942 Socket client_socket(client_id);
1943 trans.write_to_socket(client_socket);
1949 } else if (cmd == ISM_TRANS_CMD_SET_ISE_LANGUAGE) {
1952 if (m_recv_trans.get_data(language)) {
1953 m_info_manager->set_ise_language(client_id, language);
1955 LOGW ("wrong format of transaction\n");
1959 } else if (cmd == ISM_TRANS_CMD_SET_ISE_IMDATA) {
1960 char* imdata = NULL;
1963 if (m_recv_trans.get_data(&imdata, len)) {
1964 m_info_manager->set_ise_imdata(client_id, imdata, len);
1966 LOGW ("wrong format of transaction\n");
1973 } else if (cmd == ISM_TRANS_CMD_GET_ISE_IMDATA) {
1974 char* imdata = NULL;
1976 m_info_manager->get_ise_imdata(client_id, &imdata, len);
1978 Socket client_socket(client_id);
1981 trans.put_command(SCIM_TRANS_CMD_REPLY);
1984 trans.put_command(SCIM_TRANS_CMD_OK);
1985 trans.put_data(imdata, len);
1987 trans.put_command(SCIM_TRANS_CMD_FAIL);
1990 trans.write_to_socket(client_socket);
1996 } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_TYPE) {
1999 if (m_recv_trans.get_data(type)) {
2000 m_info_manager->set_ise_return_key_type(client_id, type);
2002 LOGW ("wrong format of transaction\n");
2006 } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_TYPE) {
2008 bool ret = m_info_manager->get_ise_return_key_type(client_id, type);
2010 Socket client_socket(client_id);
2013 trans.put_command(SCIM_TRANS_CMD_REPLY);
2016 trans.put_command(SCIM_TRANS_CMD_OK);
2017 trans.put_data(type);
2019 trans.put_command(SCIM_TRANS_CMD_FAIL);
2022 trans.write_to_socket(client_socket);
2024 } else if (cmd == ISM_TRANS_CMD_SET_RETURN_KEY_DISABLE) {
2027 if (m_recv_trans.get_data(disabled)) {
2028 m_info_manager->set_ise_return_key_disable(client_id, disabled);
2030 LOGW ("wrong format of transaction\n");
2034 } else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE) {
2037 m_info_manager->get_ise_return_key_disable(client_id, disabled);
2039 Socket client_socket(client_id);
2042 trans.put_command(SCIM_TRANS_CMD_REPLY);
2045 trans.put_command(SCIM_TRANS_CMD_OK);
2046 trans.put_data(disabled);
2048 trans.put_command(SCIM_TRANS_CMD_FAIL);
2051 trans.write_to_socket(client_socket);
2053 } else if (cmd == ISM_TRANS_CMD_GET_LAYOUT) {
2055 bool ret = m_info_manager->get_ise_layout(client_id, layout);
2057 Socket client_socket(client_id);
2060 trans.put_command(SCIM_TRANS_CMD_REPLY);
2063 trans.put_command(SCIM_TRANS_CMD_OK);
2064 trans.put_data(layout);
2066 trans.put_command(SCIM_TRANS_CMD_FAIL);
2069 trans.write_to_socket(client_socket);
2071 } else if (cmd == ISM_TRANS_CMD_SET_LAYOUT) {
2074 if (m_recv_trans.get_data(layout)) {
2075 m_info_manager->set_ise_layout(client_id, layout);
2077 LOGW ("wrong format of transaction\n");
2081 } else if (cmd == ISM_TRANS_CMD_SET_CAPS_MODE) {
2084 if (m_recv_trans.get_data(mode)) {
2085 m_info_manager->set_ise_caps_mode(client_id, mode);
2087 LOGW ("wrong format of transaction\n");
2091 } else if (cmd == ISM_TRANS_CMD_SEND_WILL_SHOW_ACK) {
2092 m_info_manager->will_show_ack(client_id);
2094 } else if (cmd == ISM_TRANS_CMD_SEND_WILL_HIDE_ACK) {
2095 m_info_manager->will_hide_ack(client_id);
2097 } else if (cmd == ISM_TRANS_CMD_SET_HARDWARE_KEYBOARD_MODE) {
2100 if (m_recv_trans.get_data(mode)) {
2101 m_info_manager->set_keyboard_mode(client_id, mode);
2103 LOGW ("wrong format of transaction\n");
2107 } else if (cmd == ISM_TRANS_CMD_SEND_CANDIDATE_WILL_HIDE_ACK) {
2108 m_info_manager->candidate_will_hide_ack(client_id);
2110 } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT) {
2116 if (m_recv_trans.get_data(key)) {
2118 m_info_manager->process_key_event(key, result);
2120 LOGW ("wrong format of transaction\n");
2124 Socket client_socket(client_id);
2127 trans.put_command(SCIM_TRANS_CMD_REPLY);
2130 trans.put_command(SCIM_TRANS_CMD_OK);
2131 trans.put_data(result);
2133 trans.put_command(SCIM_TRANS_CMD_FAIL);
2136 trans.write_to_socket(client_socket);
2138 } else if (cmd == ISM_TRANS_CMD_GET_ACTIVE_HELPER_OPTION) {
2140 m_info_manager->get_active_helper_option(client_id, option);
2142 Socket client_socket(client_id);
2145 trans.put_command(SCIM_TRANS_CMD_REPLY);
2146 trans.put_command(SCIM_TRANS_CMD_OK);
2147 trans.put_data(option);
2148 SCIM_DEBUG_MAIN(4) << __func__ << " option " << option << "\n";
2149 trans.write_to_socket(client_socket);
2151 } else if (cmd == ISM_TRANS_CMD_GET_ISE_STATE) {
2153 m_info_manager->get_ise_state(client_id, state);
2155 Socket client_socket(client_id);
2158 trans.put_command(SCIM_TRANS_CMD_REPLY);
2159 trans.put_command(SCIM_TRANS_CMD_OK);
2160 trans.put_data(state);
2161 trans.write_to_socket(client_socket);
2163 } else if (cmd == ISM_TRANS_CMD_SET_INPUT_MODE) {
2166 if (m_recv_trans.get_data(input_mode)) {
2167 m_info_manager->set_ise_input_mode(client_id, input_mode);
2169 LOGW ("wrong format of transaction\n");
2173 } else if (cmd == ISM_TRANS_CMD_SET_INPUT_HINT) {
2176 if (m_recv_trans.get_data(input_hint)) {
2177 m_info_manager->set_ise_input_hint(client_id, input_hint);
2179 LOGW ("wrong format of transaction\n");
2183 } else if (cmd == ISM_TRANS_CMD_UPDATE_BIDI_DIRECTION) {
2184 uint32 bidi_direction;
2186 if (m_recv_trans.get_data(bidi_direction)) {
2187 m_info_manager->update_ise_bidi_direction(client_id, bidi_direction);
2189 LOGW ("wrong format of transaction\n");
2193 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
2194 m_info_manager->show_ise_option_window(client_id);
2196 } else if (cmd == ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW) {
2197 m_info_manager->resume_ise_option_window(client_id);
2204 else if (cmd == SCIM_TRANS_CMD_START_HELPER) {
2207 if (m_recv_trans.get_data(uuid) && uuid.length()) {
2208 m_info_manager->socket_start_helper(client_id, context, uuid);
2210 LOGW ("wrong format of transaction\n");
2214 } else if (cmd == SCIM_TRANS_CMD_SEND_HELPER_EVENT) {
2217 if (m_recv_trans.get_data(uuid) && m_recv_trans.get_data(m_nest_trans) &&
2218 uuid.length() && m_nest_trans.valid()) {
2219 m_info_manager->socket_send_helper_event(client_id, context, uuid, m_nest_trans);
2221 LOGW ("wrong format of transaction\n");
2225 } else if (cmd == SCIM_TRANS_CMD_STOP_HELPER) {
2228 if (m_recv_trans.get_data(uuid) && uuid.length()) {
2229 m_info_manager->socket_stop_helper(client_id, context, uuid);
2231 LOGW ("wrong format of transaction\n");
2240 /* Client must focus in before do any other things. */
2241 else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_ON)
2242 m_info_manager->socket_turn_on();
2243 else if (cmd == SCIM_TRANS_CMD_PANEL_TURN_OFF)
2244 m_info_manager->socket_turn_off();
2245 else if (cmd == SCIM_TRANS_CMD_UPDATE_SCREEN) {
2248 if (m_recv_trans.get_data(num))
2249 m_info_manager->socket_update_screen(client_id, num);
2251 LOGW ("wrong format of transaction\n");
2252 } else if (cmd == SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION) {
2255 if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) && m_recv_trans.get_data(top_y)) {
2256 m_info_manager->socket_update_spot_location(x, y, top_y);
2258 LOGW ("wrong format of transaction\n");
2260 } else if (cmd == ISM_TRANS_CMD_UPDATE_CURSOR_POSITION) {
2263 if (m_recv_trans.get_data(cursor_pos)) {
2264 m_info_manager->socket_update_cursor_position(cursor_pos);
2266 LOGW ("wrong format of transaction\n");
2268 } else if (cmd == ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT) {
2272 if (m_recv_trans.get_data(text) && m_recv_trans.get_data(cursor)) {
2273 m_info_manager->socket_update_surrounding_text(text, cursor);
2275 LOGW ("wrong format of transaction\n");
2277 } else if (cmd == ISM_TRANS_CMD_UPDATE_SELECTION) {
2280 if (m_recv_trans.get_data(text)) {
2281 m_info_manager->socket_update_selection(text);
2283 LOGW ("wrong format of transaction\n");
2285 } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE)
2286 m_info_manager->expand_candidate();
2287 else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE)
2288 m_info_manager->contract_candidate();
2289 else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2290 uint32 portrait_line, mode;
2292 if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2293 m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2295 LOGW ("wrong format of transaction\n");
2296 } else if (cmd == SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO) {
2297 PanelFactoryInfo info;
2299 if (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2300 m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2301 m_info_manager->socket_update_factory_info(info);
2303 LOGW ("wrong format of transaction\n");
2305 } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING)
2306 m_info_manager->socket_show_preedit_string();
2307 else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING)
2308 m_info_manager->socket_show_aux_string();
2309 else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE)
2310 m_info_manager->socket_show_lookup_table();
2311 else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE)
2312 m_info_manager->socket_show_associate_table();
2313 else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING)
2314 m_info_manager->socket_hide_preedit_string();
2315 else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING)
2316 m_info_manager->socket_hide_aux_string();
2317 else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE)
2318 m_info_manager->socket_hide_lookup_table();
2319 else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE)
2320 m_info_manager->socket_hide_associate_table();
2321 else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2323 AttributeList attrs;
2326 if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs) && m_recv_trans.get_data(caret))
2327 m_info_manager->socket_update_preedit_string(str, attrs, caret);
2329 LOGW ("wrong format of transaction\n");
2330 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2333 if (m_recv_trans.get_data(caret))
2334 m_info_manager->socket_update_preedit_caret(caret);
2336 LOGW ("wrong format of transaction\n");
2337 } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2339 AttributeList attrs;
2341 if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2342 m_info_manager->socket_update_aux_string(str, attrs);
2344 LOGW ("wrong format of transaction\n");
2345 } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2346 CommonLookupTable _isf_candidate_table;
2348 if (m_recv_trans.get_data(_isf_candidate_table))
2349 m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2351 LOGW ("wrong format of transaction\n");
2353 } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2354 CommonLookupTable table;
2356 if (m_recv_trans.get_data(table))
2357 m_info_manager->socket_update_associate_table(table);
2359 LOGW ("wrong format of transaction\n");
2360 } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2361 PropertyList properties;
2363 if (m_recv_trans.get_data(properties))
2364 m_info_manager->socket_register_properties(properties);
2366 LOGW ("wrong format of transaction\n");
2367 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2370 if (m_recv_trans.get_data(property))
2371 m_info_manager->socket_update_property(property);
2373 LOGW ("wrong format of transaction\n");
2374 } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_HELP) {
2377 if (m_recv_trans.get_data(help))
2378 m_info_manager->socket_show_help(help);
2380 LOGW ("wrong format of transaction\n");
2381 } else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU) {
2382 PanelFactoryInfo info;
2383 std::vector <PanelFactoryInfo> vec;
2385 while (m_recv_trans.get_data(info.uuid) && m_recv_trans.get_data(info.name) &&
2386 m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
2387 info.lang = scim_get_normalized_language(info.lang);
2388 vec.push_back(info);
2391 m_info_manager->socket_show_factory_menu(vec);
2392 } else if (cmd == SCIM_TRANS_CMD_FOCUS_OUT) {
2393 m_info_manager->focus_out(client_id, context);
2395 LOGW ("unknow cmd: %d\n", cmd);
2399 socket_transaction_end();
2401 } else if (client_info.type == FRONTEND_CLIENT) {
2402 if (m_recv_trans.get_data(context)) {
2403 SCIM_DEBUG_MAIN(1) << "client_info.type == FRONTEND_CLIENT\n";
2404 socket_transaction_start();
2406 while (m_recv_trans.get_command(cmd)) {
2407 LOGD ("PanelAgent::cmd = %d\n", cmd);
2409 if (cmd == ISM_TRANS_CMD_GET_PANEL_CLIENT_ID) {
2410 Socket client_socket(client_id);
2414 trans.put_command(SCIM_TRANS_CMD_REPLY);
2415 trans.put_command(SCIM_TRANS_CMD_OK);
2416 trans.put_data(client_id);
2417 trans.write_to_socket(client_socket);
2420 LOGW ("unknow cmd: %d\n", cmd);
2424 socket_transaction_end();
2426 } else if (client_info.type == HELPER_CLIENT) {
2427 socket_transaction_start();
2429 while (m_recv_trans.get_command(cmd)) {
2430 LOGD ("PanelAgent::cmd = %d\n", cmd);
2432 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_HELPER) {
2435 if (m_recv_trans.get_data(info.uuid) &&
2436 m_recv_trans.get_data(info.name) &&
2437 m_recv_trans.get_data(info.icon) &&
2438 m_recv_trans.get_data(info.description) &&
2439 m_recv_trans.get_data(info.option) &&
2440 info.uuid.length()) {
2441 m_info_manager->socket_helper_register_helper(client_id, info);
2444 LOGW ("unknow cmd: %d\n", cmd);
2448 socket_transaction_end();
2449 } else if (client_info.type == HELPER_ACT_CLIENT) {
2450 socket_transaction_start();
2452 while (m_recv_trans.get_command(cmd)) {
2453 LOGD ("PanelAgent::cmd = %d\n", cmd);
2455 if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER) {
2458 if (m_recv_trans.get_data(info.uuid) &&
2459 m_recv_trans.get_data(info.name) &&
2460 m_recv_trans.get_data(info.icon) &&
2461 m_recv_trans.get_data(info.description) &&
2462 m_recv_trans.get_data(info.option) &&
2463 info.uuid.length()) {
2464 m_info_manager->socket_helper_register_helper_passive(client_id, info);
2466 LOGW ("wrong format of transaction\n");
2468 } else if (cmd == SCIM_TRANS_CMD_COMMIT_STRING) {
2473 if (m_recv_trans.get_data(target_ic) &&
2474 m_recv_trans.get_data(target_uuid) &&
2475 m_recv_trans.get_data(wstr) &&
2477 m_info_manager->socket_helper_commit_string(client_id, target_ic, target_uuid, wstr);
2479 LOGW ("wrong format of transaction\n");
2481 } else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING) {
2485 if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2486 m_info_manager->socket_helper_show_preedit_string(client_id, target_ic, target_uuid);
2488 LOGW ("wrong format of transaction\n");
2490 } else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING) {
2491 m_info_manager->socket_show_aux_string();
2492 } else if (cmd == SCIM_TRANS_CMD_SHOW_LOOKUP_TABLE) {
2493 m_info_manager->socket_show_lookup_table();
2494 } else if (cmd == ISM_TRANS_CMD_SHOW_ASSOCIATE_TABLE) {
2495 m_info_manager->socket_show_associate_table();
2496 } else if (cmd == SCIM_TRANS_CMD_HIDE_PREEDIT_STRING) {
2500 if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
2501 m_info_manager->socket_helper_hide_preedit_string(client_id, target_ic, target_uuid);
2503 LOGW ("wrong format of transaction\n");
2505 } else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING) {
2506 m_info_manager->socket_hide_aux_string();
2507 } else if (cmd == SCIM_TRANS_CMD_HIDE_LOOKUP_TABLE) {
2508 m_info_manager->socket_hide_lookup_table();
2509 } else if (cmd == ISM_TRANS_CMD_HIDE_ASSOCIATE_TABLE) {
2510 m_info_manager->socket_hide_associate_table();
2511 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
2516 AttributeList attrs;
2519 if (m_recv_trans.get_data(target_ic) &&
2520 m_recv_trans.get_data(target_uuid) &&
2521 m_recv_trans.get_data(preedit) &&
2522 m_recv_trans.get_data(commit) &&
2523 m_recv_trans.get_data(attrs) &&
2524 m_recv_trans.get_data(caret)) {
2525 m_info_manager->socket_helper_update_preedit_string(client_id, target_ic, target_uuid, preedit, commit, attrs, caret);
2527 LOGW ("wrong format of transaction\n");
2529 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
2532 if (m_recv_trans.get_data(caret)) {
2533 m_info_manager->socket_helper_update_preedit_caret(client_id, caret);
2535 LOGW ("wrong format of transaction\n");
2537 } else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
2539 AttributeList attrs;
2541 if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
2542 m_info_manager->socket_update_aux_string(str, attrs);
2544 LOGW ("wrong format of transaction\n");
2546 } else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
2547 CommonLookupTable _isf_candidate_table;
2549 if (m_recv_trans.get_data(_isf_candidate_table)) {
2550 m_info_manager->socket_update_lookup_table(_isf_candidate_table);
2552 LOGW ("wrong format of transaction\n");
2554 } else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
2555 CommonLookupTable _isf_candidate_table;
2557 if (m_recv_trans.get_data(_isf_candidate_table)) {
2558 m_info_manager->socket_update_associate_table(_isf_candidate_table);
2560 LOGW ("wrong format of transaction\n");
2562 } else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT ||
2563 cmd == SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT) {
2568 if (m_recv_trans.get_data(target_ic) &&
2569 m_recv_trans.get_data(target_uuid) &&
2570 m_recv_trans.get_data(key) &&
2572 m_info_manager->socket_helper_send_key_event(client_id, target_ic, target_uuid, key);
2574 LOGW ("wrong format of transaction\n");
2576 } else if (cmd == SCIM_TRANS_CMD_FORWARD_KEY_EVENT) {
2581 if (m_recv_trans.get_data(target_ic) &&
2582 m_recv_trans.get_data(target_uuid) &&
2583 m_recv_trans.get_data(key) &&
2585 m_info_manager->socket_helper_forward_key_event(client_id, target_ic, target_uuid, key);
2587 LOGW ("wrong format of transaction\n");
2589 } else if (cmd == SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT) {
2593 if (m_recv_trans.get_data(target_ic) &&
2594 m_recv_trans.get_data(target_uuid) &&
2595 m_recv_trans.get_data(m_nest_trans) &&
2596 m_nest_trans.valid()) {
2597 m_info_manager->socket_helper_send_imengine_event(client_id, target_ic, target_uuid, m_nest_trans);
2599 LOGW ("wrong format of transaction\n");
2601 } else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
2602 PropertyList properties;
2604 if (m_recv_trans.get_data(properties))
2605 m_info_manager->socket_helper_register_properties(client_id, properties);
2607 LOGW ("wrong format of transaction\n");
2608 } else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
2611 if (m_recv_trans.get_data(property))
2612 m_info_manager->socket_helper_update_property(client_id, property);
2614 LOGW ("wrong format of transaction\n");
2615 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT) {
2619 if (m_recv_trans.get_data(type) && m_recv_trans.get_data(value)) {
2620 m_info_manager->socket_helper_update_input_context(client_id, type, value);
2622 LOGW ("wrong format of transaction\n");
2624 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST) {
2627 if (m_recv_trans.get_data(uuid)) {
2628 m_info_manager->socket_get_keyboard_ise_list(uuid);
2630 LOGW ("wrong format of transaction\n");
2632 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
2633 uint32 portrait_line, mode;
2635 if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
2636 m_info_manager->socket_set_candidate_ui(portrait_line, mode);
2638 LOGW ("wrong format of transaction\n");
2639 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_UI) {
2642 if (m_recv_trans.get_data(uuid)) {
2643 m_info_manager->socket_get_candidate_ui(uuid);
2645 LOGW ("wrong format of transaction\n");
2647 } else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_POSITION) {
2650 if (m_recv_trans.get_data(left) && m_recv_trans.get_data(top))
2651 m_info_manager->socket_set_candidate_position(left, top);
2653 LOGW ("wrong format of transaction\n");
2654 } else if (cmd == ISM_TRANS_CMD_HIDE_CANDIDATE) {
2655 m_info_manager->socket_hide_candidate();
2656 } else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
2659 if (m_recv_trans.get_data(uuid)) {
2660 m_info_manager->socket_get_candidate_geometry(uuid);
2662 LOGW ("wrong format of transaction\n");
2664 } else if (cmd == ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE) {
2665 m_info_manager->reset_keyboard_ise();
2666 } else if (cmd == ISM_TRANS_CMD_SET_KEYBOARD_ISE_BY_UUID) {
2669 if (m_recv_trans.get_data(uuid)) {
2670 m_info_manager->socket_set_keyboard_ise(uuid);
2672 LOGW ("wrong format of transaction\n");
2674 } else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE) {
2677 if (m_recv_trans.get_data(uuid)) {
2678 m_info_manager->socket_get_keyboard_ise(uuid);
2680 LOGW ("wrong format of transaction\n");
2682 } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY) {
2683 uint32 x, y, width, height;
2685 if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) &&
2686 m_recv_trans.get_data(width) && m_recv_trans.get_data(height)) {
2687 m_info_manager->socket_helper_update_ise_geometry(client_id, x, y, width, height);
2689 LOGW ("wrong format of transaction\n");
2691 } else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE) {
2692 m_info_manager->expand_candidate();
2693 } else if (cmd == ISM_TRANS_CMD_CONTRACT_CANDIDATE) {
2694 m_info_manager->contract_candidate();
2695 } else if (cmd == ISM_TRANS_CMD_SELECT_CANDIDATE) {
2698 if (m_recv_trans.get_data(index))
2699 m_info_manager->socket_helper_select_candidate(index);
2701 LOGW ("wrong format of transaction\n");
2702 } else if (cmd == SCIM_TRANS_CMD_GET_SURROUNDING_TEXT) {
2704 uint32 maxlen_before;
2705 uint32 maxlen_after;
2707 if (m_recv_trans.get_data(uuid) &&
2708 m_recv_trans.get_data(maxlen_before) &&
2709 m_recv_trans.get_data(maxlen_after)) {
2710 m_info_manager->socket_helper_get_surrounding_text(client_id, uuid, maxlen_before, maxlen_after);
2712 LOGW ("wrong format of transaction\n");
2714 } else if (cmd == SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
2718 if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
2719 m_info_manager->socket_helper_delete_surrounding_text(client_id, offset, len);
2721 LOGW ("wrong format of transaction\n");
2723 } else if (cmd == SCIM_TRANS_CMD_GET_SELECTION) {
2726 if (m_recv_trans.get_data(uuid)) {
2727 m_info_manager->socket_helper_get_selection(client_id, uuid);
2729 LOGW ("wrong format of transaction\n");
2731 } else if (cmd == SCIM_TRANS_CMD_SET_SELECTION) {
2735 if (m_recv_trans.get_data(start) && m_recv_trans.get_data(end)) {
2736 m_info_manager->socket_helper_set_selection(client_id, start, end);
2738 LOGW ("wrong format of transaction\n");
2740 } else if (cmd == SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND) {
2743 if (m_recv_trans.get_data(command)) {
2744 m_info_manager->socket_helper_send_private_command(client_id, command);
2746 LOGW ("wrong format of transaction\n");
2749 //} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_EXIT) {
2750 // m_info_manager->UPDATE_ISE_EXIT(client_id);
2751 } else if (cmd == ISM_TRANS_CMD_PROCESS_KEY_EVENT_DONE) {
2756 if (m_recv_trans.get_data(key) && m_recv_trans.get_data(ret) && m_recv_trans.get_data(serial)) {
2757 m_info_manager->process_key_event_done(key, ret, serial);
2759 LOGW ("wrong format of transaction\n");
2761 } else if (cmd == ISM_TRANS_CMD_REQUEST_ISE_HIDE) {
2762 m_info_manager->request_ise_hide();
2764 LOGW ("unknow cmd: %d\n", cmd);
2768 socket_transaction_end();
2769 } else if (client_info.type == IMCONTROL_ACT_CLIENT) {
2770 socket_transaction_start();
2772 while (m_recv_trans.get_command(cmd)) {
2773 LOGD ("PanelAgent::cmd = %d\n", cmd);
2775 if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE) {
2777 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2778 String default_uuid;
2779 m_info_manager->get_active_ise(client_id, default_uuid);
2781 Socket client_socket(client_id);
2784 trans.put_command(SCIM_TRANS_CMD_REPLY);
2785 trans.put_command(SCIM_TRANS_CMD_OK);
2786 trans.put_data(default_uuid);
2787 trans.write_to_socket(client_socket);
2790 LOGW ("Access denied to get active ise\n");
2791 send_fail_reply (client_id);
2793 } else if (cmd == ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID) {
2794 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2799 if (m_recv_trans.get_data(&buf, len)) {
2800 ret = m_info_manager->set_active_ise_by_uuid(client_id, buf, len);
2802 LOGW ("wrong format of transaction\n");
2806 Socket client_socket(client_id);
2809 trans.put_command(SCIM_TRANS_CMD_REPLY);
2810 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2811 trans.write_to_socket(client_socket);
2817 LOGW ("Access denied to set active ise\n");
2818 send_fail_reply (client_id);
2820 } else if (cmd == ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID) {
2821 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2827 //ret need be checked
2828 if (m_recv_trans.get_data(&buf, len)) {
2829 m_info_manager->set_initial_ise_by_uuid(client_id, buf, len);
2831 LOGW ("wrong format of transaction\n");
2835 Socket client_socket(client_id);
2838 trans.put_command(SCIM_TRANS_CMD_REPLY);
2839 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2840 trans.write_to_socket(client_socket);
2846 LOGW ("Access denied to set initial ise\n");
2847 send_fail_reply (client_id);
2849 } else if (cmd == ISM_TRANS_CMD_GET_ISE_LIST) {
2850 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2851 std::vector<String> strlist;
2852 m_info_manager->get_ise_list(client_id, strlist);
2854 Socket client_socket(client_id);
2860 trans.put_command(SCIM_TRANS_CMD_REPLY);
2861 trans.put_command(SCIM_TRANS_CMD_OK);
2863 num = strlist.size();
2864 trans.put_data(num);
2866 for (unsigned int i = 0; i < num; i++) {
2867 buf = const_cast<char*>(strlist[i].c_str());
2868 len = strlen(buf) + 1;
2869 trans.put_data(buf, len);
2872 trans.write_to_socket(client_socket);
2875 LOGW ("Access denied to get ise list\n");
2876 send_fail_reply (client_id);
2878 } else if (cmd == ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO) {
2879 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2880 HELPER_ISE_INFO info;
2881 m_info_manager->get_all_helper_ise_info(client_id, info);
2885 Socket client_socket(client_id);
2888 trans.put_command(SCIM_TRANS_CMD_REPLY);
2889 trans.put_command(SCIM_TRANS_CMD_OK);
2891 if (info.appid.size() > 0) {
2892 trans.put_data(info.appid);
2893 trans.put_data(info.label);
2894 trans.put_data(info.is_enabled);
2895 trans.put_data(info.is_preinstalled);
2896 trans.put_data(info.has_option);
2899 trans.write_to_socket(client_socket);
2903 LOGW ("Access denied to get all helper ise info\n");
2904 send_fail_reply (client_id);
2906 } else if (cmd == ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO) {
2907 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2912 if (m_recv_trans.get_data(appid) && appid.length() != 0 && m_recv_trans.get_data(is_enabled)) {
2913 m_info_manager->set_enable_helper_ise_info(client_id, appid, is_enabled);
2916 LOGW ("wrong format of transaction\n");
2920 Socket client_socket(client_id);
2923 trans.put_command(SCIM_TRANS_CMD_REPLY);
2924 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
2925 trans.write_to_socket(client_socket);
2928 LOGW ("Access denied to set enable helper ise info\n");
2929 send_fail_reply (client_id);
2931 } else if (cmd == ISM_TRANS_CMD_GET_ISE_INFORMATION) {
2932 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2933 String strUuid, strName, strLanguage, strModuleName;
2937 if (m_recv_trans.get_data(strUuid)) {
2938 m_info_manager->get_ise_information(client_id, strUuid, strName, strLanguage, nType, nOption, strModuleName);
2940 LOGW ("wrong format of transaction\n");
2944 Socket client_socket(client_id);
2946 trans.put_command(SCIM_TRANS_CMD_REPLY);
2947 trans.put_command(SCIM_TRANS_CMD_OK);
2948 trans.put_data(strName);
2949 trans.put_data(strLanguage);
2950 trans.put_data(nType);
2951 trans.put_data(nOption);
2952 trans.put_data(strModuleName);
2953 trans.write_to_socket(client_socket);
2956 LOGW ("Access denied to get ise information\n");
2957 send_fail_reply (client_id);
2959 } else if (cmd == ISM_TRANS_CMD_RESET_ISE_OPTION) {
2960 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2962 Socket client_socket(client_id);
2965 trans.put_command(SCIM_TRANS_CMD_REPLY);
2966 trans.put_command(SCIM_TRANS_CMD_OK);
2967 trans.write_to_socket(client_socket);
2968 m_info_manager->show_helper_ise_selector(client_id);
2969 m_info_manager->reset_ise_option(client_id);
2972 LOGW ("Access denied to reset ise option\n");
2973 send_fail_reply (client_id);
2975 } else if (cmd == ISM_TRANS_CMD_RESET_DEFAULT_ISE) {
2976 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2977 m_info_manager->reset_default_ise(client_id);
2980 LOGW ("Access denied to reset default ise\n");
2981 send_fail_reply (client_id);
2983 } else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
2984 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2985 m_info_manager->show_isf_panel(client_id);
2988 LOGW ("Access denied to show isf control\n");
2989 send_fail_reply (client_id);
2991 } else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
2992 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
2993 m_info_manager->show_ise_option_window(client_id);
2996 LOGW ("Access denied to show ise option window\n");
2997 send_fail_reply (client_id);
2999 } else if (cmd == ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW) {
3000 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3001 m_info_manager->resume_ise_option_window(client_id);
3004 LOGW ("Access denied to resume ise option window\n");
3005 send_fail_reply (client_id);
3007 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST) {
3008 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3010 Socket client_socket(client_id);
3013 trans.put_command(SCIM_TRANS_CMD_REPLY);
3014 trans.put_command(SCIM_TRANS_CMD_OK);
3015 trans.write_to_socket(client_socket);
3017 m_info_manager->show_helper_ise_list(client_id);
3020 LOGW ("Access denied to show helper ise list\n");
3021 send_fail_reply (client_id);
3023 } else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR) {
3024 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3026 Socket client_socket(client_id);
3029 trans.put_command(SCIM_TRANS_CMD_REPLY);
3030 trans.put_command(SCIM_TRANS_CMD_OK);
3031 trans.write_to_socket(client_socket);
3032 m_info_manager->show_helper_ise_selector(client_id);
3035 LOGW ("Access denied to show helper ise selector\n");
3036 send_fail_reply (client_id);
3038 } else if (cmd == ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED) {
3039 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
3041 uint32 nEnabled = 0;
3044 //ret need be checked
3045 m_info_manager->is_helper_ise_enabled(client_id, strAppid, nEnabled);
3047 Socket client_socket(client_id);
3049 trans.put_command(SCIM_TRANS_CMD_REPLY);
3052 trans.put_command(SCIM_TRANS_CMD_OK);
3053 trans.put_data(static_cast<uint32>(nEnabled));
3055 trans.put_command(SCIM_TRANS_CMD_FAIL);
3058 trans.write_to_socket(client_socket);
3061 LOGW ("Access denied to check helper ise enabled\n");
3062 send_fail_reply (client_id);
3064 } else if (cmd == ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY) {
3068 Socket client_socket(client_id);
3071 trans.put_command(SCIM_TRANS_CMD_REPLY);
3073 if (m_recv_trans.get_data(angle)) {
3074 struct rectinfo info = {0, 0, 0, 0};
3075 m_info_manager->get_recent_ise_geometry(client_id, angle, info);
3077 trans.put_command(SCIM_TRANS_CMD_OK);
3078 trans.put_data(info.pos_x);
3079 trans.put_data(info.pos_y);
3080 trans.put_data(info.width);
3081 trans.put_data(info.height);
3083 trans.put_command(SCIM_TRANS_CMD_FAIL);
3086 trans.write_to_socket(client_socket);
3087 } else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
3089 Socket client_socket(client_id);
3092 trans.put_command(SCIM_TRANS_CMD_REPLY);
3093 trans.put_command(SCIM_TRANS_CMD_OK);
3094 trans.write_to_socket(client_socket);
3095 m_info_manager->hide_helper_ise ();
3097 LOGW ("unknow cmd: %d\n", cmd);
3101 socket_transaction_end();
3102 } else if (client_info.type == REMOTEINPUT_ACT_CLIENT) {
3103 socket_transaction_start();
3104 while (m_recv_trans.get_command(cmd)) {
3105 LOGD ("PanelAgent::cmd = %d\n", cmd);
3106 if (cmd == ISM_REMOTE_TRANS_CMD_SEND_INPUT_MESSAGE) {
3111 if (m_recv_trans.get_data(&buf, len)) {
3112 ret = m_info_manager->remoteinput_send_input_message(client_id, buf, len);
3114 LOGW ("wrong format of transaction\n");
3118 Socket client_socket(client_id);
3121 trans.put_command(SCIM_TRANS_CMD_REPLY);
3122 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3123 trans.write_to_socket(client_socket);
3127 } else if (cmd == ISM_REMOTE_TRANS_CMD_CHECK_PRIVILEGE) {
3130 if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE))
3134 Socket client_socket(client_id);
3137 trans.put_command(SCIM_TRANS_CMD_REPLY);
3138 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3139 trans.write_to_socket(client_socket);
3140 } else if (cmd == ISM_REMOTE_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
3145 if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
3146 ret = m_info_manager->remoteinput_delete_surrounding_text(offset, len);
3148 LOGW ("wrong format of transaction\n");
3152 Socket client_socket(client_id);
3155 trans.put_command(SCIM_TRANS_CMD_REPLY);
3156 trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
3157 trans.write_to_socket(client_socket);
3159 LOGW ("unknow cmd: %d\n", cmd);
3163 socket_transaction_end ();
3167 void socket_exception_callback(SocketServer* server,
3168 const Socket& client) {
3169 SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_exception_callback (" << client.get_id() << ")\n";
3170 LOGD ("client id:%d\n", client.get_id());
3171 socket_close_connection(server, client);
3174 bool socket_open_connection(SocketServer* server,
3175 const Socket& client) {
3176 SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_open_connection (" << client.get_id() << ")\n";
3177 LOGD ("client id:%d\n", client.get_id());
3179 String type = scim_socket_accept_connection(key,
3181 String("FrontEnd,FrontEnd_Active,Helper,Helper_Active,IMControl_Active,IMControl_Passive,RemoteInput_Active,RemoteInput_Passive,SocketConfig"),
3185 SCIM_DEBUG_MAIN (3) << "type = " << type << "\n";
3186 if (type.length()) {
3187 ClientType _type = ((type == "FrontEnd") ? FRONTEND_CLIENT :
3188 ((type == "FrontEnd_Active") ? FRONTEND_ACT_CLIENT :
3189 ((type == "Helper") ? HELPER_CLIENT :
3190 ((type == "Helper_Active") ? HELPER_ACT_CLIENT :
3191 ((type == "IMControl_Active") ? IMCONTROL_ACT_CLIENT :
3192 ((type == "IMControl_Passive") ? IMCONTROL_CLIENT :
3193 ((type == "RemoteInput_Active") ? REMOTEINPUT_ACT_CLIENT :
3194 ((type == "RemoteInput_Passive") ? REMOTEINPUT_CLIENT : CONFIG_CLIENT))))))));
3196 m_info_manager->add_client(client.get_id(), key, _type);
3200 LOGW ("open_connection failed\n");
3202 SCIM_DEBUG_MAIN(4) << "Close client connection " << client.get_id() << "\n";
3203 server->close_connection(client);
3207 void socket_close_connection(SocketServer* server,
3208 const Socket& client) {
3209 SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_close_connection (" << client.get_id() << ")\n";
3210 LOGD ("client id:%d\n", client.get_id());
3212 std::vector<Ecore_Fd_Handler *>::iterator IterPos;
3214 for (IterPos = _read_handler_list.begin (); IterPos != _read_handler_list.end (); ++IterPos,++i) {
3215 if (ecore_main_fd_handler_fd_get (_read_handler_list[i]) == client.get_id()) {
3216 ::close (client.get_id ());
3217 ecore_main_fd_handler_del (_read_handler_list[i]);
3218 _read_handler_list.erase (IterPos);
3222 m_info_manager->del_client(client.get_id());
3225 void socket_transaction_start(void) {
3226 //m_signal_transaction_start ();
3229 void socket_transaction_end(void) {
3230 //m_signal_transaction_end ();
3237 //m_signal_unlock ();
3241 } /* namespace scim */
3243 /***************************************************/
3244 /*** Beginning of panel agent interface for ISF ***/
3245 /***************************************************/
3246 static scim::PanelAgentPointer instance;
3250 EXAPI void scim_module_init(void)
3254 EXAPI void scim_module_exit(void)
3259 EXAPI void scim_panel_agent_module_init(const scim::ConfigPointer& config)
3264 EXAPI scim::PanelAgentPointer scim_panel_agent_module_get_instance()
3266 scim::PanelAgentBase* _instance = NULL;
3267 if (instance.null()) {
3269 _instance = new scim::EcoreSocketPanelAgent();
3275 instance = _instance;
3282 vi:ts=4:nowrap:ai:expandtab