#include <string.h>
#include <sys/types.h>
#include <sys/times.h>
+#include <sys/socket.h>
#include <dlog.h>
#include <unistd.h>
#include <Ecore.h>
+#include <aul.h>
#include "scim_private.h"
#include "scim.h"
#include "scim_stl_map.h"
+#include "isf_debug.h"
+#include <errno.h>
#ifdef LOG_TAG
# undef LOG_TAG
#endif
#define LOG_TAG "ISF_ECORE_SOCKET_MODULE"
-#define MIN_REPEAT_TIME 2.0
-
#define IMEMANAGER_PRIVILEGE "http://tizen.org/privilege/imemanager"
#define SCIM_CONFIG_PANEL_SOCKET_CONFIG_READONLY "/Panel/Socket/ConfigReadOnly"
std::vector<int> count;
};
+void aul_wakeup_ime_application(int sockfd)
+{
+ struct ucred ucred;
+ socklen_t len = sizeof(struct ucred);
+ if (getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &ucred, &len) == 0) {
+ int ret = aul_update_freezer_status((long)ucred.pid, "wakeup");
+ LOGD("aul_update_freezer_status : %d %d", ucred.pid, ret);
+ } else {
+ LOGD("getsockopt failed : %d", errno);
+ }
+}
#define DEFAULT_CONTEXT_VALUE 0xfff
#define scim_module_init ecoresocket_LTX_scim_module_init
#define scim_panel_agent_module_get_instance ecoresocket_LTX_scim_panel_agent_module_get_instance
-static ConfigPointer _config;
-
-
//==================================== PanelAgent ===========================
class EcoreSocketPanelAgent: public PanelAgentBase
{
bool m_should_shared_ise;
bool m_ise_exiting;
- bool m_config_readonly;
std::vector<Ecore_Fd_Handler*> _read_handler_list;
m_socket_timeout(scim_get_default_socket_timeout()),
m_should_shared_ise(false),
m_ise_exiting(false),
- m_config_readonly (false) {
+ m_info_manager(NULL) {
m_socket_server.signal_connect_accept(slot(this, &EcoreSocketPanelAgent::socket_accept_callback));
m_socket_server.signal_connect_receive(slot(this, &EcoreSocketPanelAgent::socket_receive_callback));
m_socket_server.signal_connect_exception(slot(this, &EcoreSocketPanelAgent::socket_exception_callback));
}
~EcoreSocketPanelAgent() {
+ stop ();
for (unsigned int ii = 0; ii < _read_handler_list.size(); ++ii) {
ecore_main_fd_handler_del(_read_handler_list[ii]);
}
}
bool initialize(InfoManager* info_manager, const String& display, bool resident) {
- LOGD ("");
m_info_manager = info_manager;
m_socket_address = scim_get_default_panel_socket_address(display);
- if (!_config.null ())
- m_config_readonly = _config->read (String (SCIM_CONFIG_PANEL_SOCKET_CONFIG_READONLY), false);
- else {
- m_config_readonly = false;
- LOGW("config is not ready");
- }
-
m_socket_server.shutdown();
if (m_socket_server.create(SocketAddress(m_socket_address))) {
_read_handler_list.push_back(panel_agent_read_handler);
return true;
}
- LOGE("create server failed\n");
+ LOGE("create server failed");
return false;
}
void stop(void) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::stop ()\n";
- LOGD ("");
lock();
m_should_exit = true;
unlock();
if (client.connect(SocketAddress(m_socket_address))) {
client.close();
}
- _config.reset();
}
private:
void update_panel_event(int client, uint32 context_id, int cmd, uint32 nType, uint32 nValue) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
void move_preedit_caret(int client, uint32 context_id, uint32 position) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::move_preedit_caret (" << position << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
m_send_trans.put_data((uint32) context_id);
m_send_trans.put_command(SCIM_TRANS_CMD_PANEL_REQUEST_HELP);
m_send_trans.write_to_socket(client_socket);
-
}
void request_factory_menu(int client_id, uint32 context_id) {
#endif
void reset_keyboard_ise(int client, uint32 context_id) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
}
void update_keyboard_ise_list(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void change_factory(int client, uint32 context, const String& uuid) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::change_factory (" << uuid << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void helper_candidate_show(int client, uint32 context, const String& uuid) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
-
+ LOGD ("client id:%d", client);
Socket client_socket(client);
}
void helper_candidate_hide(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
void candidate_more_window_show(int client, uint32 context) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
-
+ LOGD ("client id:%d", client);
Socket client_socket(client);
void candidate_more_window_hide(int client, uint32 context) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
void update_helper_lookup_table(int client, uint32 context, const String& uuid, const LookupTable& table) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
void select_aux(int client, uint32 contextid, uint32 item) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::select_aux (" << item << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void select_candidate(int client, uint32 context, uint32 item) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void lookup_table_page_up(int client, uint32 context) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::lookup_table_page_up ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void lookup_table_page_down(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void update_lookup_table_page_size(int client, uint32 context, uint32 size) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void update_candidate_item_layout(int client, uint32 context, const std::vector<uint32>& row_items) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void select_associate(int client, uint32 context, uint32 item) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void associate_table_page_up(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void associate_table_page_down(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void update_associate_table_page_size(int client, uint32 context, uint32 size) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void update_displayed_candidate_number(int client, uint32 context, uint32 size) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void send_longpress_event(int client, uint32 context, int index) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void trigger_property(int client, uint32 context, const String& property) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void focus_out_helper(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void focus_in_helper(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void show_helper(int client, uint32 context, const String& uuid, char* data, size_t& len) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
+
+ aul_wakeup_ime_application(client_socket.get_id());
+
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
m_send_trans.put_data(context);
}
void hide_helper(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_mode(int client, uint32 context, const String& uuid, uint32& mode) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_language(int client, uint32 context, const String& uuid, uint32& language) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_imdata(int client, uint32 context, const String& uuid, const char* imdata, size_t& len) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_return_key_type(int client, uint32 context, const String& uuid, uint32 type) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void get_helper_return_key_type(int client, uint32 context, const String& uuid, _OUT_ uint32& type) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
Transaction trans;
SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
} else {
- LOGW ("read failed\n");
+ LOGW ("read failed");
}
}
void set_helper_return_key_disable(int client, uint32 context, const String& uuid, uint32 disabled) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void get_helper_return_key_disable(int client, uint32 context, const String& uuid, _OUT_ uint32& disabled) {
-
Socket client_socket(client);
LOGD ("client id:%d", client);
}
void set_helper_layout(int client, uint32 context, const String& uuid, uint32& layout) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_input_mode(int client, uint32 context, const String& uuid, uint32& mode) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_input_hint(int client, uint32 context, const String& uuid, uint32& hint) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_bidi_direction(int client, uint32 context, const String& uuid, uint32& direction) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void set_helper_caps_mode(int client, uint32 context, const String& uuid, uint32& mode) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void show_helper_option_window(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
+
+ aul_wakeup_ime_application(client_socket.get_id());
+
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
m_send_trans.put_data(context);
m_send_trans.write_to_socket(client_socket);
}
- bool process_key_event(int client, uint32 context, const String& uuid, KeyEvent& key, _OUT_ uint32& result) {
- LOGD ("client id:%d\n", client);
+ void resume_helper_option_window(int client, uint32 context, const String& uuid) {
+ LOGD ("client id:%d", client);
+
+ Socket client_socket(client);
+
+ aul_wakeup_ime_application(client_socket.get_id());
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(context);
+ m_send_trans.put_data(uuid);
+ m_send_trans.put_command(ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW);
+ m_send_trans.write_to_socket(client_socket);
+ }
+
+ void set_helper_keyboard_mode(int client, uint32 context, const String& uuid, uint32& mode) {
+ LOGD ("client id:%d", client);
+
+ Socket client_socket(client);
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(context);
+ m_send_trans.put_data(uuid);
+ m_send_trans.put_command(ISM_TRANS_CMD_SET_KEYBOARD_MODE);
+ m_send_trans.put_data(mode);
+ m_send_trans.write_to_socket(client_socket);
+ }
+
+ void set_helper_prediction_hint(int client, uint32 context, const String& uuid, String& prediction_hint) {
+ LOGD ("client id:%d", client);
+
+ Socket client_socket(client);
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(context);
+ m_send_trans.put_data(uuid);
+ m_send_trans.put_command(ISM_TRANS_CMD_SET_PREDICTION_HINT);
+ m_send_trans.put_data(prediction_hint);
+ m_send_trans.write_to_socket(client_socket);
+ }
+
+ void set_helper_mime_type(int client, uint32 context, const String& uuid, String& mime_type) {
+ LOGD ("client id:%d", client);
+
+ Socket client_socket(client);
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(context);
+ m_send_trans.put_data(uuid);
+ m_send_trans.put_command(ISM_TRANS_CMD_SET_MIME_TYPE);
+ m_send_trans.put_data(mime_type);
+ m_send_trans.write_to_socket(client_socket);
+ }
+
+ void set_helper_prediction_hint_data(int client, uint32 context, const String& uuid, String& key, String &value) {
+ Socket client_socket(client);
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(context);
+ m_send_trans.put_data(uuid);
+ m_send_trans.put_command(ISM_TRANS_CMD_SET_PREDICTION_HINT_DATA);
+ m_send_trans.put_data(key);
+ m_send_trans.put_data(value);
+ m_send_trans.write_to_socket(client_socket);
+ }
+
+ void finalize_content_helper(int client, uint32 context, const String& uuid, String& text, uint32& cursor_pos) {
+ LOGD("client id:%d", client);
+
+ Socket client_socket(client);
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(context);
+ m_send_trans.put_data(uuid);
+ m_send_trans.put_command(ISM_TRANS_CMD_FINALIZE_CONTENT);
+ m_send_trans.put_data(text);
+ m_send_trans.put_data(cursor_pos);
+ m_send_trans.write_to_socket(client_socket);
+ }
+
+ bool process_key_event(int client, uint32 context, const String& uuid, KeyEvent& key, uint32 serial) {
+ LOGD ("client id:%d", client);
Socket client_socket(client);
trans.put_data(uuid);
trans.put_command(SCIM_TRANS_CMD_PROCESS_KEY_EVENT);
trans.put_data(key);
- int cmd;
+ trans.put_data(serial);
- if (trans.write_to_socket(client_socket)
- && trans.read_from_socket(client_socket)
- && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
- && trans.get_data(result)) {
+ if (trans.write_to_socket(client_socket)) {
SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
return true;
} else {
- LOGW ("read failed\n");
+ LOGW ("read failed");
}
return false;
}
bool get_helper_geometry(int client, uint32 context, String& uuid, _OUT_ struct rectinfo& info) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
SCIM_DEBUG_MAIN(1) << __func__ << " is successful\n";
return true;
} else
- LOGW ("read failed\n");
+ LOGW ("read failed");
} else
- LOGW ("write failed\n");
+ LOGW ("write failed");
return false;
}
void get_helper_imdata(int client, uint32 context, String& uuid, char** imdata, size_t& len) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
Transaction trans;
if (trans.write_to_socket(client_socket)
&& trans.read_from_socket(client_socket)
- && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY) {
- trans.get_data(imdata, len);
+ && trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
+ && trans.get_data(imdata, len)) {
LOGD ("length of imdata is %d", len);
} else {
- LOGW ("read imdata failed\n");
+ LOGW ("read imdata failed");
}
}
void get_helper_layout(int client, uint32 context, String& uuid, uint32& layout) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
&& trans.get_data(layout)) {
SCIM_DEBUG_MAIN(1) << "get_helper_layout success\n";
} else
- LOGW ("failed\n");
+ LOGW ("failed");
}
- void get_ise_language_locale(int client, uint32 context, String& uuid, char* data, size_t& len) {
+ void get_ise_language_locale(int client, uint32 context, String& uuid, char** data, size_t& len) {
SCIM_DEBUG_MAIN(4) << __func__ << "\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Transaction trans;
if (trans.write_to_socket(client_socket)
&& trans.read_from_socket(client_socket)
&& trans.get_command(cmd) && cmd == SCIM_TRANS_CMD_REPLY
- && trans.get_data(&data, len)) {
+ && trans.get_data(data, len)) {
} else {
- LOGW ("failed\n");
+ LOGW ("failed");
}
}
void check_option_window(int client, uint32 context, String& uuid, _OUT_ uint32& avail) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
int cmd;
Socket client_socket(client);
if (!trans.read_from_socket(client_socket, m_socket_timeout) ||
!trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REPLY ||
!trans.get_data(avail)) {
- LOGW ("ISM_TRANS_CMD_CHECK_OPTION_WINDOW failed\n");
+ LOGW ("ISM_TRANS_CMD_CHECK_OPTION_WINDOW failed");
}
}
void reset_ise_option(int client, uint32 context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
}
void reset_helper_context(int client, uint32 context, const String& uuid) {
- LOGD ("client id:%d\n", client);
-
+ LOGD ("client id:%d", client);
+ Transaction trans;
Socket client_socket(client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
void reload_config(int client) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::reload_config ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
void exit(int client, uint32 context) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::exit ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
Socket client_socket(client);
m_send_trans.write_to_socket(client_socket);
+
+ m_info_manager->del_client(client_socket.get_id());
+ }
+
+ bool process_input_device_event(int client, uint32 context, const String& uuid, uint32 type, const char *data, size_t len, _OUT_ uint32& result) {
+ LOGD("client id:%d", client);
+
+ Socket client_socket(client);
+
+ Transaction trans;
+
+ trans.clear();
+ trans.put_command(SCIM_TRANS_CMD_REPLY);
+ trans.put_data(context);
+ trans.put_data(uuid);
+ trans.put_command(ISM_TRANS_CMD_PROCESS_INPUT_DEVICE_EVENT);
+ trans.put_data(type);
+ trans.put_data(data, len);
+
+ if (trans.write_to_socket(client_socket)) {
+ SCIM_DEBUG_MAIN(1) << __func__ << " success\n";
+ return true;
+ }
+ else {
+ LOGW("read failed");
+ }
+
+ return false;
}
void socket_update_surrounding_text(int client, uint32 context, const String& uuid, String& text, uint32 cursor) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.put_data(text);
m_send_trans.put_data(cursor);
m_send_trans.write_to_socket(client_socket);
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_command(ISM_TRANS_CMD_FLUSH_BUFFER);
+ m_send_trans.write_to_socket(client_socket);
}
- void socket_update_selection(int client, uint32 context, const String& uuid, String text) {
- LOGD ("client id:%d\n", client);
+ void socket_remoteinput_focus_in (int client) {
+ SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
+ LOGD ("client id:%d", client);
+
+ bool ret;
+ ret = (client == -1) ? false : true;
+
+ if (ret) {
+ Socket client_socket(client);
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_FOCUS_IN);
+ m_send_trans.write_to_socket(client_socket);
+ }
+ }
+
+ void socket_remoteinput_focus_out (int client) {
+ SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
+ LOGD ("client id:%d", client);
+
+ bool ret;
+ ret = (client == -1) ? false : true;
+
+ if (ret) {
+ Socket client_socket(client);
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_FOCUS_OUT);
+ m_send_trans.write_to_socket(client_socket);
+ }
+ }
+
+ void socket_remoteinput_entry_metadata (int client, uint32 hint, uint32 layout, int variation, uint32 autocapital_type, int return_key_disabled) {
+ SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
+ LOGD ("client id:%d", client);
+
+ bool ret;
+ ret = (client == -1) ? false : true;
+
+ if (ret) {
+ Socket client_socket(client);
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_ENTRY_METADATA);
+ m_send_trans.put_data(hint);
+ m_send_trans.put_data(layout);
+ m_send_trans.put_data(variation);
+ m_send_trans.put_data(autocapital_type);
+ m_send_trans.put_data(return_key_disabled);
+ m_send_trans.write_to_socket(client_socket);
+ }
+ }
+
+ void socket_remoteinput_surrounding_text (int client, String& text, uint32 cursor) {
+ SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
+ LOGD ("client id:%d", client);
+
+ bool ret;
+ ret = (client == -1) ? false : true;
+
+ if (ret) {
+ Socket client_socket(client);
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_SURROUNDING_TEXT);
+ m_send_trans.put_data(text);
+ m_send_trans.put_data(cursor);
+ m_send_trans.write_to_socket(client_socket);
+ }
+ }
+
+ void socket_remoteinput_input_resource (int client, uint32 input_resource) {
+ SCIM_DEBUG_MAIN(4) << __FUNCTION__ << "...\n";
+ LOGD ("client id:%d", client);
+
+ bool ret;
+ ret = (client == -1) ? false : true;
+
+ if (ret) {
+ Socket client_socket(client);
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_command(ISM_REMOTE_TRANS_CMD_RECV_INPUT_RESOURCE);
+ m_send_trans.put_data(input_resource);
+ m_send_trans.write_to_socket(client_socket);
+ }
+ }
+
+ void socket_update_selection(int client, uint32 context, String& uuid, String text) {
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_SELECTION);
m_send_trans.put_data(text);
m_send_trans.write_to_socket(client_socket);
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_command(ISM_TRANS_CMD_FLUSH_BUFFER);
+ m_send_trans.write_to_socket(client_socket);
}
void socket_get_keyboard_ise_list(int client, uint32 context, const String& uuid, std::vector<String>& list) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
void socket_get_candidate_ui(int client, uint32 context, const String& uuid, int style, int mode) {
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_get_candidate_ui ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
void socket_get_candidate_geometry(int client, uint32 context, const String& uuid, struct rectinfo& info) {
SCIM_DEBUG_MAIN(4) << __func__ << " \n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
}
void socket_get_keyboard_ise(int client, uint32 context, const String& uuid, String& ise_name, String& ise_uuid) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
void socket_start_helper(int client, uint32 context, const String& ic_uuid) {
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_start_helper ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void helper_detach_input_context(int client, uint32 context, const String& ic_uuid) {
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_stop_helper ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
void helper_process_imengine_event(int client, uint32 context, const String& ic_uuid, const Transaction& _nest_trans) {
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_send_helper_event ()\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
}
void process_helper_event(int client, uint32 context, String target_uuid, String active_uuid, Transaction& nest_trans) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
SCIM_DEBUG_MAIN(4) << "PanelAgent::socket_helper_send_imengine_event (" << client << ")\n";
Socket socket_client(client);
m_send_trans.put_data(nest_trans);
m_send_trans.write_to_socket(socket_client);
unlock();
-
}
void socket_helper_key_event(int client, uint32 context, int cmd, KeyEvent& key) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void commit_string(int client, uint32 target_context, const WideString& wstr) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
void socket_helper_get_surrounding_text(int client, uint32 context_id, uint32 maxlen_before, uint32 maxlen_after) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
void socket_helper_delete_surrounding_text(int client, uint32 context_id, uint32 offset, uint32 len) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
void socket_helper_get_selection(int client, uint32 context_id) {
SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
}
void socket_helper_set_selection(int client, uint32 context_id, uint32 start, uint32 end) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void show_preedit_string(int client, uint32 target_context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
}
void hide_preedit_string(int client, uint32 target_context) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
unlock();
}
- void update_preedit_string(int client, uint32 target_context, WideString wstr, AttributeList& attrs, uint32 caret) {
- LOGD ("client id:%d\n", client);
+ void update_preedit_string(int client, uint32 target_context, WideString preedit, WideString commit, AttributeList& attrs, uint32 caret) {
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
m_send_trans.put_data(target_context);
m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
- m_send_trans.put_data(wstr);
+ m_send_trans.put_data(preedit);
+ m_send_trans.put_data(commit);
m_send_trans.put_data(attrs);
m_send_trans.put_data(caret);
m_send_trans.write_to_socket(socket_client);
unlock();
-
}
void update_preedit_caret(int client, uint32 focused_context, uint32 caret) {
-
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
m_send_trans.put_data(caret);
m_send_trans.write_to_socket(socket_client);
unlock();
-
}
void helper_attach_input_context_and_update_screen(int client, std::vector < std::pair <uint32, String> >& helper_ic_index, uint32 current_screen) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
m_send_trans.clear();
}
void update_ise_input_context(int client, uint32 focused_context, uint32 type, uint32 value) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket client_socket(client);
m_send_trans.clear();
m_send_trans.put_data(type);
m_send_trans.put_data(value);
m_send_trans.write_to_socket(client_socket);
-
}
void send_private_command(int client, uint32 focused_context, String command) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
Socket socket_client(client);
lock();
m_send_trans.put_command(SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND);
m_send_trans.put_data(command);
m_send_trans.write_to_socket(socket_client);
+ }
+ void commit_content(int client, uint32 focused_context, String content, String description, String mime_types) {
+ LOGD ("client id:%d", client);
+
+ Socket socket_client(client);
+ lock();
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(focused_context);
+ m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_CONTENT);
+ m_send_trans.put_data(content);
+ m_send_trans.put_data(description);
+ m_send_trans.put_data(mime_types);
+ m_send_trans.write_to_socket(socket_client);
}
void helper_all_update_spot_location(int client, uint32 context_id, String uuid, int x, int y) {
- LOGD ("client id:%d\n", client);
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
Socket client_socket(client);
m_send_trans.write_to_socket(client_socket);
+ }
+
+ void helper_all_update_cursor_position(int client, uint32 context_id, String uuid, int cursor_pos) {
+ LOGD ("client id:%d", client);
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(context_id);
+ m_send_trans.put_data(uuid);
+ m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CURSOR_POSITION);
+ m_send_trans.put_data((uint32) cursor_pos);
+
+ Socket client_socket(client);
+ m_send_trans.write_to_socket(client_socket);
+ }
+
+ void helper_all_update_screen(int client, uint32 context_id, String uuid, int screen) {
+ LOGD ("client id:%d", client);
+
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+
+ /* FIXME: We presume that client and context are both less than 65536.
+ * Hopefully, it should be true in any UNIXs.
+ * So it's ok to combine client and context into one uint32. */
+ m_send_trans.put_data(context_id);
+ m_send_trans.put_data(uuid);
+ m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
+ m_send_trans.put_data((uint32) screen);
+
+ Socket client_socket(client);
+ m_send_trans.write_to_socket(client_socket);
+ }
+
+ void set_autocapital_type(int client, uint32 context, String uuid, int mode) {
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+
+ m_send_trans.put_data(context);
+ m_send_trans.put_data(uuid);
+ m_send_trans.put_command(SCIM_TRANS_CMD_SET_AUTOCAPITAL_TYPE);
+ m_send_trans.put_data((uint32) mode);
+
+ Socket client_socket(client);
+ m_send_trans.write_to_socket(client_socket);
+ }
+
+ void remote_update_preedit_string (int client, uint32 target_context, const WideString str, const WideString commit, const AttributeList &attrs, uint32 caret) {
+ Socket client_socket(client);
+ lock();
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(target_context);
+ m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING);
+ m_send_trans.put_data(str);
+ m_send_trans.put_data(commit);
+ m_send_trans.put_data(attrs);
+ m_send_trans.put_data(caret);
+ m_send_trans.write_to_socket(client_socket);
+ unlock();
+ }
+
+ void remote_send_key_event (int client, uint32 target_context, const KeyEvent &key) {
+ Socket client_socket(client);
+ lock();
+ m_send_trans.clear ();
+ m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data (target_context);
+ m_send_trans.put_command (SCIM_TRANS_CMD_PROCESS_KEY_EVENT);
+ m_send_trans.put_data (key);
+ m_send_trans.write_to_socket (client_socket);
+ unlock();
+ }
+
+ void remote_forward_key_event (int client, uint32 target_context, const KeyEvent &key) {
+ Socket client_socket(client);
+ lock();
+ m_send_trans.clear ();
+ m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data (target_context);
+ m_send_trans.put_command (SCIM_TRANS_CMD_FORWARD_KEY_EVENT);
+ m_send_trans.put_data (key);
+ m_send_trans.write_to_socket (client_socket);
+ unlock();
+ }
+
+ void remote_commit_string (int client, uint32 target_context, const WideString& wstr) {
+ LOGD ("client id:%d", client);
+ Socket socket_client(client);
+ lock();
+ m_send_trans.clear();
+ m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
+ m_send_trans.put_data(target_context);
+ m_send_trans.put_command(SCIM_TRANS_CMD_COMMIT_STRING);
+ m_send_trans.put_data(wstr);
+ m_send_trans.write_to_socket(socket_client);
+ unlock();
}
- void helper_all_update_cursor_position(int client, uint32 context_id, String uuid, int cursor_pos) {
- LOGD ("client id:%d\n", client);
+ void remote_delete_surrounding_text (int client, uint32 context_id, uint32 offset, uint32 len) {
+ SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
+ LOGD ("client id:%d", client);
+ Socket socket_client(client);
+ lock();
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
m_send_trans.put_data(context_id);
- m_send_trans.put_data(uuid);
- m_send_trans.put_command(ISM_TRANS_CMD_UPDATE_CURSOR_POSITION);
- m_send_trans.put_data((uint32) cursor_pos);
-
- Socket client_socket(client);
- m_send_trans.write_to_socket(client_socket);
-
+ m_send_trans.put_command(SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT);
+ m_send_trans.put_data(offset);
+ m_send_trans.put_data(len);
+ m_send_trans.write_to_socket(socket_client);
+ unlock();
}
- void helper_all_update_screen(int client, uint32 context_id, String uuid, int screen) {
- LOGD ("client id:%d\n", client);
+ void set_prediction_allow (int client, uint32 context, String uuid, int mode) {
+ LOGD ("client id:%d", client);
m_send_trans.clear();
m_send_trans.put_command(SCIM_TRANS_CMD_REPLY);
- /* FIXME: We presume that client and context are both less than 65536.
- * Hopefully, it should be true in any UNIXs.
- * So it's ok to combine client and context into one uint32. */
- m_send_trans.put_data(context_id);
+ m_send_trans.put_data(context);
m_send_trans.put_data(uuid);
- m_send_trans.put_command(SCIM_TRANS_CMD_UPDATE_SCREEN);
- m_send_trans.put_data((uint32) screen);
+ m_send_trans.put_command(ISM_TRANS_CMD_SET_PREDICTION_ALLOW);
+ m_send_trans.put_data((uint32) mode);
Socket client_socket(client);
m_send_trans.write_to_socket(client_socket);
-
}
-private:
-
- static void send_fail_reply (int client_id)
+ void send_fail_reply (int client)
{
- Socket client_socket (client_id);
+ SCIM_DEBUG_MAIN(4) << __FUNCTION__ << " (" << client << ")\n";
+ LOGD ("client id:%d", client);
+
+ Socket client_socket (client);
Transaction trans;
trans.clear ();
trans.put_command (SCIM_TRANS_CMD_REPLY);
trans.write_to_socket (client_socket);
}
+private:
+
bool filter_event(int fd) {
SCIM_DEBUG_MAIN(1) << "PanelAgent::filter_event ()\n";
return true;
if (nbytes < 0) {
- LOGW ("Error occurred when reading socket: %s\n", client.get_error_message().c_str());
+ LOGW ("Error occurred when reading socket: %s", client.get_error_message().c_str());
} else {
- LOGW ("Timeout when reading socket\n");
+ LOGW ("Timeout when reading socket");
}
return false;
EcoreSocketPanelAgent* _agent = (EcoreSocketPanelAgent*)data;
int fd = ecore_main_fd_handler_fd_get(fd_handler);
+ if (fd < 0)
+ return ECORE_CALLBACK_RENEW;
for (unsigned int i = 0; i < _agent->_read_handler_list.size(); i++) {
if (fd_handler == _agent->_read_handler_list [i]) {
if (!_agent->filter_event(fd)) {
std::cerr << "_panel_agent->filter_event () is failed!!!\n";
+ ::close (fd);
ecore_main_fd_handler_del(fd_handler);
- ISF_SAVE_LOG("_panel_agent->filter_event (fd=%d) is failed!!!\n", fd);
+ ISF_SAVE_LOG("_panel_agent->filter_event (fd=%d) is failed!!!", fd);
}
return ECORE_CALLBACK_RENEW;
std::cerr << "panel_agent_handler () has received exception event!!!\n";
_agent->filter_exception_event(fd);
+ ::close (fd);
ecore_main_fd_handler_del(fd_handler);
- ISF_SAVE_LOG("Received exception event (fd=%d)!!!\n", fd);
+ ISF_SAVE_LOG("Received exception event (fd=%d)!!!", fd);
return ECORE_CALLBACK_RENEW;
}
/* If the connection is closed then close this client. */
if (!socket_check_client_connection(client)) {
- LOGW ("check client connection failed\n");
+ LOGW ("check client connection failed");
socket_close_connection(server, client);
return;
}
if (!m_recv_trans.read_from_socket(client, m_socket_timeout) ||
!m_recv_trans.get_command(cmd) || cmd != SCIM_TRANS_CMD_REQUEST ||
!m_recv_trans.get_data(key) || key != (uint32) client_info.key) {
- LOGW ("cmd:%d key:%d client info key: %d\n", cmd, key, client_info.key);
+ LOGW ("cmd:%d key:%d client info key: %d", cmd, key, client_info.key);
return;
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == ISM_TRANS_CMD_REGISTER_PANEL_CLIENT) {
uint32 id = 0;
if (m_recv_trans.get_data(id)) {
m_info_manager->register_panel_client(client_id, id);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
}
-
else if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_INPUT_CONTEXT) {
if (m_recv_trans.get_data(uuid)) {
m_info_manager->register_input_context(client_id, context, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
}
-
else if (cmd == SCIM_TRANS_CMD_PANEL_REMOVE_INPUT_CONTEXT) {
m_info_manager->remove_input_context(client_id, context);
continue;
}
-
else if (cmd == SCIM_TRANS_CMD_PANEL_RESET_INPUT_CONTEXT) {
m_info_manager->socket_reset_input_context(client_id, context);
continue;
}
-
else if (cmd == SCIM_TRANS_CMD_FOCUS_IN) {
SCIM_DEBUG_MAIN(4) << " SCIM_TRANS_CMD_FOCUS_IN (" << "client:" << client_id << " context:" << context << ")\n";
if (m_recv_trans.get_data(uuid)) {
m_info_manager->focus_in(client_id, context, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
}
-
else if (cmd == ISM_TRANS_CMD_TURN_ON_LOG) {
uint32 isOn;
if (m_recv_trans.get_data(isOn)) {
m_info_manager->socket_turn_on_log(isOn);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
}
-
else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
m_info_manager->show_isf_panel(client_id);
continue;
if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context) && m_recv_trans.get_data(&data, len)) {
ret = true;
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
trans.put_data(ret);
trans.write_to_socket(client_socket);
- if (data != NULL)
- delete[] data;
-
if (ret)
m_info_manager->show_ise_panel(client_id, client, context, data, len);
+ if (data != NULL)
+ delete[] data;
+
continue;
} else if (cmd == ISM_TRANS_CMD_HIDE_ISE_PANEL) {
uint32 client;
if (m_recv_trans.get_data(client) && m_recv_trans.get_data(context)) {
m_info_manager->hide_ise_panel(client_id, client, context);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
} else if (cmd == ISM_TRANS_CMD_GET_ISE_LANGUAGE_LOCALE) {
size_t len;
char* data = NULL;
- m_info_manager->get_ise_language_locale(client_id, data, len);
+ m_info_manager->get_ise_language_locale(client_id, &data, len);
Transaction trans;
trans.clear();
trans.put_command(SCIM_TRANS_CMD_REPLY);
if (m_recv_trans.get_data(language)) {
m_info_manager->set_ise_language(client_id, language);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(&imdata, len)) {
m_info_manager->set_ise_imdata(client_id, imdata, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
if (NULL != imdata)
if (m_recv_trans.get_data(type)) {
m_info_manager->set_ise_return_key_type(client_id, type);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(disabled)) {
m_info_manager->set_ise_return_key_disable(client_id, disabled);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
} else if (cmd == ISM_TRANS_CMD_GET_RETURN_KEY_DISABLE) {
uint32 disabled;
bool ret = true;
- m_info_manager->get_ise_return_key_disable(client_id, disabled);
+ ret = m_info_manager->get_ise_return_key_disable(client_id, disabled);
Transaction trans;
Socket client_socket(client_id);
if (m_recv_trans.get_data(layout)) {
m_info_manager->set_ise_layout(client_id, layout);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(mode)) {
m_info_manager->set_ise_caps_mode(client_id, mode);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(mode)) {
m_info_manager->set_keyboard_mode(client_id, mode);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
ret = true;
m_info_manager->process_key_event(key, result);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
if (m_recv_trans.get_data(input_mode)) {
m_info_manager->set_ise_input_mode(client_id, input_mode);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(input_hint)) {
m_info_manager->set_ise_input_hint(client_id, input_hint);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(bidi_direction)) {
m_info_manager->update_ise_bidi_direction(client_id, bidi_direction);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
} else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
m_info_manager->show_ise_option_window(client_id);
continue;
+ } else if (cmd == ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW) {
+ m_info_manager->resume_ise_option_window(client_id);
+ continue;
}
//FIXME
if (m_recv_trans.get_data(uuid) && uuid.length()) {
m_info_manager->socket_start_helper(client_id, context, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
uuid.length() && m_nest_trans.valid()) {
m_info_manager->socket_send_helper_event(client_id, context, uuid, m_nest_trans);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(uuid) && uuid.length()) {
m_info_manager->socket_stop_helper(client_id, context, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
continue;
if (m_recv_trans.get_data(num))
m_info_manager->socket_update_screen(client_id, num);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_SPOT_LOCATION) {
uint32 x, y, top_y;
if (m_recv_trans.get_data(x) && m_recv_trans.get_data(y) && m_recv_trans.get_data(top_y)) {
m_info_manager->socket_update_spot_location(x, y, top_y);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_CURSOR_POSITION) {
uint32 cursor_pos;
if (m_recv_trans.get_data(cursor_pos)) {
m_info_manager->socket_update_cursor_position(cursor_pos);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_SURROUNDING_TEXT) {
String text;
if (m_recv_trans.get_data(text) && m_recv_trans.get_data(cursor)) {
m_info_manager->socket_update_surrounding_text(text, cursor);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_SELECTION) {
String text;
if (m_recv_trans.get_data(text)) {
m_info_manager->socket_update_selection(text);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE)
m_info_manager->expand_candidate();
if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
m_info_manager->socket_set_candidate_ui(portrait_line, mode);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_PANEL_UPDATE_FACTORY_INFO) {
PanelFactoryInfo info;
m_recv_trans.get_data(info.lang) && m_recv_trans.get_data(info.icon)) {
m_info_manager->socket_update_factory_info(info);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING)
m_info_manager->socket_show_preedit_string();
if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs) && m_recv_trans.get_data(caret))
m_info_manager->socket_update_preedit_string(str, attrs, caret);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
uint32 caret;
if (m_recv_trans.get_data(caret))
m_info_manager->socket_update_preedit_caret(caret);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
String str;
AttributeList attrs;
if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
m_info_manager->socket_update_aux_string(str, attrs);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
+ } else if (cmd == ISM_TRANS_CMD_RECAPTURE_STRING) {
+ uint32 target_ic;
+ String target_uuid;
+ uint32 offset;
+ uint32 len;
+ WideString preedit;
+ WideString commit;
+ AttributeList attrs;
+
+ if (m_recv_trans.get_data(target_ic) &&
+ m_recv_trans.get_data(target_uuid) &&
+ m_recv_trans.get_data(offset) &&
+ m_recv_trans.get_data(len) &&
+ m_recv_trans.get_data(preedit) &&
+ m_recv_trans.get_data(commit) &&
+ m_recv_trans.get_data(attrs)) {
+ m_info_manager->socket_helper_recapture_string(client_id, target_ic, target_uuid, offset, len, preedit, commit, attrs);
+ } else {
+ LOGW ("wrong format of transaction");
+ }
} else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
CommonLookupTable _isf_candidate_table;
if (m_recv_trans.get_data(_isf_candidate_table))
m_info_manager->socket_update_lookup_table(_isf_candidate_table);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
CommonLookupTable table;
if (m_recv_trans.get_data(table))
m_info_manager->socket_update_associate_table(table);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
PropertyList properties;
if (m_recv_trans.get_data(properties))
m_info_manager->socket_register_properties(properties);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
Property property;
if (m_recv_trans.get_data(property))
m_info_manager->socket_update_property(property);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_HELP) {
String help;
if (m_recv_trans.get_data(help))
m_info_manager->socket_show_help(help);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_PANEL_SHOW_FACTORY_MENU) {
PanelFactoryInfo info;
std::vector <PanelFactoryInfo> vec;
} else if (cmd == SCIM_TRANS_CMD_FOCUS_OUT) {
m_info_manager->focus_out(client_id, context);
} else {
- LOGW ("unknow cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == ISM_TRANS_CMD_GET_PANEL_CLIENT_ID) {
Socket client_socket(client_id);
trans.write_to_socket(client_socket);
continue;
} else {
- LOGW ("unknow cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
-
if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_HELPER) {
HelperInfo info;
m_info_manager->socket_helper_register_helper(client_id, info);
}
} else {
- LOGW ("unknow cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
-
if (cmd == SCIM_TRANS_CMD_PANEL_REGISTER_ACTIVE_HELPER) {
HelperInfo info;
info.uuid.length()) {
m_info_manager->socket_helper_register_helper_passive(client_id, info);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
+
+ /* Check whether application already requested the focus_in and showing input_panel
+ * If so, Input FW request focus_in and show input_panel again to helper IME.
+ * Because Helper IME couldn't receive these events during the launch.
+ */
+ m_info_manager->reshow_input_panel ();
} else if (cmd == SCIM_TRANS_CMD_COMMIT_STRING) {
uint32 target_ic;
String target_uuid;
wstr.length()) {
m_info_manager->socket_helper_commit_string(client_id, target_ic, target_uuid, wstr);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SHOW_PREEDIT_STRING) {
uint32 target_ic;
if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
m_info_manager->socket_helper_show_preedit_string(client_id, target_ic, target_uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SHOW_AUX_STRING) {
m_info_manager->socket_show_aux_string();
if (m_recv_trans.get_data(target_ic) && m_recv_trans.get_data(target_uuid)) {
m_info_manager->socket_helper_hide_preedit_string(client_id, target_ic, target_uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_HIDE_AUX_STRING) {
m_info_manager->socket_hide_aux_string();
} else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_STRING) {
uint32 target_ic;
String target_uuid;
- WideString wstr;
+ WideString preedit;
+ WideString commit;
AttributeList attrs;
uint32 caret;
if (m_recv_trans.get_data(target_ic) &&
m_recv_trans.get_data(target_uuid) &&
- m_recv_trans.get_data(wstr) &&
+ m_recv_trans.get_data(preedit) &&
+ m_recv_trans.get_data(commit) &&
m_recv_trans.get_data(attrs) &&
m_recv_trans.get_data(caret)) {
- m_info_manager->socket_helper_update_preedit_string(client_id, target_ic, target_uuid, wstr, attrs, caret);
+ m_info_manager->socket_helper_update_preedit_string(client_id, target_ic, target_uuid, preedit, commit, attrs, caret);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_UPDATE_PREEDIT_CARET) {
uint32 caret;
if (m_recv_trans.get_data(caret)) {
m_info_manager->socket_helper_update_preedit_caret(client_id, caret);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_UPDATE_AUX_STRING) {
String str;
if (m_recv_trans.get_data(str) && m_recv_trans.get_data(attrs))
m_info_manager->socket_update_aux_string(str, attrs);
else
- LOGW ("wrong format of transaction\n");
-
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_LOOKUP_TABLE) {
CommonLookupTable _isf_candidate_table;
if (m_recv_trans.get_data(_isf_candidate_table)) {
m_info_manager->socket_update_lookup_table(_isf_candidate_table);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_ASSOCIATE_TABLE) {
CommonLookupTable _isf_candidate_table;
if (m_recv_trans.get_data(_isf_candidate_table)) {
m_info_manager->socket_update_associate_table(_isf_candidate_table);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_PROCESS_KEY_EVENT ||
cmd == SCIM_TRANS_CMD_PANEL_SEND_KEY_EVENT) {
!key.empty()) {
m_info_manager->socket_helper_send_key_event(client_id, target_ic, target_uuid, key);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_FORWARD_KEY_EVENT) {
uint32 target_ic;
!key.empty()) {
m_info_manager->socket_helper_forward_key_event(client_id, target_ic, target_uuid, key);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_PANEL_SEND_IMENGINE_EVENT) {
uint32 target_ic;
m_nest_trans.valid()) {
m_info_manager->socket_helper_send_imengine_event(client_id, target_ic, target_uuid, m_nest_trans);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_REGISTER_PROPERTIES) {
PropertyList properties;
if (m_recv_trans.get_data(properties))
m_info_manager->socket_helper_register_properties(client_id, properties);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_UPDATE_PROPERTY) {
Property property;
if (m_recv_trans.get_data(property))
m_info_manager->socket_helper_update_property(client_id, property);
else
- LOGW ("wrong format of transaction\n");
-#if 0 //only receives reload message by socketconfig
- } else if (cmd == SCIM_TRANS_CMD_RELOAD_CONFIG) {
- m_info_manager->reload_config();
-#endif
+ LOGW ("wrong format of transaction");
} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_INPUT_CONTEXT) {
uint32 type;
uint32 value;
if (m_recv_trans.get_data(type) && m_recv_trans.get_data(value)) {
m_info_manager->socket_helper_update_input_context(client_id, type, value);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
+ }
+ } else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_LANGUAGE_LOCALE) {
+ String locale;
+
+ char* data = NULL;
+ size_t len;
+ if (m_recv_trans.get_data(&data, len)) {
+ if (data && len) {
+ locale = String(data, len);
+ m_info_manager->socket_helper_update_language_locale(client_id, locale);
+ } else {
+ LOGW("wrong format of transaction : %p %d", data, len);
+ }
+ } else {
+ LOGW("wrong format of transaction");
}
+
+ if (data != NULL)
+ delete [] data;
} else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE_LIST) {
String uuid;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_get_keyboard_ise_list(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_UI) {
uint32 portrait_line, mode;
if (m_recv_trans.get_data(portrait_line) && m_recv_trans.get_data(mode))
m_info_manager->socket_set_candidate_ui(portrait_line, mode);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_UI) {
String uuid;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_get_candidate_ui(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_SET_CANDIDATE_POSITION) {
uint32 left, top;
if (m_recv_trans.get_data(left) && m_recv_trans.get_data(top))
m_info_manager->socket_set_candidate_position(left, top);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == ISM_TRANS_CMD_HIDE_CANDIDATE) {
m_info_manager->socket_hide_candidate();
} else if (cmd == ISM_TRANS_CMD_GET_CANDIDATE_GEOMETRY) {
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_get_candidate_geometry(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_PANEL_RESET_KEYBOARD_ISE) {
m_info_manager->reset_keyboard_ise();
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_set_keyboard_ise(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_GET_KEYBOARD_ISE) {
String uuid;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_get_keyboard_ise(uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_GEOMETRY) {
uint32 x, y, width, height;
m_recv_trans.get_data(width) && m_recv_trans.get_data(height)) {
m_info_manager->socket_helper_update_ise_geometry(client_id, x, y, width, height);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == ISM_TRANS_CMD_EXPAND_CANDIDATE) {
m_info_manager->expand_candidate();
if (m_recv_trans.get_data(index))
m_info_manager->socket_helper_select_candidate(index);
else
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
} else if (cmd == SCIM_TRANS_CMD_GET_SURROUNDING_TEXT) {
String uuid;
uint32 maxlen_before;
m_recv_trans.get_data(maxlen_after)) {
m_info_manager->socket_helper_get_surrounding_text(client_id, uuid, maxlen_before, maxlen_after);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
uint32 offset;
if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
m_info_manager->socket_helper_delete_surrounding_text(client_id, offset, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_GET_SELECTION) {
String uuid;
if (m_recv_trans.get_data(uuid)) {
m_info_manager->socket_helper_get_selection(client_id, uuid);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SET_SELECTION) {
uint32 start;
if (m_recv_trans.get_data(start) && m_recv_trans.get_data(end)) {
m_info_manager->socket_helper_set_selection(client_id, start, end);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
} else if (cmd == SCIM_TRANS_CMD_SEND_PRIVATE_COMMAND) {
String command;
if (m_recv_trans.get_data(command)) {
m_info_manager->socket_helper_send_private_command(client_id, command);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
//FIXME: useless
//} else if (cmd == ISM_TRANS_CMD_UPDATE_ISE_EXIT) {
// m_info_manager->UPDATE_ISE_EXIT(client_id);
+ } else if (cmd == SCIM_TRANS_CMD_COMMIT_CONTENT) {
+ String content;
+ String description;
+ String mime_types;
+
+ if (m_recv_trans.get_data(content) &&
+ m_recv_trans.get_data(description) &&
+ m_recv_trans.get_data(mime_types)) {
+ m_info_manager->socket_helper_commit_content(client_id, content, description, mime_types);
+ } else {
+ LOGW ("wrong format of transaction");
+ }
+ } else if (cmd == ISM_TRANS_CMD_PROCESS_KEY_EVENT_DONE) {
+ KeyEvent key;
+ uint32 ret;
+ uint32 serial;
+
+ if (m_recv_trans.get_data(key) && m_recv_trans.get_data(ret) && m_recv_trans.get_data(serial)) {
+ m_info_manager->process_key_event_done(key, ret, serial);
+ } else {
+ LOGW ("wrong format of transaction");
+ }
+ } else if (cmd == ISM_TRANS_CMD_REQUEST_ISE_HIDE) {
+ m_info_manager->request_ise_hide();
+ } else if (cmd == ISM_TRANS_CMD_RECAPTURE_STRING) {
+ uint32 target_ic;
+ String target_uuid;
+ uint32 offset;
+ uint32 len;
+ WideString preedit;
+ WideString commit;
+ AttributeList attrs;
+
+ if (m_recv_trans.get_data(target_ic) &&
+ m_recv_trans.get_data(target_uuid) &&
+ m_recv_trans.get_data(offset) &&
+ m_recv_trans.get_data(len) &&
+ m_recv_trans.get_data(preedit) &&
+ m_recv_trans.get_data(commit) &&
+ m_recv_trans.get_data(attrs)) {
+ m_info_manager->socket_helper_recapture_string(client_id, target_ic, target_uuid, offset, len, preedit, commit, attrs);
+ } else {
+ LOGW ("wrong format of transaction");
+ }
} else {
- LOGW ("unknow cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
socket_transaction_start();
while (m_recv_trans.get_command(cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
+ LOGD ("PanelAgent::cmd = %d", cmd);
if (cmd == ISM_TRANS_CMD_GET_ACTIVE_ISE) {
-
if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
String default_uuid;
m_info_manager->get_active_ise(client_id, default_uuid);
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to get active ise\n");
+ LOGW ("Access denied to get active ise");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SET_ACTIVE_ISE_BY_UUID) {
if (m_recv_trans.get_data(&buf, len)) {
ret = m_info_manager->set_active_ise_by_uuid(client_id, buf, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
delete[] buf;
}
else {
- LOGW ("Access denied to set active ise\n");
+ LOGW ("Access denied to set active ise");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SET_INITIAL_ISE_BY_UUID) {
if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
char* buf = NULL;
size_t len;
- bool ret = true;
//FIXME
//ret need be checked
if (m_recv_trans.get_data(&buf, len)) {
m_info_manager->set_initial_ise_by_uuid(client_id, buf, len);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
trans.clear();
trans.put_command(SCIM_TRANS_CMD_REPLY);
- trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
+ trans.put_command(SCIM_TRANS_CMD_OK);
trans.write_to_socket(client_socket);
if (NULL != buf)
delete[] buf;
}
else {
- LOGW ("Access denied to set initial ise\n");
+ LOGW ("Access denied to set initial ise");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_GET_ISE_LIST) {
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to get ise list\n");
+ LOGW ("Access denied to get ise list");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_GET_ALL_HELPER_ISE_INFO) {
} while (0);
}
else {
- LOGW ("Access denied to get all helper ise info\n");
+ LOGW ("Access denied to get all helper ise info");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SET_ENABLE_HELPER_ISE_INFO) {
m_info_manager->set_enable_helper_ise_info(client_id, appid, is_enabled);
ret = true;
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to set enable helper ise info\n");
+ LOGW ("Access denied to set enable helper ise info");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_GET_ISE_INFORMATION) {
if (m_recv_trans.get_data(strUuid)) {
m_info_manager->get_ise_information(client_id, strUuid, strName, strLanguage, nType, nOption, strModuleName);
} else {
- LOGW ("wrong format of transaction\n");
+ LOGW ("wrong format of transaction");
}
Transaction trans;
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to get ise information\n");
+ LOGW ("Access denied to get ise information");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_RESET_ISE_OPTION) {
m_info_manager->reset_ise_option(client_id);
}
else {
- LOGW ("Access denied to reset ise option\n");
+ LOGW ("Access denied to reset ise option");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_RESET_DEFAULT_ISE) {
m_info_manager->reset_default_ise(client_id);
}
else {
- LOGW ("Access denied to reset default ise\n");
+ LOGW ("Access denied to reset default ise");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SHOW_ISF_CONTROL) {
m_info_manager->show_isf_panel(client_id);
}
else {
- LOGW ("Access denied to show isf control\n");
+ LOGW ("Access denied to show isf control");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SHOW_ISE_OPTION_WINDOW) {
m_info_manager->show_ise_option_window(client_id);
}
else {
- LOGW ("Access denied to show ise option window\n");
+ LOGW ("Access denied to show ise option window");
+ send_fail_reply (client_id);
+ }
+ } else if (cmd == ISM_TRANS_CMD_RESUME_ISE_OPTION_WINDOW) {
+ if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
+ m_info_manager->resume_ise_option_window(client_id);
+ }
+ else {
+ LOGW ("Access denied to resume ise option window");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_LIST) {
m_info_manager->show_helper_ise_list(client_id);
}
else {
- LOGW ("Access denied to show helper ise list\n");
+ LOGW ("Access denied to show helper ise list");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_SHOW_HELPER_ISE_SELECTOR) {
m_info_manager->show_helper_ise_selector(client_id);
}
else {
- LOGW ("Access denied to show helper ise selector\n");
+ LOGW ("Access denied to show helper ise selector");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_IS_HELPER_ISE_ENABLED) {
if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE)) {
String strAppid;
uint32 nEnabled = 0;
- bool ret = true;
- //FIXME
- //ret need be checked
+
m_info_manager->is_helper_ise_enabled(client_id, strAppid, nEnabled);
Transaction trans;
Socket client_socket(client_id);
trans.clear();
trans.put_command(SCIM_TRANS_CMD_REPLY);
-
- if (ret) {
- trans.put_command(SCIM_TRANS_CMD_OK);
- trans.put_data(static_cast<uint32>(nEnabled));
- } else {
- trans.put_command(SCIM_TRANS_CMD_FAIL);
- }
-
+ trans.put_command(SCIM_TRANS_CMD_OK);
+ trans.put_data(static_cast<uint32>(nEnabled));
trans.write_to_socket(client_socket);
}
else {
- LOGW ("Access denied to check helper ise enabled\n");
+ LOGW ("Access denied to check helper ise enabled");
send_fail_reply (client_id);
}
} else if (cmd == ISM_TRANS_CMD_GET_RECENT_ISE_GEOMETRY) {
trans.put_command(SCIM_TRANS_CMD_OK);
trans.write_to_socket(client_socket);
m_info_manager->hide_helper_ise ();
+ } else if (cmd == ISM_TRANS_CMD_LAUNCH_ISE) {
+ m_info_manager->launch_helper_ise();
+
+ Transaction trans;
+ Socket client_socket(client_id);
+
+ trans.clear();
+ trans.put_command(SCIM_TRANS_CMD_REPLY);
+ trans.put_command(SCIM_TRANS_CMD_OK);
+ trans.write_to_socket(client_socket);
} else {
- LOGW ("unknow cmd: %d\n", cmd);
+ LOGW ("unknown cmd: %d", cmd);
}
}
socket_transaction_end();
- } else if (client_info.type == CONFIG_CLIENT) {
- socket_transaction_start ();
- while (m_recv_trans.get_command (cmd)) {
- LOGD ("PanelAgent::cmd = %d\n", cmd);
-
- if (cmd == SCIM_TRANS_CMD_FLUSH_CONFIG) {
- if (m_config_readonly) {
- LOGW ("sorry config readonly");
- continue;
- }
- if (_config.null ()) {
- LOGW ("config is not ready");
- continue;
- }
- SCIM_DEBUG_FRONTEND (2) << " socket_flush_config.\n";
-
- _config->flush ();
-
- } else if (cmd == SCIM_TRANS_CMD_ERASE_CONFIG) {
-
- String key;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_erase_config.\n";
-
- if (m_recv_trans.get_data (key)) {
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- if (m_config_readonly) {
- LOGW ("sorry config readonly");
- continue;
- }
- _config->erase (key);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
- } else if (cmd == SCIM_TRANS_CMD_RELOAD_CONFIG) {
-
- SCIM_DEBUG_FRONTEND (2) << " socket_reload_config.\n";
- Socket client_socket (client_id);
- m_send_trans.clear ();
- m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
-
- if (_config.null ()) {
- LOGW ("config is not ready");
- m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- } else {
- static timeval last_timestamp = {0, 0};
-
- timeval timestamp;
-
- gettimeofday (×tamp, 0);
-
- if (timestamp.tv_sec >= last_timestamp.tv_sec)
- _config->reload ();
-
- gettimeofday (&last_timestamp, 0);
- m_send_trans.put_command (SCIM_TRANS_CMD_OK);
- }
-
- m_send_trans.write_to_socket (client_socket);
-
- } else if (cmd == SCIM_TRANS_CMD_GET_CONFIG_STRING) {
- String key;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_get_config_string.\n";
-
- if (m_recv_trans.get_data (key)) {
- String value;
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- Socket client_socket (client_id);
- m_send_trans.clear ();
- m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
- if (!_config.null () && _config->read (key, &value)) {
- m_send_trans.put_data (value);
- m_send_trans.put_command (SCIM_TRANS_CMD_OK);
- } else {
- m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s faided\n", key.c_str());
- }
- m_send_trans.write_to_socket (client_socket);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
- } else if (cmd == SCIM_TRANS_CMD_SET_CONFIG_STRING) {
- String key;
- String value;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_set_config_string.\n";
-
- if (m_recv_trans.get_data (key) &&
- m_recv_trans.get_data (value)) {
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- SCIM_DEBUG_FRONTEND (3) << " Value (" << value << ").\n";
- if (m_config_readonly) {
- LOGW ("sorry config readonly");
- continue;
- }
- if (_config.null ()) {
- LOGW ("config is not ready");
- continue;
- }
- _config->write (key, value);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
- } else if (cmd == SCIM_TRANS_CMD_GET_CONFIG_INT) {
- if (_config.null ()) {
- LOGW ("config not ready");
- break;
- }
-
- String key;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_get_config_int.\n";
-
- if (m_recv_trans.get_data (key)) {
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
-
- int value;
- Socket client_socket (client_id);
- m_send_trans.clear ();
- m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
- if (_config->read (key, &value)) {
- m_send_trans.put_data ((uint32) value);
- m_send_trans.put_command (SCIM_TRANS_CMD_OK);
- } else {
- m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s faided\n", key.c_str());
- }
- m_send_trans.write_to_socket (client_socket);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
-
- } else if (cmd == SCIM_TRANS_CMD_SET_CONFIG_INT) {
-
- String key;
- uint32 value;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_set_config_int.\n";
-
- if (m_recv_trans.get_data (key) &&
- m_recv_trans.get_data (value)) {
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- SCIM_DEBUG_FRONTEND (3) << " Value (" << value << ").\n";
- if (m_config_readonly) {
- LOGW ("sorry config readonly");
- continue;
- }
- if (_config.null ()) {
- LOGW ("config is not ready");
- continue;
- }
- _config->write (key, (int) value);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
-
- } else if (cmd == SCIM_TRANS_CMD_GET_CONFIG_BOOL) {
-
- String key;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_get_config_bool.\n";
-
- if (m_recv_trans.get_data (key)) {
- bool value;
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- Socket client_socket (client_id);
- m_send_trans.clear ();
- m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
-
- if (!_config.null () && _config->read (key, &value)) {
- m_send_trans.put_data ((uint32) value);
- m_send_trans.put_command (SCIM_TRANS_CMD_OK);
- } else {
- m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s faided\n", key.c_str());
- }
- m_send_trans.write_to_socket (client_socket);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
-
- } else if (cmd == SCIM_TRANS_CMD_SET_CONFIG_BOOL) {
-
- String key;
- uint32 value;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_set_config_bool.\n";
-
- if (m_recv_trans.get_data (key) &&
- m_recv_trans.get_data (value)) {
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- SCIM_DEBUG_FRONTEND (3) << " Value (" << value << ").\n";
- if (m_config_readonly) {
- LOGW ("sorry config readonly");
- continue;
- }
- if (_config.null ()) {
- LOGW ("config is not ready");
- continue;
- }
- _config->write (key, (bool) value);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
-
- } else if (cmd == SCIM_TRANS_CMD_GET_CONFIG_DOUBLE) {
- String key;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_get_config_double.\n";
-
- if (m_recv_trans.get_data (key)) {
- double value;
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- Socket client_socket (client_id);
- m_send_trans.clear ();
- m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
-
- if (!_config.null () && _config->read (key, &value)) {
- char buf [80];
- snprintf (buf, 79, "%lE", value);
- m_send_trans.put_data (String (buf));
- m_send_trans.put_command (SCIM_TRANS_CMD_OK);
- } else {
- m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s faided\n", key.c_str());
- }
- m_send_trans.write_to_socket (client_socket);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
-
- } else if (cmd == SCIM_TRANS_CMD_SET_CONFIG_DOUBLE) {
-
- String key;
- String str;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_set_config_double.\n";
-
- if (m_recv_trans.get_data (key) &&
- m_recv_trans.get_data (str)) {
- double value;
- sscanf (str.c_str (), "%lE", &value);
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- SCIM_DEBUG_FRONTEND (3) << " Value (" << value << ").\n";
- if (m_config_readonly) {
- LOGW ("sorry config readonly");
- continue;
- }
- if (_config.null ()) {
- LOGW ("config is not ready");
- continue;
- }
- _config->write (key, value);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
-
- } else if (cmd == SCIM_TRANS_CMD_GET_CONFIG_VECTOR_STRING) {
-
- String key;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_get_config_vector_string.\n";
-
- if (m_recv_trans.get_data (key)) {
- std::vector <String> vec;
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- Socket client_socket (client_id);
- m_send_trans.clear ();
- m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
-
- if (!_config.null () && _config->read (key, &vec)) {
- m_send_trans.put_data (vec);
- m_send_trans.put_command (SCIM_TRANS_CMD_OK);
- } else {
- m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s faided\n", key.c_str());
- }
- m_send_trans.write_to_socket (client_socket);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
-
- } else if (cmd == SCIM_TRANS_CMD_SET_CONFIG_VECTOR_STRING) {
-
- String key;
- std::vector<String> vec;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_set_config_vector_string.\n";
-
- if (m_recv_trans.get_data (key) &&
- m_recv_trans.get_data (vec)) {
+ } else if (client_info.type == REMOTEINPUT_ACT_CLIENT) {
+ socket_transaction_start();
+ while (m_recv_trans.get_command(cmd)) {
+ if (cmd == ISM_REMOTE_TRANS_CMD_SEND_INPUT_MESSAGE) {
+ char* buf = NULL;
+ size_t len;
+ bool ret = false;
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- if (m_config_readonly) {
- LOGW ("sorry config readonly");
- continue;
- }
- if (_config.null ()) {
- LOGW ("config is not ready");
- continue;
- }
- _config->write (key, vec);
+ if (m_recv_trans.get_data(&buf, len)) {
+ ret = m_info_manager->remoteinput_send_input_message(client_id, buf, len);
} else {
- LOGW ("wrong format of transaction\n");
- break;
+ LOGW ("wrong format of transaction");
}
- } else if (cmd == SCIM_TRANS_CMD_GET_CONFIG_VECTOR_INT) {
-
- String key;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_get_config_vector_int.\n";
+ Transaction trans;
+ Socket client_socket(client_id);
- if (m_recv_trans.get_data (key)) {
- std::vector <int> vec;
+ trans.clear();
+ trans.put_command(SCIM_TRANS_CMD_REPLY);
+ trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
+ trans.write_to_socket(client_socket);
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
- Socket client_socket (client_id);
- m_send_trans.clear ();
- m_send_trans.put_command (SCIM_TRANS_CMD_REPLY);
+ if (NULL != buf)
+ delete[] buf;
+ } else if (cmd == ISM_REMOTE_TRANS_CMD_CHECK_PRIVILEGE) {
+ bool ret = false;
- if (!_config.null () && _config->read (key, &vec)) {
- std::vector <uint32> reply;
+ if (m_info_manager->check_privilege_by_sockfd(client_id, IMEMANAGER_PRIVILEGE))
+ ret = true;
- for (uint32 i=0; i<vec.size (); ++i)
- reply.push_back ((uint32) vec[i]);
+ Transaction trans;
+ Socket client_socket(client_id);
- m_send_trans.put_data (reply);
- m_send_trans.put_command (SCIM_TRANS_CMD_OK);
- } else {
- m_send_trans.put_command (SCIM_TRANS_CMD_FAIL);
- LOGW ("read config key = %s faided\n", key.c_str());
- }
- m_send_trans.write_to_socket (client_socket);
+ trans.clear();
+ trans.put_command(SCIM_TRANS_CMD_REPLY);
+ trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
+ trans.write_to_socket(client_socket);
+ } else if (cmd == ISM_REMOTE_TRANS_CMD_DELETE_SURROUNDING_TEXT) {
+ uint32 offset;
+ uint32 len;
+ bool ret = false;
+ if (m_recv_trans.get_data(offset) && m_recv_trans.get_data(len)) {
+ ret = m_info_manager->remoteinput_delete_surrounding_text(offset, len);
} else {
- LOGW ("wrong format of transaction\n");
- break;
+ LOGW ("wrong format of transaction");
}
- } else if (cmd == SCIM_TRANS_CMD_SET_CONFIG_VECTOR_INT) {
-
- String key;
- std::vector<uint32> vec;
-
- SCIM_DEBUG_FRONTEND (2) << " socket_set_config_vector_int.\n";
-
- if (m_recv_trans.get_data (key) &&
- m_recv_trans.get_data (vec)) {
- if (m_config_readonly) {
- LOGW ("sorry config readonly");
- continue;
- }
- if (_config.null ()) {
- LOGW ("config is not ready");
- continue;
- }
- std::vector<int> req;
-
- SCIM_DEBUG_FRONTEND (3) << " Key (" << key << ").\n";
-
- for (uint32 i=0; i<vec.size (); ++i)
- req.push_back ((int) vec[i]);
-
- _config->write (key, req);
- } else {
- LOGW ("wrong format of transaction\n");
- break;
- }
+ Transaction trans;
+ Socket client_socket(client_id);
+ trans.clear();
+ trans.put_command(SCIM_TRANS_CMD_REPLY);
+ trans.put_command(ret ? SCIM_TRANS_CMD_OK : SCIM_TRANS_CMD_FAIL);
+ trans.write_to_socket(client_socket);
+ } else {
+ LOGW ("unknown cmd: %d", cmd);
}
}
void socket_exception_callback(SocketServer* server,
const Socket& client) {
SCIM_DEBUG_MAIN(2) << "PanelAgent::socket_exception_callback (" << client.get_id() << ")\n";
- LOGD ("client id:%d\n", client.get_id());
+ LOGD ("client id:%d", client.get_id());
socket_close_connection(server, client);
}
bool socket_open_connection(SocketServer* server,
const Socket& client) {
SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_open_connection (" << client.get_id() << ")\n";
- LOGD ("client id:%d\n", client.get_id());
+ LOGD ("client id:%d", client.get_id());
uint32 key;
String type = scim_socket_accept_connection(key,
String("Panel"),
- String("FrontEnd,FrontEnd_Active,Helper,Helper_Active,IMControl_Active,IMControl_Passive,SocketConfig"),
+ String("FrontEnd,FrontEnd_Active,Helper,Helper_Active,IMControl_Active,IMControl_Passive,RemoteInput_Active,RemoteInput_Passive,SocketConfig"),
client,
m_socket_timeout);
((type == "Helper") ? HELPER_CLIENT :
((type == "Helper_Active") ? HELPER_ACT_CLIENT :
((type == "IMControl_Active") ? IMCONTROL_ACT_CLIENT :
- ((type == "IMControl_Passive") ? IMCONTROL_CLIENT : CONFIG_CLIENT))))));
+ ((type == "IMControl_Passive") ? IMCONTROL_CLIENT :
+ ((type == "RemoteInput_Active") ? REMOTEINPUT_ACT_CLIENT :
+ ((type == "RemoteInput_Passive") ? REMOTEINPUT_CLIENT : CONFIG_CLIENT))))))));
lock();
m_info_manager->add_client(client.get_id(), key, _type);
unlock();
return true;
}
- LOGW ("open_connection failed\n");
+ LOGW ("open_connection failed");
SCIM_DEBUG_MAIN(4) << "Close client connection " << client.get_id() << "\n";
server->close_connection(client);
void socket_close_connection(SocketServer* server,
const Socket& client) {
SCIM_DEBUG_MAIN(3) << "PanelAgent::socket_close_connection (" << client.get_id() << ")\n";
- LOGD ("client id:%d\n", client.get_id());
+ LOGD ("client id:%d", client.get_id());
int i = 0;
std::vector<Ecore_Fd_Handler *>::iterator IterPos;
- for (IterPos = _read_handler_list.begin (); IterPos != _read_handler_list.end (); ++IterPos,++i) {
+ for (IterPos = _read_handler_list.begin (); IterPos != _read_handler_list.end (); ++IterPos, ++i) {
if (ecore_main_fd_handler_fd_get (_read_handler_list[i]) == client.get_id()) {
+ ::close (client.get_id ());
ecore_main_fd_handler_del (_read_handler_list[i]);
_read_handler_list.erase (IterPos);
break;
EXAPI void scim_panel_agent_module_init(const scim::ConfigPointer& config)
{
LOGD ("");
- scim::_config = config;
}
EXAPI scim::PanelAgentPointer scim_panel_agent_module_get_instance()
delete _instance;
_instance = NULL;
}
- if(_instance)
+ if (_instance)
instance = _instance;
}
return instance;
projects / platform / core / uifw / isf.git / blobdiff