inputmethod/src/inputmethod.cpp

   1 /*
   2  * Copyright (c) 2015-2021 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <vector>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <dlog.h>
  22 #include <sclcore.h>
  23 #include <unistd.h>
  24 #include <privilege_checker_private.h>
  25 #include "inputmethod_private.h"
  26 #include <inputmethod.h>
  27 #include "inputmethod_internal.h"
  28
  29 using namespace std;
  30
  31 #ifdef LOG_TAG
  32 #undef LOG_TAG
  33 #endif
  34 #define LOG_TAG "INPUTMETHOD"
  35
  36 using namespace scl;
  37
  38 class CCoreEventCallback : public ISCLCoreEventCallback
  39 {
  40     void on_init();
  41     void on_run(int argc, char **argv);
  42     void on_exit();
  43     void on_update_cursor_position(sclint ic, const sclchar *ic_uuid, sclint cursor_pos);
  44     void on_update_surrounding_text(sclint ic, const sclchar *text, sclint cursor);
  45     void on_focus_out(sclint ic, const sclchar *ic_uuid);
  46     void on_focus_in(sclint ic, const sclchar *ic_uuid);
  47     void on_ise_show(sclint ic, const int degree, Ise_Context &context);
  48     void on_ise_hide(sclint ic, const sclchar *ic_uuid);
  49     void on_get_geometry(sclu32 *pos_x, sclu32 *pos_y, sclu32 *width, sclu32 *height);
  50     void on_set_language(sclu32 language);
  51     void on_set_imdata(sclchar *buf, sclu32 len);
  52     void on_get_imdata(sclchar **buf, sclu32 *len);
  53     void on_get_language_locale(sclint ic, sclchar **locale);
  54     void on_set_return_key_type(sclu32 type);
  55     void on_set_return_key_disable(sclu32 disabled);
  56     void on_set_layout(sclu32 layout);
  57     void on_reset_input_context(sclint ic, const sclchar *uuid);
  58     void on_process_key_event(scim::KeyEvent &key, sclu32 *ret);
  59     void on_process_key_event_with_keycode(scim::KeyEvent &key, sclu32 *ret, sclu32 keycode);
  60     void on_set_display_language(const sclchar *language);
  61     void on_set_rotation_degree(sclint degree);
  62     void on_set_accessibility_state(sclboolean state);
  63     void on_create_option_window(sclwindow window, SCLOptionWindowType type);
  64     void on_destroy_option_window(sclwindow window);
  65     void on_check_option_window_availability(sclboolean *ret);
  66     void on_set_caps_mode(sclu32 mode);
  67     void on_candidate_show(sclint ic, const sclchar *ic_uuid);
  68     void on_candidate_hide(sclint ic, const sclchar *ic_uuid);
  69     void on_update_lookup_table(SclCandidateTable &table);
  70     void on_process_input_device_event(sclu32 &type, sclchar *data, size_t &len, sclu32 *ret);
  71     void on_set_prediction_hint(const sclchar *prediction_hint);
  72     void on_set_mime_type(const sclchar *mime_type);
  73     void on_set_prediction_hint_data(const sclchar *key, const sclchar *value);
  74     void on_set_optimization_hint(sclu32 hint);
  75     void on_process_key_event_with_imengine(scim::KeyEvent &key, sclu32 serial);
  76     void on_set_autocapital_type(sclu32 type);
  77     void on_set_prediction_allow(sclu32 prediction_allow);
  78     void on_trigger_property(const sclchar *property);
  79     void on_candidate_more_window_show(sclint ic, const sclchar *uuid);
  80     void on_candidate_more_window_hide(sclint ic, const sclchar *uuid);
  81     void on_select_aux(sclint ic, const sclchar *uuid, sclint index);
  82     void on_select_candidate(sclint ic, const sclchar *uuid, sclint index);
  83     void on_candidate_table_page_up(sclint ic, const sclchar *uuid);
  84     void on_candidate_table_page_down(sclint ic, const sclchar *uuid);
  85     void on_update_candidate_table_page_size(sclint ic, const sclchar *uuid, sclint page_size);
  86     void on_update_candidate_item_layout(const std::vector<sclu32> item);
  87     void on_update_displayed_candidate_number(sclu32 size);
  88     void on_longpress_candidate(sclu32 index);
  89     void on_set_input_hint(sclu32 input_hint);
  90 };
  91
  92 typedef struct
  93 {
  94     ime_focus_in_cb focus_in;   /**< Called when an edit field has focus */
  95     ime_focus_out_cb focus_out; /**< Called when an edit field loses focus */
  96     ime_surrounding_text_updated_cb surrounding_text_updated;   /**< Called when an edit field responds to a request with the surrounding text */
  97     ime_input_context_reset_cb input_context_reset;             /**< Called to reset the input context of an edit field */
  98     ime_cursor_position_updated_cb cursor_position_updated;     /**< Called when the position of the cursor in an edit field changes */
  99     ime_language_requested_cb language_requested;   /**< Called when an edit field requests the language from the input panel */
 100     ime_language_set_cb language_set;   /**< Called to set the preferred language to the input panel */
 101     ime_imdata_set_cb imdata_set;       /**< Called to set the application specific data to deliver to the input panel */
 102     ime_imdata_requested_cb imdata_requested;       /**< Called when an associated text input UI control requests the application specific data from the input panel */
 103     ime_layout_set_cb layout_set;       /**< Called when an edit field requests the input panel to set its layout */
 104     ime_return_key_type_set_cb return_key_type_set;     /**< Called when an edit field requests the input panel to set the "return" key label */
 105     ime_return_key_state_set_cb return_key_state_set;   /**< Called when an edit field requests the input panel to enable or disable the "return" key state */
 106     ime_geometry_requested_cb geometry_requested;       /**< Called when an edit field requests the position and size from the input panel */
 107     ime_process_key_event_cb process_key_event;         /**< Called when the key event is received from the external keyboard devices */
 108     ime_process_key_event_with_keycode_cb process_key_event_with_keycode; /**< Called when the key event is received from the external keyboard devices */
 109     ime_display_language_changed_cb display_language_changed;   /**< Called when the system display language is changed */
 110     ime_rotation_degree_changed_cb rotation_degree_changed;     /**< Called when the device is rotated */
 111     ime_accessibility_state_changed_cb accessibility_state_changed; /**< Called when Accessibility in Settings application is on or off */
 112     ime_option_window_created_cb option_window_created;     /**< Called to create the option window */
 113     ime_option_window_destroyed_cb option_window_destroyed; /**< Called to destroy the option window */
 114     ime_caps_mode_changed_cb caps_mode_changed;
 115     ime_candidate_show_cb candidate_show;
 116     ime_candidate_hide_cb candidate_hide;
 117     ime_lookup_table_changed_cb lookup_table_changed;
 118     ime_process_input_device_event_cb process_input_device_event;   /**< Called when the event is received from the unconventional input devices */
 119     ime_prediction_hint_set_cb prediction_hint_set;
 120     ime_mime_type_set_request_cb mime_type_set;
 121     ime_prediction_hint_data_set_cb prediction_hint_data_set;
 122     ime_optimization_hint_set_cb optimization_hint_set;
 123     ime_process_key_event_with_imengine_cb process_key_event_with_imengine;
 124     ime_autocapital_type_set_cb autocapital_type_set;
 125     ime_prediction_allow_set_cb prediction_allow_set;
 126     ime_trigger_property_set_cb trigger_property_set;
 127     ime_candidate_more_window_show_cb candidate_more_window_show;
 128     ime_candidate_more_window_hide_cb candidate_more_window_hide;
 129     ime_aux_select_cb aux_select;
 130     ime_candidate_select_cb candidate_select;
 131     ime_candidate_table_page_up_cb candidate_table_page_up;
 132     ime_candidate_table_page_down_cb candidate_table_page_down;
 133     ime_candidate_table_page_size_chaned_cb candidate_table_page_size_chaned;
 134     ime_candidate_item_layout_set_cb candidate_item_layout_set;
 135     ime_displayed_candidate_number_chaned_cb displayed_candidate_number_chaned;
 136     ime_candidate_item_long_pressed_cb candidate_item_long_pressed;
 137     ime_input_hint_set_cb input_hint_set;       /**< Called when an edit field requests the input panel to set its input hint */
 138     void *focus_in_user_data;
 139     void *focus_out_user_data;
 140     void *surrounding_text_updated_user_data;
 141     void *input_context_reset_user_data;
 142     void *cursor_position_updated_user_data;
 143     void *language_requested_user_data;
 144     void *language_set_user_data;
 145     void *imdata_set_user_data;
 146     void *imdata_requested_user_data;
 147     void *layout_set_user_data;
 148     void *return_key_type_set_user_data;
 149     void *return_key_state_set_user_data;
 150     void *geometry_requested_user_data;
 151     void *process_key_event_user_data;
 152     void *process_key_event_with_keycode_user_data;
 153     void *display_language_changed_user_data;
 154     void *rotation_degree_changed_user_data;
 155     void *accessibility_state_changed_user_data;
 156     void *option_window_created_user_data;
 157     void *option_window_destroyed_user_data;
 158     void *caps_mode_changed_user_data;
 159     void *candidate_show_user_data;
 160     void *candidate_hide_user_data;
 161     void *lookup_table_changed_user_data;
 162     void *process_input_device_event_user_data;
 163     void *prediction_hint_set_user_data;
 164     void *mime_type_set_user_data;
 165     void *prediction_hint_data_set_user_data;
 166     void *optimization_hint_set_user_data;
 167     void *process_key_event_with_imengine_user_data;
 168     void *autocapital_type_set_user_data;
 169     void *prediction_allow_set_user_data;
 170     void *trigger_property_set_user_data;
 171     void *candidate_more_window_show_user_data;
 172     void *candidate_more_window_hide_user_data;
 173     void *aux_select_user_data;
 174     void *candidate_select_user_data;
 175     void *candidate_table_page_up_user_data;
 176     void *candidate_table_page_down_user_data;
 177     void *candidate_table_page_size_chaned_user_data;
 178     void *candidate_item_layout_set_user_data;
 179     void *displayed_candidate_number_chaned_user_data;
 180     void *candidate_item_long_pressed_user_data;
 181     void *input_hint_set_user_data;
 182 } ime_event_callback_s;
 183
 184 typedef struct {
 185     ime_input_device_type_e device_type;
 186     void *event_data;
 187 } ime_device_event_s;
 188
 189 static ime_callback_s g_basic_callback = {NULL};
 190 static ime_event_callback_s g_event_callback = {NULL};
 191 static void *g_user_data = NULL;
 192 static bool g_running = false;
 193
 194 static CCoreEventCallback g_core_event_callback;
 195 CSCLCore g_core(&g_core_event_callback);
 196
 197 static bool g_checked_privilege = false;
 198 static bool g_permission_allowed = false;
 199
 200 extern "C" {
 201     extern void ime_app_main(int argc, char **argv);
 202 }
 203
 204 //LCOV_EXCL_START
 205 void CCoreEventCallback::on_init()
 206 {
 207     if (g_basic_callback.create) {
 208         g_basic_callback.create(g_user_data);
 209     }
 210 }
 211
 212 void CCoreEventCallback::on_run(int argc, char **argv)
 213 {
 214     LOGD("on_run");
 215     ime_app_main(argc, argv);
 216 }
 217
 218 void CCoreEventCallback::on_exit()
 219 {
 220     LOGD("on_exit");
 221     if (g_basic_callback.terminate) {
 222         g_basic_callback.terminate(g_user_data);
 223     }
 224 }
 225
 226 void CCoreEventCallback::on_update_cursor_position(sclint ic, const sclchar *ic_uuid, sclint cursor_pos)
 227 {
 228     if (g_event_callback.cursor_position_updated) {
 229         g_event_callback.cursor_position_updated(cursor_pos, g_event_callback.cursor_position_updated_user_data);
 230     }
 231 }
 232
 233 void CCoreEventCallback::on_update_surrounding_text(sclint ic, const sclchar *text, sclint cursor)
 234 {
 235     if (g_event_callback.surrounding_text_updated) {
 236         g_event_callback.surrounding_text_updated(ic, text, cursor, g_event_callback.surrounding_text_updated_user_data);
 237     }
 238 }
 239
 240 void CCoreEventCallback::on_focus_out(sclint ic, const sclchar *ic_uuid)
 241 {
 242     if (g_event_callback.focus_out) {
 243         g_event_callback.focus_out(ic, g_event_callback.focus_out_user_data);
 244     }
 245 }
 246
 247 void CCoreEventCallback::on_focus_in(sclint ic, const sclchar *ic_uuid)
 248 {
 249     if (g_event_callback.focus_in) {
 250         g_event_callback.focus_in(ic, g_event_callback.focus_in_user_data);
 251     }
 252 }
 253
 254 void CCoreEventCallback::on_ise_show(sclint ic, const int degree, Ise_Context &context)
 255 {
 256     if (g_basic_callback.show) {
 257         struct _ime_context input_context;
 258
 259         memset(&input_context, 0, sizeof(struct _ime_context));
 260         input_context.layout = context.layout;
 261         input_context.layout_variation = context.layout_variation;
 262         input_context.cursor_pos = context.cursor_pos;
 263         input_context.autocapital_type = context.autocapital_type;
 264         input_context.return_key_type = context.return_key_type;
 265         input_context.return_key_disabled = context.return_key_disabled;
 266         input_context.prediction_allow = context.prediction_allow;
 267         input_context.password_mode = context.password_mode;
 268         input_context.imdata_size = context.imdata_size;
 269         input_context.input_hint = context.input_hint;
 270         input_context.bidi_direction = context.bidi_direction;
 271         input_context.language = context.language;
 272         input_context.client_window = context.client_window;
 273         input_context.caps_mode = context.caps_mode;
 274
 275         g_basic_callback.show(ic, static_cast<ime_context_h>(&input_context), g_user_data);
 276     }
 277 }
 278
 279 void CCoreEventCallback::on_ise_hide(sclint ic, const sclchar *ic_uuid)
 280 {
 281     if (g_basic_callback.hide) {
 282         g_basic_callback.hide(ic, g_user_data);
 283     }
 284 }
 285
 286 void CCoreEventCallback::on_get_geometry(sclu32 *pos_x, sclu32 *pos_y, sclu32 *width, sclu32 *height)
 287 {
 288     int geometry_pos_x = 0;
 289     int geometry_pos_y = 0;
 290     int geometry_width = 0;
 291     int geometry_height = 0;
 292
 293     if (g_event_callback.geometry_requested) {
 294         g_event_callback.geometry_requested(g_event_callback.geometry_requested_user_data, &geometry_pos_x, &geometry_pos_y, &geometry_width, &geometry_height);
 295     }
 296
 297     if (pos_x)
 298         *pos_x = geometry_pos_x;
 299
 300     if (pos_y)
 301         *pos_y = geometry_pos_y;
 302
 303     if (width)
 304         *width = geometry_width;
 305
 306     if (height)
 307         *height = geometry_height;
 308 }
 309
 310 void CCoreEventCallback::on_set_language(sclu32 language)
 311 {
 312     if (g_event_callback.language_set) {
 313         g_event_callback.language_set((Ecore_IMF_Input_Panel_Lang)language, g_event_callback.language_set_user_data);
 314     }
 315 }
 316
 317 void CCoreEventCallback::on_set_imdata(sclchar *buf, sclu32 len)
 318 {
 319     if (g_event_callback.imdata_set) {
 320         g_event_callback.imdata_set((void *)buf, len, g_event_callback.imdata_set_user_data);
 321     }
 322 }
 323
 324 void CCoreEventCallback::on_get_imdata(sclchar **buf, sclu32 *len)
 325 {
 326     if (g_event_callback.imdata_requested) {
 327         g_event_callback.imdata_requested(g_event_callback.imdata_set_user_data, (void **)buf, len);
 328     }
 329 }
 330
 331 void CCoreEventCallback::on_get_language_locale(sclint ic, sclchar **locale)
 332 {
 333     if (g_event_callback.language_requested) {
 334         g_event_callback.language_requested(g_event_callback.language_requested_user_data, locale);
 335     }
 336 }
 337
 338 void CCoreEventCallback::on_set_return_key_type(sclu32 type)
 339 {
 340     if (g_event_callback.return_key_type_set) {
 341         g_event_callback.return_key_type_set((Ecore_IMF_Input_Panel_Return_Key_Type)type, g_event_callback.return_key_type_set_user_data);
 342     }
 343 }
 344
 345 void CCoreEventCallback::on_set_return_key_disable(sclu32 disabled)
 346 {
 347     bool return_key_disabled = !!disabled;
 348
 349     if (g_event_callback.return_key_state_set) {
 350         g_event_callback.return_key_state_set(return_key_disabled, g_event_callback.return_key_state_set_user_data);
 351     }
 352 }
 353
 354 void CCoreEventCallback::on_set_layout(sclu32 layout)
 355 {
 356     if (g_event_callback.layout_set) {
 357         g_event_callback.layout_set(static_cast<Ecore_IMF_Input_Panel_Layout>(layout), g_event_callback.layout_set_user_data);
 358     }
 359 }
 360
 361 void CCoreEventCallback::on_set_input_hint(sclu32 input_hint)
 362 {
 363     if (g_event_callback.input_hint_set) {
 364         g_event_callback.input_hint_set(static_cast<Ecore_IMF_Input_Hints>(input_hint), g_event_callback.input_hint_set_user_data);
 365     }
 366 }
 367
 368 void CCoreEventCallback::on_reset_input_context(sclint ic, const sclchar *uuid)
 369 {
 370     if (g_event_callback.input_context_reset) {
 371         g_event_callback.input_context_reset(g_event_callback.input_context_reset_user_data);
 372     }
 373 }
 374
 375 void CCoreEventCallback::on_process_key_event(scim::KeyEvent &key, sclu32 *ret)
 376 {
 377     if (g_event_callback.process_key_event) {
 378         struct _ime_device_info dev_info = {key.dev_name.c_str(),
 379             static_cast<Ecore_IMF_Device_Class>(key.dev_class), static_cast<Ecore_IMF_Device_Subclass>(key.dev_subclass)};
 380         bool processed = g_event_callback.process_key_event(static_cast<ime_key_code_e>(key.code), static_cast<ime_key_mask_e>(key.mask),
 381             static_cast<ime_device_info_h>(&dev_info), g_event_callback.process_key_event_user_data);
 382
 383         if (ret) {
 384             if (processed)
 385                 *ret = 1;
 386             else
 387                 *ret = 0;
 388         }
 389     } else {
 390         if (ret) {
 391             *ret = 0;
 392         }
 393     }
 394 }
 395
 396 void CCoreEventCallback::on_process_key_event_with_keycode(scim::KeyEvent &key, sclu32 *ret, sclu32 keycode)
 397 {
 398     if (g_event_callback.process_key_event_with_keycode) {
 399         struct _ime_device_info dev_info = {key.dev_name.c_str(),
 400             static_cast<Ecore_IMF_Device_Class>(key.dev_class), static_cast<Ecore_IMF_Device_Subclass>(key.dev_subclass)};
 401         bool processed = g_event_callback.process_key_event_with_keycode(keycode, static_cast<ime_key_code_e>(key.code), static_cast<ime_key_mask_e>(key.mask),
 402                 static_cast<ime_device_info_h>(&dev_info), g_event_callback.process_key_event_user_data);
 403
 404         if (ret) {
 405             if (processed)
 406                 *ret = 1;
 407             else
 408                 *ret = 0;
 409         }
 410     } else {
 411         if (ret) {
 412             *ret = 0;
 413         }
 414     }
 415 }
 416
 417 void CCoreEventCallback::on_set_display_language(const sclchar *language)
 418 {
 419     if (g_event_callback.display_language_changed) {
 420         g_event_callback.display_language_changed(language, g_event_callback.display_language_changed_user_data);
 421     }
 422 }
 423
 424 void CCoreEventCallback::on_set_rotation_degree(sclint degree)
 425 {
 426     if (g_event_callback.rotation_degree_changed) {
 427         g_event_callback.rotation_degree_changed(degree, g_event_callback.rotation_degree_changed_user_data);
 428     }
 429 }
 430
 431 void CCoreEventCallback::on_set_accessibility_state(sclboolean state)
 432 {
 433     if (g_event_callback.accessibility_state_changed) {
 434         g_event_callback.accessibility_state_changed(state, g_event_callback.accessibility_state_changed_user_data);
 435     }
 436 }
 437
 438 void CCoreEventCallback::on_create_option_window(sclwindow window, SCLOptionWindowType type)
 439 {
 440     if (g_event_callback.option_window_created) {
 441         g_event_callback.option_window_created(static_cast<Evas_Object*>(window), static_cast<ime_option_window_type_e>(type), g_event_callback.option_window_created_user_data);
 442     }
 443 }
 444
 445 void CCoreEventCallback::on_destroy_option_window(sclwindow window)
 446 {
 447     if (g_event_callback.option_window_destroyed) {
 448         g_event_callback.option_window_destroyed(static_cast<Evas_Object*>(window), g_event_callback.option_window_destroyed_user_data);
 449     }
 450 }
 451
 452 void CCoreEventCallback::on_check_option_window_availability(sclboolean *ret)
 453 {
 454     if (ret) {
 455         if (g_event_callback.option_window_created) // Instead of each 3rd party keyboard, inputmethod will reply the availability of the option (setting).
 456             *ret = true;
 457         else
 458             *ret = false;
 459     }
 460 }
 461
 462 void CCoreEventCallback::on_set_caps_mode(sclu32 mode)
 463 {
 464     if (g_event_callback.caps_mode_changed) {
 465         g_event_callback.caps_mode_changed(mode, g_event_callback.caps_mode_changed_user_data);
 466     }
 467 }
 468
 469 void CCoreEventCallback::on_candidate_show(sclint ic, const sclchar *ic_uuid)
 470 {
 471     if (g_event_callback.candidate_show) {
 472         g_event_callback.candidate_show(ic, g_event_callback.candidate_show_user_data);
 473     }
 474 }
 475
 476 void CCoreEventCallback::on_candidate_hide(sclint ic, const sclchar *ic_uuid)
 477 {
 478     if (g_event_callback.candidate_hide) {
 479         g_event_callback.candidate_hide(ic, g_event_callback.candidate_hide_user_data);
 480     }
 481 }
 482
 483 void CCoreEventCallback::on_update_lookup_table(SclCandidateTable &table)
 484 {
 485     Eina_List *string_list = NULL;
 486
 487     if (g_event_callback.lookup_table_changed) {
 488         vector<string>::iterator iter = table.candidate.begin();
 489         for (; iter != table.candidate.end(); ++iter) {
 490             string_list = eina_list_append(string_list, iter->c_str());
 491         }
 492
 493         g_event_callback.lookup_table_changed(string_list, g_event_callback.lookup_table_changed_user_data);
 494     }
 495 }
 496
 497 void CCoreEventCallback::on_process_input_device_event(sclu32 &type, sclchar *data, size_t &len, sclu32 *ret)
 498 {
 499     typedef struct {
 500         int ecore_event_id;
 501         ime_input_device_type_e device_type;
 502     } ime_device_type_conv_table;
 503
 504     ime_device_type_conv_table conv_table[] = {
 505         { ECORE_EVENT_DETENT_ROTATE , IME_INPUT_DEVICE_TYPE_ROTARY },
 506     };
 507
 508     ime_input_device_type_e device_type = IME_INPUT_DEVICE_TYPE_UNKNOWN;
 509     for (unsigned int loop = 0; loop < sizeof(conv_table) / sizeof(ime_device_type_conv_table); loop++) {
 510         if ((unsigned int)(conv_table[loop].ecore_event_id) == type) {
 511             device_type = conv_table[loop].device_type;
 512         }
 513     }
 514
 515     if (g_event_callback.process_input_device_event) {
 516         ime_device_event_s device_event;
 517         device_event.device_type = device_type;
 518         device_event.event_data = static_cast<void*>(data);
 519         void *input_data = static_cast<void*>(&device_event);
 520         void *user_data = g_event_callback.process_input_device_event_user_data;
 521
 522         g_event_callback.process_input_device_event(device_type, input_data, user_data);
 523
 524         if (ret) {
 525             *ret = 1;
 526         }
 527     } else {
 528         if (ret) {
 529             *ret = 0;
 530         }
 531     }
 532 }
 533
 534 void CCoreEventCallback::on_set_prediction_hint(const sclchar *prediction_hint)
 535 {
 536     if (g_event_callback.prediction_hint_set) {
 537         g_event_callback.prediction_hint_set(prediction_hint, g_event_callback.prediction_hint_set_user_data);
 538     }
 539 }
 540
 541 void CCoreEventCallback::on_set_mime_type(const sclchar *mime_type)
 542 {
 543     if (g_event_callback.mime_type_set) {
 544         g_event_callback.mime_type_set(mime_type, g_event_callback.mime_type_set_user_data);
 545     }
 546 }
 547
 548 void CCoreEventCallback::on_set_prediction_hint_data(const sclchar *key, const sclchar *value)
 549 {
 550     if (g_event_callback.prediction_hint_data_set) {
 551         g_event_callback.prediction_hint_data_set(key, value, g_event_callback.prediction_hint_data_set_user_data);
 552     }
 553 }
 554
 555 void CCoreEventCallback::on_set_optimization_hint(sclu32 hint)
 556 {
 557     if (g_event_callback.optimization_hint_set) {
 558         g_event_callback.optimization_hint_set((ime_optimization_hint_e)hint, g_event_callback.optimization_hint_set_user_data);
 559     }
 560 }
 561
 562 void CCoreEventCallback::on_process_key_event_with_imengine(scim::KeyEvent &key, sclu32 serial)
 563 {
 564     if (g_event_callback.process_key_event_with_imengine) {
 565         g_event_callback.process_key_event_with_imengine(key, serial, g_event_callback.process_key_event_with_imengine_user_data);
 566     }
 567 }
 568
 569 void CCoreEventCallback::on_set_autocapital_type(sclu32 type)
 570 {
 571     if (g_event_callback.autocapital_type_set) {
 572         g_event_callback.autocapital_type_set(type, g_event_callback.autocapital_type_set_user_data);
 573     }
 574 }
 575
 576 void CCoreEventCallback::on_set_prediction_allow(sclu32 prediction_allow)
 577 {
 578     if (g_event_callback.prediction_allow_set) {
 579         g_event_callback.prediction_allow_set(prediction_allow, g_event_callback.prediction_allow_set_user_data);
 580     }
 581 }
 582
 583 void CCoreEventCallback::on_trigger_property(const sclchar *property)
 584 {
 585     if (g_event_callback.trigger_property_set) {
 586         g_event_callback.trigger_property_set(property, g_event_callback.trigger_property_set_user_data);
 587     }
 588 }
 589
 590 void CCoreEventCallback::on_candidate_more_window_show(sclint ic, const sclchar *uuid)
 591 {
 592     if (g_event_callback.candidate_more_window_show) {
 593         g_event_callback.candidate_more_window_show(g_event_callback.candidate_more_window_show_user_data);
 594     }
 595 }
 596
 597 void CCoreEventCallback::on_candidate_more_window_hide(sclint ic, const sclchar *uuid)
 598 {
 599     if (g_event_callback.candidate_more_window_hide) {
 600         g_event_callback.candidate_more_window_hide(g_event_callback.candidate_more_window_hide_user_data);
 601     }
 602 }
 603
 604 void CCoreEventCallback::on_select_aux(sclint ic, const sclchar *uuid, sclint index)
 605 {
 606     if (g_event_callback.aux_select) {
 607         g_event_callback.aux_select((uint32_t)index, g_event_callback.aux_select_user_data);
 608     }
 609 }
 610
 611 void CCoreEventCallback::on_select_candidate(sclint ic, const sclchar *uuid, sclint index)
 612 {
 613     if (g_event_callback.candidate_select) {
 614         g_event_callback.candidate_select((uint32_t)index, g_event_callback.candidate_select_user_data);
 615     }
 616 }
 617
 618 void CCoreEventCallback::on_candidate_table_page_up(sclint ic, const sclchar *uuid)
 619 {
 620     if (g_event_callback.candidate_table_page_up) {
 621         g_event_callback.candidate_table_page_up(g_event_callback.candidate_table_page_up_user_data);
 622     }
 623 }
 624
 625 void CCoreEventCallback::on_candidate_table_page_down(sclint ic, const sclchar *uuid)
 626 {
 627     if (g_event_callback.candidate_table_page_down) {
 628         g_event_callback.candidate_table_page_down(g_event_callback.candidate_table_page_down_user_data);
 629     }
 630 }
 631
 632 void CCoreEventCallback::on_update_candidate_table_page_size(sclint ic, const sclchar *uuid, sclint page_size)
 633 {
 634     if (g_event_callback.candidate_table_page_size_chaned) {
 635         g_event_callback.candidate_table_page_size_chaned((uint32_t)page_size, g_event_callback.candidate_table_page_size_chaned_user_data);
 636     }
 637 }
 638
 639 void CCoreEventCallback::on_update_candidate_item_layout(const std::vector<sclu32> item)
 640 {
 641     if (g_event_callback.candidate_item_layout_set) {
 642         g_event_callback.candidate_item_layout_set(item, g_event_callback.candidate_item_layout_set_user_data);
 643     }
 644 }
 645
 646 void CCoreEventCallback::on_update_displayed_candidate_number(sclu32 size)
 647 {
 648     if (g_event_callback.displayed_candidate_number_chaned) {
 649         g_event_callback.displayed_candidate_number_chaned(size, g_event_callback.displayed_candidate_number_chaned_user_data);
 650     }
 651 }
 652
 653 void CCoreEventCallback::on_longpress_candidate(sclu32 index)
 654 {
 655     if (g_event_callback.candidate_item_long_pressed) {
 656         g_event_callback.candidate_item_long_pressed(index, g_event_callback.candidate_item_long_pressed_user_data);
 657     }
 658 }
 659
 660 void ime_privilege_cache_init()
 661 {
 662     g_permission_allowed = false;
 663     g_checked_privilege = false;
 664 }
 665 //LCOV_EXCL_STOP
 666
 667 ime_error_e _check_privilege()
 668 {
 669     char uid[16];
 670     ime_error_e ret = IME_ERROR_NONE;
 671
 672     if (g_checked_privilege) {
 673         return g_permission_allowed ? IME_ERROR_NONE : IME_ERROR_PERMISSION_DENIED;
 674     }
 675
 676     if (inputmethod_cynara_initialize() == false) {
 677         //LCOV_EXCL_START
 678         g_permission_allowed = false;
 679         g_checked_privilege = true;
 680         LOGE("inputmethod_cynara_initialize () == false");
 681         //LCOV_EXCL_STOP
 682         return IME_ERROR_PERMISSION_DENIED;
 683     }
 684
 685     snprintf(uid, 16, "%d", getuid());
 686     if (check_privilege(uid, IME_PRIVILEGE) == false) {
 687         LOGE("check_privilege(uid, IME_PRIVILEGE) == false. uid : %s", uid); //LCOV_EXCL_LINE
 688         ret = IME_ERROR_PERMISSION_DENIED;
 689     }
 690
 691     g_permission_allowed = (ret == IME_ERROR_NONE);
 692     g_checked_privilege = true;
 693
 694     inputmethod_cynara_finish();
 695
 696     return ret;
 697 }
 698
 699 //LCOV_EXCL_START
 700 bool g_from_dotnet = false;
 701 EXPORT_API int ime_set_dotnet_flag(bool set)
 702 {
 703     ime_error_e retVal = IME_ERROR_NONE;
 704
 705     retVal = _check_privilege();
 706     if (retVal != IME_ERROR_NONE) return retVal;
 707
 708     g_from_dotnet = set;
 709
 710     return retVal;
 711 }
 712 //LCOV_EXCL_STOP
 713
 714 EXPORT_API int ime_run(ime_callback_s *basic_cb, void *user_data)
 715 {
 716     ime_error_e retVal = IME_ERROR_NONE;
 717
 718     if (g_running) {
 719         //LCOV_EXCL_START
 720         LOGE("inputmethod main loop is already running.");
 721         return IME_ERROR_OPERATION_FAILED;
 722         //LCOV_EXCL_STOP
 723     }
 724
 725     if (!basic_cb) {
 726         LOGE("basic callbacks pointer is null.");
 727         return IME_ERROR_INVALID_PARAMETER;
 728     }
 729
 730     retVal = _check_privilege();
 731     if (retVal != IME_ERROR_NONE) return retVal;
 732
 733     g_basic_callback = *basic_cb;
 734
 735     if (!g_basic_callback.create || !g_basic_callback.terminate ||
 736         !g_basic_callback.show || !g_basic_callback.hide) {
 737         LOGE("mandatory callback functions are not set");
 738         memset(&g_basic_callback, 0, sizeof(ime_callback_s));
 739         memset(&g_event_callback, 0, sizeof(ime_event_callback_s));
 740         return IME_ERROR_NO_CALLBACK_FUNCTION;
 741     }
 742
 743     //LCOV_EXCL_START
 744     g_user_data = user_data;
 745     g_running = true;
 746
 747     if (g_from_dotnet) {
 748         LOGD("ime_run is called from dotnet");
 749         return IME_ERROR_NONE;
 750     }
 751
 752     try {
 753         g_core.run();
 754     } catch (...) {
 755         LOGW("exception is thrown from g_core.run()\n");
 756     }
 757
 758     memset(&g_basic_callback, 0, sizeof(ime_callback_s));
 759     memset(&g_event_callback, 0, sizeof(ime_event_callback_s));
 760     g_user_data = NULL;
 761     g_running = false;
 762
 763     return IME_ERROR_NONE;
 764     //LCOV_EXCL_STOP
 765 }
 766
 767 EXPORT_API int ime_event_set_focus_in_cb(ime_focus_in_cb callback_func, void *user_data)
 768 {
 769     ime_error_e retVal = IME_ERROR_NONE;
 770
 771     if (!callback_func) {
 772         LOGW("IME_ERROR_INVALID_PARAMETER");
 773         return IME_ERROR_INVALID_PARAMETER;
 774     }
 775
 776     retVal = _check_privilege();
 777     if (retVal != IME_ERROR_NONE) return retVal;
 778
 779     g_event_callback.focus_in = callback_func;
 780     g_event_callback.focus_in_user_data = user_data;
 781
 782     return IME_ERROR_NONE;
 783 }
 784
 785 EXPORT_API int ime_event_set_focus_out_cb(ime_focus_out_cb callback_func, void *user_data)
 786 {
 787     ime_error_e retVal = IME_ERROR_NONE;
 788
 789     if (!callback_func) {
 790         LOGW("IME_ERROR_INVALID_PARAMETER");
 791         return IME_ERROR_INVALID_PARAMETER;
 792     }
 793
 794     retVal = _check_privilege();
 795     if (retVal != IME_ERROR_NONE) return retVal;
 796
 797     g_event_callback.focus_out = callback_func;
 798     g_event_callback.focus_out_user_data = user_data;
 799
 800     return IME_ERROR_NONE;
 801 }
 802
 803 EXPORT_API int ime_event_set_surrounding_text_updated_cb(ime_surrounding_text_updated_cb callback_func, void *user_data)
 804 {
 805     ime_error_e retVal = IME_ERROR_NONE;
 806
 807     if (!callback_func) {
 808         LOGW("IME_ERROR_INVALID_PARAMETER");
 809         return IME_ERROR_INVALID_PARAMETER;
 810     }
 811
 812     retVal = _check_privilege();
 813     if (retVal != IME_ERROR_NONE) return retVal;
 814
 815     g_event_callback.surrounding_text_updated = callback_func;
 816     g_event_callback.surrounding_text_updated_user_data = user_data;
 817
 818     return IME_ERROR_NONE;
 819 }
 820
 821 EXPORT_API int ime_event_set_input_context_reset_cb(ime_input_context_reset_cb callback_func, void *user_data)
 822 {
 823     ime_error_e retVal = IME_ERROR_NONE;
 824
 825     if (!callback_func) {
 826         LOGW("IME_ERROR_INVALID_PARAMETER");
 827         return IME_ERROR_INVALID_PARAMETER;
 828     }
 829
 830     retVal = _check_privilege();
 831     if (retVal != IME_ERROR_NONE) return retVal;
 832
 833     g_event_callback.input_context_reset = callback_func;
 834     g_event_callback.input_context_reset_user_data = user_data;
 835
 836     return IME_ERROR_NONE;
 837 }
 838
 839 EXPORT_API int ime_event_set_cursor_position_updated_cb(ime_cursor_position_updated_cb callback_func, void *user_data)
 840 {
 841     ime_error_e retVal = IME_ERROR_NONE;
 842
 843     if (!callback_func) {
 844         LOGW("IME_ERROR_INVALID_PARAMETER");
 845         return IME_ERROR_INVALID_PARAMETER;
 846     }
 847
 848     retVal = _check_privilege();
 849     if (retVal != IME_ERROR_NONE) return retVal;
 850
 851     g_event_callback.cursor_position_updated = callback_func;
 852     g_event_callback.cursor_position_updated_user_data = user_data;
 853
 854     return IME_ERROR_NONE;
 855 }
 856
 857 EXPORT_API int ime_event_set_language_requested_cb(ime_language_requested_cb callback_func, void *user_data)
 858 {
 859     ime_error_e retVal = IME_ERROR_NONE;
 860
 861     if (!callback_func) {
 862         LOGW("IME_ERROR_INVALID_PARAMETER");
 863         return IME_ERROR_INVALID_PARAMETER;
 864     }
 865
 866     retVal = _check_privilege();
 867     if (retVal != IME_ERROR_NONE) return retVal;
 868
 869     g_event_callback.language_requested = callback_func;
 870     g_event_callback.language_requested_user_data = user_data;
 871
 872     return IME_ERROR_NONE;
 873 }
 874
 875 EXPORT_API int ime_event_set_language_set_cb(ime_language_set_cb callback_func, void *user_data)
 876 {
 877     ime_error_e retVal = IME_ERROR_NONE;
 878
 879     if (!callback_func) {
 880         LOGW("IME_ERROR_INVALID_PARAMETER");
 881         return IME_ERROR_INVALID_PARAMETER;
 882     }
 883
 884     retVal = _check_privilege();
 885     if (retVal != IME_ERROR_NONE) return retVal;
 886
 887     g_event_callback.language_set = callback_func;
 888     g_event_callback.language_set_user_data = user_data;
 889
 890     return IME_ERROR_NONE;
 891 }
 892
 893 EXPORT_API int ime_event_set_imdata_set_cb(ime_imdata_set_cb callback_func, void *user_data)
 894 {
 895     ime_error_e retVal = IME_ERROR_NONE;
 896
 897     if (!callback_func) {
 898         LOGW("IME_ERROR_INVALID_PARAMETER");
 899         return IME_ERROR_INVALID_PARAMETER;
 900     }
 901
 902     retVal = _check_privilege();
 903     if (retVal != IME_ERROR_NONE) return retVal;
 904
 905     g_event_callback.imdata_set = callback_func;
 906     g_event_callback.imdata_set_user_data = user_data;
 907
 908     return IME_ERROR_NONE;
 909 }
 910
 911 EXPORT_API int ime_event_set_imdata_requested_cb(ime_imdata_requested_cb callback_func, void *user_data)
 912 {
 913     ime_error_e retVal = IME_ERROR_NONE;
 914
 915     if (!callback_func) {
 916         LOGW("IME_ERROR_INVALID_PARAMETER");
 917         return IME_ERROR_INVALID_PARAMETER;
 918     }
 919
 920     retVal = _check_privilege();
 921     if (retVal != IME_ERROR_NONE) return retVal;
 922
 923     g_event_callback.imdata_requested = callback_func;
 924     g_event_callback.imdata_requested_user_data = user_data;
 925
 926     return IME_ERROR_NONE;
 927 }
 928
 929 EXPORT_API int ime_event_set_layout_set_cb(ime_layout_set_cb callback_func, void *user_data)
 930 {
 931     ime_error_e retVal = IME_ERROR_NONE;
 932
 933     if (!callback_func) {
 934         LOGW("IME_ERROR_INVALID_PARAMETER");
 935         return IME_ERROR_INVALID_PARAMETER;
 936     }
 937
 938     retVal = _check_privilege();
 939     if (retVal != IME_ERROR_NONE) return retVal;
 940
 941     g_event_callback.layout_set = callback_func;
 942     g_event_callback.layout_set_user_data = user_data;
 943
 944     return IME_ERROR_NONE;
 945 }
 946
 947 EXPORT_API int ime_event_set_return_key_type_set_cb(ime_return_key_type_set_cb callback_func, void *user_data)
 948 {
 949     ime_error_e retVal = IME_ERROR_NONE;
 950
 951     if (!callback_func) {
 952         LOGW("IME_ERROR_INVALID_PARAMETER");
 953         return IME_ERROR_INVALID_PARAMETER;
 954     }
 955
 956     retVal = _check_privilege();
 957     if (retVal != IME_ERROR_NONE) return retVal;
 958
 959     g_event_callback.return_key_type_set = callback_func;
 960     g_event_callback.return_key_type_set_user_data = user_data;
 961
 962     return IME_ERROR_NONE;
 963 }
 964
 965 EXPORT_API int ime_event_set_return_key_state_set_cb(ime_return_key_state_set_cb callback_func, void *user_data)
 966 {
 967     ime_error_e retVal = IME_ERROR_NONE;
 968
 969     if (!callback_func) {
 970         LOGW("IME_ERROR_INVALID_PARAMETER");
 971         return IME_ERROR_INVALID_PARAMETER;
 972     }
 973
 974     retVal = _check_privilege();
 975     if (retVal != IME_ERROR_NONE) return retVal;
 976
 977     g_event_callback.return_key_state_set = callback_func;
 978     g_event_callback.return_key_state_set_user_data = user_data;
 979
 980     return IME_ERROR_NONE;
 981 }
 982
 983 EXPORT_API int ime_event_set_geometry_requested_cb(ime_geometry_requested_cb callback_func, void *user_data)
 984 {
 985     ime_error_e retVal = IME_ERROR_NONE;
 986
 987     if (!callback_func) {
 988         LOGW("IME_ERROR_INVALID_PARAMETER");
 989         return IME_ERROR_INVALID_PARAMETER;
 990     }
 991
 992     retVal = _check_privilege();
 993     if (retVal != IME_ERROR_NONE) return retVal;
 994
 995     g_event_callback.geometry_requested = callback_func;
 996     g_event_callback.geometry_requested_user_data = user_data;
 997
 998     return IME_ERROR_NONE;
 999 }
1000
1001 EXPORT_API int ime_event_set_process_key_event_cb(ime_process_key_event_cb callback_func, void *user_data)
1002 {
1003     ime_error_e retVal = IME_ERROR_NONE;
1004
1005     if (!callback_func) {
1006         LOGW("IME_ERROR_INVALID_PARAMETER");
1007         return IME_ERROR_INVALID_PARAMETER;
1008     }
1009
1010     retVal = _check_privilege();
1011     if (retVal != IME_ERROR_NONE) return retVal;
1012
1013     g_event_callback.process_key_event = callback_func;
1014     g_event_callback.process_key_event_user_data = user_data;
1015
1016     return IME_ERROR_NONE;
1017 }
1018
1019 EXPORT_API int ime_event_set_process_key_event_with_keycode_cb(ime_process_key_event_with_keycode_cb callback_func, void *user_data)
1020 {
1021     ime_error_e retVal = IME_ERROR_NONE;
1022
1023     if (!callback_func) {
1024         LOGW("IME_ERROR_INVALID_PARAMETER");
1025         return IME_ERROR_INVALID_PARAMETER;
1026     }
1027
1028     retVal = _check_privilege();
1029     if (retVal != IME_ERROR_NONE) return retVal;
1030
1031     g_event_callback.process_key_event_with_keycode = callback_func;
1032     g_event_callback.process_key_event_with_keycode_user_data = user_data;
1033
1034     return IME_ERROR_NONE;
1035 }
1036
1037 EXPORT_API int ime_event_set_display_language_changed_cb(ime_display_language_changed_cb callback_func, void *user_data)
1038 {
1039     ime_error_e retVal = IME_ERROR_NONE;
1040
1041     if (!callback_func) {
1042         LOGW("IME_ERROR_INVALID_PARAMETER");
1043         return IME_ERROR_INVALID_PARAMETER;
1044     }
1045
1046     retVal = _check_privilege();
1047     if (retVal != IME_ERROR_NONE) return retVal;
1048
1049     g_event_callback.display_language_changed = callback_func;
1050     g_event_callback.display_language_changed_user_data = user_data;
1051
1052     return IME_ERROR_NONE;
1053 }
1054
1055 EXPORT_API int ime_event_set_rotation_degree_changed_cb(ime_rotation_degree_changed_cb callback_func, void *user_data)
1056 {
1057     ime_error_e retVal = IME_ERROR_NONE;
1058
1059     if (!callback_func) {
1060         LOGW("IME_ERROR_INVALID_PARAMETER");
1061         return IME_ERROR_INVALID_PARAMETER;
1062     }
1063
1064     retVal = _check_privilege();
1065     if (retVal != IME_ERROR_NONE) return retVal;
1066
1067     g_event_callback.rotation_degree_changed = callback_func;
1068     g_event_callback.rotation_degree_changed_user_data = user_data;
1069
1070     return IME_ERROR_NONE;
1071 }
1072
1073 EXPORT_API int ime_event_set_accessibility_state_changed_cb(ime_accessibility_state_changed_cb callback_func, void *user_data)
1074 {
1075     ime_error_e retVal = IME_ERROR_NONE;
1076
1077     if (!callback_func) {
1078         LOGW("IME_ERROR_INVALID_PARAMETER");
1079         return IME_ERROR_INVALID_PARAMETER;
1080     }
1081
1082     retVal = _check_privilege();
1083     if (retVal != IME_ERROR_NONE) return retVal;
1084
1085     g_event_callback.accessibility_state_changed = callback_func;
1086     g_event_callback.accessibility_state_changed_user_data = user_data;
1087
1088     return IME_ERROR_NONE;
1089 }
1090
1091 EXPORT_API int ime_event_set_option_window_created_cb(ime_option_window_created_cb callback_func, void *user_data)
1092 {
1093     ime_error_e retVal = IME_ERROR_NONE;
1094
1095     if (!callback_func) {
1096         LOGW("IME_ERROR_INVALID_PARAMETER");
1097         return IME_ERROR_INVALID_PARAMETER;
1098     }
1099
1100     retVal = _check_privilege();
1101     if (retVal != IME_ERROR_NONE) return retVal;
1102
1103     g_event_callback.option_window_created = callback_func;
1104     g_event_callback.option_window_created_user_data = user_data;
1105
1106     return IME_ERROR_NONE;
1107 }
1108
1109 EXPORT_API int ime_event_set_option_window_destroyed_cb(ime_option_window_destroyed_cb callback_func, void *user_data)
1110 {
1111     ime_error_e retVal = IME_ERROR_NONE;
1112
1113     if (!callback_func) {
1114         LOGW("IME_ERROR_INVALID_PARAMETER");
1115         return IME_ERROR_INVALID_PARAMETER;
1116     }
1117
1118     retVal = _check_privilege();
1119     if (retVal != IME_ERROR_NONE) return retVal;
1120
1121     g_event_callback.option_window_destroyed = callback_func;
1122     g_event_callback.option_window_destroyed_user_data = user_data;
1123
1124     return IME_ERROR_NONE;
1125 }
1126
1127 EXPORT_API int ime_event_set_input_hint_set_cb(ime_input_hint_set_cb callback_func, void *user_data)
1128 {
1129     ime_error_e retVal = IME_ERROR_NONE;
1130
1131     if (!callback_func) {
1132         LOGW("IME_ERROR_INVALID_PARAMETER");
1133         return IME_ERROR_INVALID_PARAMETER;
1134     }
1135
1136     retVal = _check_privilege();
1137     if (retVal != IME_ERROR_NONE) return retVal;
1138
1139     g_event_callback.input_hint_set = callback_func;
1140     g_event_callback.input_hint_set_user_data = user_data;
1141
1142     return IME_ERROR_NONE;
1143 }
1144
1145 EXPORT_API int ime_event_unset_input_hint_set_cb(void)
1146 {
1147     ime_error_e retVal = IME_ERROR_NONE;
1148
1149     retVal = _check_privilege();
1150     if (retVal != IME_ERROR_NONE) return retVal;
1151
1152     g_event_callback.input_hint_set = NULL;
1153     g_event_callback.input_hint_set_user_data = NULL;
1154
1155     return IME_ERROR_NONE;
1156 }
1157
1158 //LCOV_EXCL_START
1159 EXPORT_API int ime_event_set_caps_mode_changed_cb(ime_caps_mode_changed_cb callback_func, void *user_data)
1160 {
1161     ime_error_e retVal = IME_ERROR_NONE;
1162
1163     if (!callback_func) {
1164         LOGW("IME_ERROR_INVALID_PARAMETER");
1165         return IME_ERROR_INVALID_PARAMETER;
1166     }
1167
1168     retVal = _check_privilege();
1169     if (retVal != IME_ERROR_NONE) return retVal;
1170
1171     g_event_callback.caps_mode_changed = callback_func;
1172     g_event_callback.caps_mode_changed_user_data = user_data;
1173
1174     return IME_ERROR_NONE;
1175 }
1176
1177 EXPORT_API int ime_event_set_candidate_show_cb(ime_candidate_show_cb callback_func, void *user_data)
1178 {
1179     ime_error_e retVal = IME_ERROR_NONE;
1180
1181     if (!callback_func) {
1182         LOGW("IME_ERROR_INVALID_PARAMETER");
1183         return IME_ERROR_INVALID_PARAMETER;
1184     }
1185
1186     retVal = _check_privilege();
1187     if (retVal != IME_ERROR_NONE) return retVal;
1188
1189     g_event_callback.candidate_show = callback_func;
1190     g_event_callback.candidate_show_user_data = user_data;
1191
1192     return IME_ERROR_NONE;
1193 }
1194
1195 EXPORT_API int ime_event_set_candidate_hide_cb(ime_candidate_hide_cb callback_func, void *user_data)
1196 {
1197     ime_error_e retVal = IME_ERROR_NONE;
1198
1199     if (!callback_func) {
1200         LOGW("IME_ERROR_INVALID_PARAMETER");
1201         return IME_ERROR_INVALID_PARAMETER;
1202     }
1203
1204     retVal = _check_privilege();
1205     if (retVal != IME_ERROR_NONE) return retVal;
1206
1207     g_event_callback.candidate_hide = callback_func;
1208     g_event_callback.candidate_hide_user_data = user_data;
1209
1210     return IME_ERROR_NONE;
1211 }
1212
1213 EXPORT_API int ime_event_set_lookup_table_changed_cb(ime_lookup_table_changed_cb callback_func, void *user_data)
1214 {
1215     ime_error_e retVal = IME_ERROR_NONE;
1216
1217     if (!callback_func) {
1218         LOGW("IME_ERROR_INVALID_PARAMETER");
1219         return IME_ERROR_INVALID_PARAMETER;
1220     }
1221
1222     retVal = _check_privilege();
1223     if (retVal != IME_ERROR_NONE) return retVal;
1224
1225     g_event_callback.lookup_table_changed = callback_func;
1226     g_event_callback.lookup_table_changed_user_data = user_data;
1227
1228     return IME_ERROR_NONE;
1229 }
1230 //LCOV_EXCL_STOP
1231
1232 EXPORT_API int ime_send_key_event(ime_key_code_e keycode, ime_key_mask_e keymask, bool forward_key)
1233 {
1234     ime_error_e retVal = IME_ERROR_NONE;
1235
1236     if (!g_running) {
1237         LOGW("IME_ERROR_NOT_RUNNING");
1238         return IME_ERROR_NOT_RUNNING;
1239     }
1240
1241     //LCOV_EXCL_START
1242     retVal = _check_privilege();
1243     if (retVal != IME_ERROR_NONE) return retVal;
1244
1245     if (forward_key)
1246         g_core.forward_key_event(-1, NULL, (sclu32)keycode, (sclu16)keymask);
1247     else
1248         g_core.send_key_event(-1, NULL, (sclu32)keycode, (sclu16)keymask);
1249     //LCOV_EXCL_STOP
1250
1251     return IME_ERROR_NONE;
1252 }
1253
1254 EXPORT_API int ime_commit_string(const char *str)
1255 {
1256     ime_error_e retVal = IME_ERROR_NONE;
1257
1258     if (!str) {
1259         LOGW("IME_ERROR_INVALID_PARAMETER");
1260         return IME_ERROR_INVALID_PARAMETER;
1261     }
1262
1263     if (!g_running) {
1264         LOGW("IME_ERROR_NOT_RUNNING");
1265         return IME_ERROR_NOT_RUNNING;
1266     }
1267
1268     //LCOV_EXCL_START
1269     retVal = _check_privilege();
1270     if (retVal != IME_ERROR_NONE) return retVal;
1271
1272     SECURE_LOGI("commit string : %s", str);
1273     g_core.commit_string(-1, NULL, str);
1274
1275     return IME_ERROR_NONE;
1276     //LCOV_EXCL_STOP
1277 }
1278
1279 EXPORT_API int ime_show_preedit_string(void)
1280 {
1281     ime_error_e retVal = IME_ERROR_NONE;
1282
1283     if (!g_running) {
1284         LOGW("IME_ERROR_NOT_RUNNING");
1285         return IME_ERROR_NOT_RUNNING;
1286     }
1287
1288     //LCOV_EXCL_START
1289     retVal = _check_privilege();
1290     if (retVal != IME_ERROR_NONE) return retVal;
1291
1292     g_core.show_preedit_string(-1, NULL);
1293
1294     return IME_ERROR_NONE;
1295     //LCOV_EXCL_STOP
1296 }
1297
1298 EXPORT_API int ime_hide_preedit_string(void)
1299 {
1300     ime_error_e retVal = IME_ERROR_NONE;
1301
1302     if (!g_running) {
1303         LOGW("IME_ERROR_NOT_RUNNING");
1304         return IME_ERROR_NOT_RUNNING;
1305     }
1306
1307     //LCOV_EXCL_START
1308     retVal = _check_privilege();
1309     if (retVal != IME_ERROR_NONE) return retVal;
1310
1311     g_core.hide_preedit_string(-1, NULL);
1312
1313     return IME_ERROR_NONE;
1314     //LCOV_EXCL_STOP
1315 }
1316
1317 EXPORT_API int ime_update_preedit_string(const char *str, Eina_List *attrs)
1318 {
1319     ime_error_e retVal = IME_ERROR_NONE;
1320
1321     if (!str) {
1322         LOGW("IME_ERROR_INVALID_PARAMETER");
1323         return IME_ERROR_INVALID_PARAMETER;
1324     }
1325
1326     if (!g_running) {
1327         LOGW("IME_ERROR_NOT_RUNNING");
1328         return IME_ERROR_NOT_RUNNING;
1329     }
1330
1331     //LCOV_EXCL_START
1332     retVal = _check_privilege();
1333     if (retVal != IME_ERROR_NONE) return retVal;
1334
1335     scim::AttributeList attrv;
1336     void *data = NULL;
1337     ime_preedit_attribute *attr = NULL;
1338
1339     if (attrs) {
1340         EINA_LIST_FREE(attrs, data) {
1341             attr = (ime_preedit_attribute *)data;
1342             if (attr) {
1343                 attrv.push_back(scim::Attribute(attr->start, attr->length, (scim::AttributeType)attr->type, attr->value));
1344                 free(attr);
1345             }
1346         }
1347     }
1348
1349     SECURE_LOGI("preedit string : '%s'", str);
1350     g_core.update_preedit_string(-1, NULL, str, attrv);
1351
1352     return IME_ERROR_NONE;
1353     //LCOV_EXCL_STOP
1354 }
1355
1356 EXPORT_API int ime_update_preedit_cursor(unsigned int pos)
1357 {
1358     ime_error_e retVal = IME_ERROR_NONE;
1359
1360     if (!g_running) {
1361         LOGW("IME_ERROR_NOT_RUNNING");
1362         return IME_ERROR_NOT_RUNNING;
1363     }
1364
1365     retVal = _check_privilege();
1366     if (retVal != IME_ERROR_NONE) return retVal;
1367
1368     g_core.update_preedit_caret(pos);
1369
1370     return IME_ERROR_NONE;
1371 }
1372
1373 EXPORT_API int ime_request_surrounding_text(int maxlen_before, int maxlen_after)
1374 {
1375     ime_error_e retVal = IME_ERROR_NONE;
1376
1377     if (!g_event_callback.surrounding_text_updated) {
1378         LOGW("IME_ERROR_NO_CALLBACK_FUNCTION");
1379         return IME_ERROR_NO_CALLBACK_FUNCTION;
1380     }
1381
1382     if (!g_running) {
1383         LOGW("IME_ERROR_NOT_RUNNING");
1384         return IME_ERROR_NOT_RUNNING;
1385     }
1386
1387     //LCOV_EXCL_START
1388     retVal = _check_privilege();
1389     if (retVal != IME_ERROR_NONE) return retVal;
1390
1391     g_core.get_surrounding_text(NULL, maxlen_before, maxlen_after);
1392
1393     return IME_ERROR_NONE;
1394     //LCOV_EXCL_STOP
1395 }
1396
1397 EXPORT_API int ime_delete_surrounding_text(int offset, int len)
1398 {
1399     ime_error_e retVal = IME_ERROR_NONE;
1400
1401     if (len <= 0) {
1402         LOGW("IME_ERROR_INVALID_PARAMETER");
1403         return IME_ERROR_INVALID_PARAMETER;
1404     }
1405
1406     if (!g_running) {
1407         LOGW("IME_ERROR_NOT_RUNNING");
1408         return IME_ERROR_NOT_RUNNING;
1409     }
1410
1411     //LCOV_EXCL_START
1412     retVal = _check_privilege();
1413     if (retVal != IME_ERROR_NONE) return retVal;
1414
1415     LOGI("offset: %d, len : %d", offset, len);
1416     g_core.delete_surrounding_text(offset, len);
1417
1418     return IME_ERROR_NONE;
1419     //LCOV_EXCL_STOP
1420 }
1421
1422 EXPORT_API int ime_get_surrounding_text(int maxlen_before, int maxlen_after, char **text, int *cursor_pos)
1423 {
1424     ime_error_e retVal = IME_ERROR_NONE;
1425
1426     if (!text || !cursor_pos) {
1427         LOGW("IME_ERROR_INVALID_PARAMETER");
1428         return IME_ERROR_INVALID_PARAMETER;
1429     }
1430
1431     if (!g_running) {
1432         LOGW("IME_ERROR_NOT_RUNNING");
1433         return IME_ERROR_NOT_RUNNING;
1434     }
1435
1436     //LCOV_EXCL_START
1437     retVal = _check_privilege();
1438     if (retVal != IME_ERROR_NONE) return retVal;
1439
1440     int cursor = 0;
1441
1442     int ret = g_core.get_surrounding_text(maxlen_before, maxlen_after, text, cursor);
1443     if (ret == -1) {
1444         LOGW("IME_ERROR_OUR_OF_MEMORY");
1445         return IME_ERROR_OUT_OF_MEMORY;
1446     }
1447
1448     if (cursor_pos)
1449         *cursor_pos = cursor;
1450
1451     return IME_ERROR_NONE;
1452     //LCOV_EXCL_STOP
1453 }
1454
1455 EXPORT_API int ime_set_selection(int start, int end)
1456 {
1457     ime_error_e retVal = IME_ERROR_NONE;
1458
1459     if (start < 0) {
1460         LOGW("IME_ERROR_INVALID_PARAMETER");
1461         return IME_ERROR_INVALID_PARAMETER;
1462     }
1463
1464     if (!g_running) {
1465         LOGW("IME_ERROR_NOT_RUNNING");
1466         return IME_ERROR_NOT_RUNNING;
1467     }
1468
1469     //LCOV_EXCL_START
1470     retVal = _check_privilege();
1471     if (retVal != IME_ERROR_NONE) return retVal;
1472
1473     SECURE_LOGI("start: %d, end : %d", start, end);
1474     g_core.set_selection(start, end);
1475
1476     return IME_ERROR_NONE;
1477     //LCOV_EXCL_STOP
1478 }
1479
1480 EXPORT_API int ime_get_selected_text(char **text)
1481 {
1482     ime_error_e retVal = IME_ERROR_NONE;
1483
1484     if (!text) {
1485         LOGW("IME_ERROR_INVALID_PARAMETER");
1486         return IME_ERROR_INVALID_PARAMETER;
1487     }
1488
1489     if (!g_running) {
1490         LOGW("IME_ERROR_NOT_RUNNING");
1491         return IME_ERROR_NOT_RUNNING;
1492     }
1493
1494     //LCOV_EXCL_START
1495     retVal = _check_privilege();
1496     if (retVal != IME_ERROR_NONE) return retVal;
1497
1498     g_core.get_selection_text(text);
1499
1500     return IME_ERROR_NONE;
1501     //LCOV_EXCL_STOP
1502 }
1503
1504 EXPORT_API Evas_Object* ime_get_main_window(void)
1505 {
1506     ime_error_e retVal = IME_ERROR_NONE;
1507
1508     Evas_Object *win = NULL;
1509
1510     retVal = _check_privilege();
1511     if (retVal != IME_ERROR_NONE) {
1512         //LCOV_EXCL_START
1513         LOGE("_check_privilege returned %d.", retVal);
1514         set_last_result(retVal);
1515         return NULL;
1516         //LCOV_EXCL_STOP
1517     }
1518
1519     if (!g_running) {
1520         set_last_result(IME_ERROR_NOT_RUNNING);
1521         LOGW("IME_ERROR_NOT_RUNNING");
1522         return NULL;
1523     }
1524
1525     //LCOV_EXCL_START
1526     win = static_cast<Evas_Object*>(g_core.get_main_window());
1527     if (win) {
1528         set_last_result(IME_ERROR_NONE);
1529     } else {
1530         set_last_result(IME_ERROR_OPERATION_FAILED);
1531         LOGW("IME_ERROR_OPERATION_FAILED");
1532     }
1533
1534     return win;
1535     //LCOV_EXCL_STOP
1536 }
1537
1538 EXPORT_API int ime_set_size(int portrait_width, int portrait_height, int landscape_width, int landscape_height)
1539 {
1540     ime_error_e retVal = IME_ERROR_NONE;
1541
1542     SclSize portrait_size, landscape_size;
1543
1544     if (portrait_width < 1 || portrait_height < 1 || landscape_width < 1 || landscape_height < 1) {
1545         LOGW("IME_ERROR_INVALID_PARAMETER");
1546         return IME_ERROR_INVALID_PARAMETER;
1547     }
1548
1549     if (!g_running) {
1550         LOGW("IME_ERROR_NOT_RUNNING");
1551         return IME_ERROR_NOT_RUNNING;
1552     }
1553
1554     //LCOV_EXCL_START
1555     retVal = _check_privilege();
1556     if (retVal != IME_ERROR_NONE) return retVal;
1557
1558     portrait_size.width = portrait_width;
1559     portrait_size.height = portrait_height;
1560
1561     landscape_size.width = landscape_width;
1562     landscape_size.height = landscape_height;
1563
1564     g_core.set_keyboard_size_hints(portrait_size, landscape_size);
1565
1566     return IME_ERROR_NONE;
1567     //LCOV_EXCL_STOP
1568 }
1569
1570 //LCOV_EXCL_START
1571 EXPORT_API int ime_set_native_window_size(Ecore_Wl2_Window *window, int portrait_width, int portrait_height, int landscape_width, int landscape_height)
1572 {
1573     ime_error_e retVal = IME_ERROR_NONE;
1574
1575     if (!window || portrait_width < 1 || portrait_height < 1 || landscape_width < 1 || landscape_height < 1) {
1576         LOGW("IME_ERROR_INVALID_PARAMETER");
1577         return IME_ERROR_INVALID_PARAMETER;
1578     }
1579
1580     if (!g_running) {
1581         LOGW("IME_ERROR_NOT_RUNNING");
1582         return IME_ERROR_NOT_RUNNING;
1583     }
1584
1585     retVal = _check_privilege();
1586     if (retVal != IME_ERROR_NONE) return retVal;
1587
1588     ecore_wl2_window_rotation_geometry_set(window, 0, 0, 0, portrait_width, portrait_height);
1589     ecore_wl2_window_rotation_geometry_set(window, 90, 0, 0, landscape_height, landscape_width);
1590     ecore_wl2_window_rotation_geometry_set(window, 180, 0, 0, portrait_width, portrait_height);
1591     ecore_wl2_window_rotation_geometry_set(window, 270, 0, 0, landscape_height, landscape_width);
1592
1593     return IME_ERROR_NONE;
1594 }
1595 //LCOV_EXCL_STOP
1596
1597 EXPORT_API int ime_create_option_window(void)
1598 {
1599     ime_error_e retVal = IME_ERROR_NONE;
1600
1601     if (!g_event_callback.option_window_created || !g_event_callback.option_window_destroyed) {
1602         LOGW("ime_create_option_window_cb() and ime_destroy_option_window_cb() callback functions are not set.");
1603         return IME_ERROR_NO_CALLBACK_FUNCTION;
1604     }
1605
1606     if (!g_running) {
1607         LOGW("IME_ERROR_NOT_RUNNING");
1608         return IME_ERROR_NOT_RUNNING;
1609     }
1610
1611     //LCOV_EXCL_START
1612     retVal = _check_privilege();
1613     if (retVal != IME_ERROR_NONE) return retVal;
1614
1615     if (g_core.create_option_window()) {
1616         return IME_ERROR_NONE;
1617     } else {
1618         LOGW("IME_ERROR_OPERATION_FAILED");
1619         return IME_ERROR_OPERATION_FAILED;
1620     }
1621     //LCOV_EXCL_STOP
1622 }
1623
1624 EXPORT_API int ime_destroy_option_window(Evas_Object *window)
1625 {
1626     ime_error_e retVal = IME_ERROR_NONE;
1627
1628     if (!g_event_callback.option_window_created || !g_event_callback.option_window_destroyed) {
1629         LOGW("ime_create_option_window_cb() and ime_destroy_option_window_cb() callback functions are not set.");
1630         return IME_ERROR_NO_CALLBACK_FUNCTION;
1631     }
1632
1633     if (!window) {
1634         LOGW("Window pointer is null.");
1635         return IME_ERROR_INVALID_PARAMETER;
1636     }
1637
1638     if (!g_running) {
1639         LOGW("IME_ERROR_NOT_RUNNING");
1640         return IME_ERROR_NOT_RUNNING;
1641     }
1642
1643     //LCOV_EXCL_START
1644     retVal = _check_privilege();
1645     if (retVal != IME_ERROR_NONE) return retVal;
1646
1647     g_core.destroy_option_window(window);
1648
1649     return IME_ERROR_NONE;
1650     //LCOV_EXCL_STOP
1651 }
1652
1653 //LCOV_EXCL_START
1654 EXPORT_API int ime_set_imengine(const char *engine_id)
1655 {
1656     ime_error_e retVal = IME_ERROR_NONE;
1657
1658     if (!engine_id) {
1659         LOGW("IME_ERROR_INVALID_PARAMETER");
1660         return IME_ERROR_INVALID_PARAMETER;
1661     }
1662
1663     retVal = _check_privilege();
1664     if (retVal != IME_ERROR_NONE) return retVal;
1665
1666     g_core.set_keyboard_ise_by_uuid(engine_id);
1667
1668     return IME_ERROR_NONE;
1669 }
1670
1671 EXPORT_API int ime_flush_imengine(void)
1672 {
1673     ime_error_e retVal = IME_ERROR_NONE;
1674
1675     if (!g_running) {
1676         LOGW("IME_ERROR_NOT_RUNNING");
1677         return IME_ERROR_NOT_RUNNING;
1678     }
1679
1680     retVal = _check_privilege();
1681     if (retVal != IME_ERROR_NONE) return retVal;
1682
1683     g_core.flush_keyboard_ise();
1684
1685     return IME_ERROR_NONE;
1686 }
1687
1688 EXPORT_API int ime_send_imengine_event(int command, unsigned int value)
1689 {
1690     ime_error_e retVal = IME_ERROR_NONE;
1691
1692     if (!g_running) {
1693         LOGW("IME_ERROR_NOT_RUNNING");
1694         return IME_ERROR_NOT_RUNNING;
1695     }
1696
1697     retVal = _check_privilege();
1698     if (retVal != IME_ERROR_NONE) return retVal;
1699
1700     g_core.send_imengine_event(-1, NULL, command, value);
1701
1702     return IME_ERROR_NONE;
1703 }
1704
1705 EXPORT_API int ime_reset_imengine(void)
1706 {
1707     ime_error_e retVal = IME_ERROR_NONE;
1708
1709     if (!g_running) {
1710         LOGW("IME_ERROR_NOT_RUNNING");
1711         return IME_ERROR_NOT_RUNNING;
1712     }
1713
1714     retVal = _check_privilege();
1715     if (retVal != IME_ERROR_NONE) return retVal;
1716
1717     g_core.reset_keyboard_ise();
1718
1719     return IME_ERROR_NONE;
1720 }
1721
1722 EXPORT_API int ime_update_input_context(unsigned int type, unsigned int value)
1723 {
1724     ime_error_e retVal = IME_ERROR_NONE;
1725
1726     if (!g_running) {
1727         LOGW("IME_ERROR_NOT_RUNNING");
1728         return IME_ERROR_NOT_RUNNING;
1729     }
1730
1731     retVal = _check_privilege();
1732     if (retVal != IME_ERROR_NONE) return retVal;
1733
1734     g_core.update_input_context(type, value);
1735
1736     return IME_ERROR_NONE;
1737 }
1738 //LCOV_EXCL_STOP
1739
1740 EXPORT_API int ime_request_hide(void)
1741 {
1742     ime_error_e retVal = IME_ERROR_NONE;
1743
1744     if (!g_running) {
1745         LOGW("IME_ERROR_NOT_RUNNING");
1746         return IME_ERROR_NOT_RUNNING;
1747     }
1748
1749     //LCOV_EXCL_START
1750     retVal = _check_privilege();
1751     if (retVal != IME_ERROR_NONE) return retVal;
1752
1753     g_core.request_ise_hide();
1754
1755     return IME_ERROR_NONE;
1756     //LCOV_EXCL_STOP
1757 }
1758
1759 //LCOV_EXCL_START
1760 EXPORT_API int ime_initialize(void)
1761 {
1762     ime_error_e retVal = IME_ERROR_NONE;
1763
1764     retVal = _check_privilege();
1765     if (retVal != IME_ERROR_NONE) return retVal;
1766
1767     g_core.init();
1768     g_running = false;
1769
1770     return retVal;
1771 }
1772
1773 EXPORT_API int ime_prepare(void)
1774 {
1775     ime_error_e retVal = IME_ERROR_NONE;
1776
1777     if (g_running) {
1778         LOGE("inputmethod main loop is already running.");
1779         return IME_ERROR_OPERATION_FAILED;
1780     }
1781
1782     retVal = _check_privilege();
1783     if (retVal != IME_ERROR_NONE) return retVal;
1784
1785     g_core.set_dotnet_flag(g_from_dotnet);
1786     g_core.prepare();
1787
1788     g_running = true;
1789
1790     return retVal;
1791 }
1792
1793 EXPORT_API int ime_finalize(void)
1794 {
1795     ime_error_e retVal = IME_ERROR_NONE;
1796
1797     retVal = _check_privilege();
1798     if (retVal != IME_ERROR_NONE) return retVal;
1799
1800     g_core.fini();
1801     g_running = false;
1802     memset(&g_basic_callback, 0, sizeof(ime_callback_s));
1803     memset(&g_event_callback, 0, sizeof(ime_event_callback_s));
1804     g_user_data = NULL;
1805
1806     return retVal;
1807 }
1808
1809 EXPORT_API int ime_select_candidate(unsigned int index)
1810 {
1811     ime_error_e retVal = IME_ERROR_NONE;
1812
1813     if (!g_running) {
1814         LOGW("IME_ERROR_NOT_RUNNING");
1815         return IME_ERROR_NOT_RUNNING;
1816     }
1817
1818     retVal = _check_privilege();
1819     if (retVal != IME_ERROR_NONE) return retVal;
1820
1821     g_core.select_candidate(index);
1822
1823     return IME_ERROR_NONE;
1824 }
1825 //LCOV_EXCL_STOP
1826
1827 EXPORT_API int ime_send_private_command(const char *command)
1828 {
1829     ime_error_e retVal = IME_ERROR_NONE;
1830
1831     if (!command) {
1832         LOGW("IME_ERROR_INVALID_PARAMETER");
1833         return IME_ERROR_INVALID_PARAMETER;
1834     }
1835
1836     if (!g_running) {
1837         LOGW("IME_ERROR_NOT_RUNNING");
1838         return IME_ERROR_NOT_RUNNING;
1839     }
1840
1841     //LCOV_EXCL_START
1842     retVal = _check_privilege();
1843     if (retVal != IME_ERROR_NONE) return retVal;
1844
1845     g_core.send_private_command(command);
1846
1847     return IME_ERROR_NONE;
1848     //LCOV_EXCL_STOP
1849 }
1850
1851 EXPORT_API int ime_commit_content(const char *content, const char *description, const char *mime_type)
1852 {
1853     ime_error_e retVal = IME_ERROR_NONE;
1854
1855     if (!content || !description || !mime_type) {
1856         LOGW("IME_ERROR_INVALID_PARAMETER");
1857         return IME_ERROR_INVALID_PARAMETER;
1858     }
1859
1860     retVal = _check_privilege();
1861     if (retVal != IME_ERROR_NONE) return retVal;
1862
1863     if (!g_running) {
1864         LOGW("IME_ERROR_NOT_RUNNING");
1865         return IME_ERROR_NOT_RUNNING;
1866     }
1867
1868     //LCOV_EXCL_START
1869     SECURE_LOGI("content : '%s', description : '%s', mime_type : '%s'", content, description, mime_type);
1870     g_core.commit_content(content, description, mime_type);
1871
1872     return IME_ERROR_NONE;
1873     //LCOV_EXCL_STOP
1874 }
1875
1876 EXPORT_API int ime_context_get_layout(ime_context_h context, Ecore_IMF_Input_Panel_Layout *layout)
1877 {
1878     ime_error_e retVal = IME_ERROR_NONE;
1879
1880     if (!context || !layout) {
1881         LOGW("IME_ERROR_INVALID_PARAMETER");
1882         return IME_ERROR_INVALID_PARAMETER;
1883     }
1884
1885     retVal = _check_privilege();
1886     if (retVal != IME_ERROR_NONE) return retVal;
1887
1888     if (!g_running) {
1889         LOGW("IME_ERROR_NOT_RUNNING");
1890         return IME_ERROR_NOT_RUNNING;
1891     }
1892
1893     //LCOV_EXCL_START
1894     *layout = context->layout;
1895
1896     return IME_ERROR_NONE;
1897     //LCOV_EXCL_STOP
1898 }
1899
1900 EXPORT_API int ime_context_get_layout_variation(ime_context_h context, ime_layout_variation_e *layout_variation)
1901 {
1902     ime_error_e retVal = IME_ERROR_NONE;
1903
1904     if (!context || !layout_variation) {
1905         LOGW("IME_ERROR_INVALID_PARAMETER");
1906         return IME_ERROR_INVALID_PARAMETER;
1907     }
1908
1909     retVal = _check_privilege();
1910     if (retVal != IME_ERROR_NONE) return retVal;
1911
1912     if (!g_running) {
1913         LOGW("IME_ERROR_NOT_RUNNING");
1914         return IME_ERROR_NOT_RUNNING;
1915     }
1916
1917     //LCOV_EXCL_START
1918     *layout_variation = static_cast<ime_layout_variation_e>(context->layout_variation);
1919
1920     return IME_ERROR_NONE;
1921     //LCOV_EXCL_STOP
1922 }
1923
1924 EXPORT_API int ime_context_get_cursor_position(ime_context_h context, int *cursor_pos)
1925 {
1926     ime_error_e retVal = IME_ERROR_NONE;
1927
1928     if (!context || !cursor_pos) {
1929         LOGW("IME_ERROR_INVALID_PARAMETER");
1930         return IME_ERROR_INVALID_PARAMETER;
1931     }
1932
1933     retVal = _check_privilege();
1934     if (retVal != IME_ERROR_NONE) return retVal;
1935
1936     if (!g_running) {
1937         LOGW("IME_ERROR_NOT_RUNNING");
1938         return IME_ERROR_NOT_RUNNING;
1939     }
1940
1941     //LCOV_EXCL_START
1942     *cursor_pos = context->cursor_pos;
1943
1944     return IME_ERROR_NONE;
1945     //LCOV_EXCL_STOP
1946 }
1947
1948 EXPORT_API int ime_context_get_autocapital_type(ime_context_h context, Ecore_IMF_Autocapital_Type *autocapital_type)
1949 {
1950     ime_error_e retVal = IME_ERROR_NONE;
1951
1952     if (!context || !autocapital_type) {
1953         LOGW("IME_ERROR_INVALID_PARAMETER");
1954         return IME_ERROR_INVALID_PARAMETER;
1955     }
1956
1957     retVal = _check_privilege();
1958     if (retVal != IME_ERROR_NONE) return retVal;
1959
1960     if (!g_running) {
1961         LOGW("IME_ERROR_NOT_RUNNING");
1962         return IME_ERROR_NOT_RUNNING;
1963     }
1964
1965     //LCOV_EXCL_START
1966     *autocapital_type = context->autocapital_type;
1967
1968     return IME_ERROR_NONE;
1969     //LCOV_EXCL_STOP
1970 }
1971
1972 EXPORT_API int ime_context_get_return_key_type(ime_context_h context, Ecore_IMF_Input_Panel_Return_Key_Type *return_key_type)
1973 {
1974     ime_error_e retVal = IME_ERROR_NONE;
1975
1976     if (!context || !return_key_type) {
1977         LOGW("IME_ERROR_INVALID_PARAMETER");
1978         return IME_ERROR_INVALID_PARAMETER;
1979     }
1980
1981     retVal = _check_privilege();
1982     if (retVal != IME_ERROR_NONE) return retVal;
1983
1984     if (!g_running) {
1985         LOGW("IME_ERROR_NOT_RUNNING");
1986         return IME_ERROR_NOT_RUNNING;
1987     }
1988
1989     //LCOV_EXCL_START
1990     *return_key_type = context->return_key_type;
1991
1992     return IME_ERROR_NONE;
1993     //LCOV_EXCL_STOP
1994 }
1995
1996 EXPORT_API int ime_context_get_return_key_state(ime_context_h context, bool *return_key_state)
1997 {
1998     ime_error_e retVal = IME_ERROR_NONE;
1999
2000     if (!context || !return_key_state) {
2001         LOGW("IME_ERROR_INVALID_PARAMETER");
2002         return IME_ERROR_INVALID_PARAMETER;
2003     }
2004
2005     retVal = _check_privilege();
2006     if (retVal != IME_ERROR_NONE) return retVal;
2007
2008     if (!g_running) {
2009         LOGW("IME_ERROR_NOT_RUNNING");
2010         return IME_ERROR_NOT_RUNNING;
2011     }
2012
2013     //LCOV_EXCL_START
2014     *return_key_state = static_cast<bool>(context->return_key_disabled);
2015
2016     return IME_ERROR_NONE;
2017     //LCOV_EXCL_STOP
2018 }
2019
2020 EXPORT_API int ime_context_get_prediction_mode(ime_context_h context, bool *prediction_mode)
2021 {
2022     ime_error_e retVal = IME_ERROR_NONE;
2023
2024     if (!context || !prediction_mode) {
2025         LOGW("IME_ERROR_INVALID_PARAMETER");
2026         return IME_ERROR_INVALID_PARAMETER;
2027     }
2028
2029     retVal = _check_privilege();
2030     if (retVal != IME_ERROR_NONE) return retVal;
2031
2032     if (!g_running) {
2033         LOGW("IME_ERROR_NOT_RUNNING");
2034         return IME_ERROR_NOT_RUNNING;
2035     }
2036
2037     //LCOV_EXCL_START
2038     *prediction_mode = static_cast<bool>(context->prediction_allow);
2039
2040     return IME_ERROR_NONE;
2041     //LCOV_EXCL_STOP
2042 }
2043
2044 EXPORT_API int ime_context_get_password_mode(ime_context_h context, bool *password_mode)
2045 {
2046     ime_error_e retVal = IME_ERROR_NONE;
2047
2048     if (!context || !password_mode) {
2049         LOGW("IME_ERROR_INVALID_PARAMETER");
2050         return IME_ERROR_INVALID_PARAMETER;
2051     }
2052
2053     retVal = _check_privilege();
2054     if (retVal != IME_ERROR_NONE) return retVal;
2055
2056     if (!g_running) {
2057         LOGW("IME_ERROR_NOT_RUNNING");
2058         return IME_ERROR_NOT_RUNNING;
2059     }
2060
2061     //LCOV_EXCL_START
2062     *password_mode = static_cast<bool>(context->password_mode);
2063
2064     return IME_ERROR_NONE;
2065     //LCOV_EXCL_STOP
2066 }
2067
2068 EXPORT_API int ime_context_get_input_hint(ime_context_h context, Ecore_IMF_Input_Hints *input_hint)
2069 {
2070     ime_error_e retVal = IME_ERROR_NONE;
2071
2072     if (!context || !input_hint) {
2073         LOGW("IME_ERROR_INVALID_PARAMETER");
2074         return IME_ERROR_INVALID_PARAMETER;
2075     }
2076
2077     retVal = _check_privilege();
2078     if (retVal != IME_ERROR_NONE) return retVal;
2079
2080     if (!g_running) {
2081         LOGW("IME_ERROR_NOT_RUNNING");
2082         return IME_ERROR_NOT_RUNNING;
2083     }
2084
2085     //LCOV_EXCL_START
2086     *input_hint = context->input_hint;
2087
2088     return IME_ERROR_NONE;
2089     //LCOV_EXCL_STOP
2090 }
2091
2092 EXPORT_API int ime_context_get_bidi_direction(ime_context_h context, Ecore_IMF_BiDi_Direction *bidi)
2093 {
2094     ime_error_e retVal = IME_ERROR_NONE;
2095
2096     if (!context || !bidi) {
2097         LOGW("IME_ERROR_INVALID_PARAMETER");
2098         return IME_ERROR_INVALID_PARAMETER;
2099     }
2100
2101     retVal = _check_privilege();
2102     if (retVal != IME_ERROR_NONE) return retVal;
2103
2104     if (!g_running) {
2105         LOGW("IME_ERROR_NOT_RUNNING");
2106         return IME_ERROR_NOT_RUNNING;
2107     }
2108
2109     //LCOV_EXCL_START
2110     *bidi = context->bidi_direction;
2111
2112     return IME_ERROR_NONE;
2113     //LCOV_EXCL_STOP
2114 }
2115
2116 EXPORT_API int ime_context_get_language(ime_context_h context, Ecore_IMF_Input_Panel_Lang *language)
2117 {
2118     ime_error_e retVal = IME_ERROR_NONE;
2119
2120     if (!context || !language) {
2121         LOGW("IME_ERROR_INVALID_PARAMETER");
2122         return IME_ERROR_INVALID_PARAMETER;
2123     }
2124
2125     retVal = _check_privilege();
2126     if (retVal != IME_ERROR_NONE) return retVal;
2127
2128     if (!g_running) {
2129         LOGW("IME_ERROR_NOT_RUNNING");
2130         return IME_ERROR_NOT_RUNNING;
2131     }
2132
2133     //LCOV_EXCL_START
2134     *language = context->language;
2135
2136     return IME_ERROR_NONE;
2137     //LCOV_EXCL_STOP
2138 }
2139
2140 //LCOV_EXCL_START
2141 EXPORT_API int ime_context_get_caps_mode(ime_context_h context, bool *caps_mode)
2142 {
2143     ime_error_e retVal = IME_ERROR_NONE;
2144
2145     if (!context || !caps_mode) {
2146         LOGW("IME_ERROR_INVALID_PARAMETER");
2147         return IME_ERROR_INVALID_PARAMETER;
2148     }
2149
2150     retVal = _check_privilege();
2151     if (retVal != IME_ERROR_NONE) return retVal;
2152
2153     if (!g_running) {
2154         LOGW("IME_ERROR_NOT_RUNNING");
2155         return IME_ERROR_NOT_RUNNING;
2156     }
2157
2158     *caps_mode = static_cast<bool>(context->caps_mode);
2159
2160     return IME_ERROR_NONE;
2161 }
2162 //LCOV_EXCL_STOP
2163
2164 EXPORT_API int ime_device_info_get_name(ime_device_info_h dev_info, char **dev_name)
2165 {
2166     ime_error_e retVal = IME_ERROR_NONE;
2167
2168     if (!dev_info || !dev_name) {
2169         LOGW("IME_ERROR_INVALID_PARAMETER");
2170         return IME_ERROR_INVALID_PARAMETER;
2171     }
2172
2173     retVal = _check_privilege();
2174     if (retVal != IME_ERROR_NONE) return retVal;
2175
2176     if (!g_running) {
2177         LOGW("IME_ERROR_NOT_RUNNING");
2178         return IME_ERROR_NOT_RUNNING;
2179     }
2180
2181     //LCOV_EXCL_START
2182     if (!dev_info->dev_name)
2183         *dev_name = strdup("");
2184     else
2185         *dev_name = strdup(dev_info->dev_name);
2186
2187     return IME_ERROR_NONE;
2188     //LCOV_EXCL_STOP
2189 }
2190
2191 EXPORT_API int ime_device_info_get_class(ime_device_info_h dev_info, Ecore_IMF_Device_Class *dev_class)
2192 {
2193     ime_error_e retVal = IME_ERROR_NONE;
2194
2195     if (!dev_info || !dev_class) {
2196         LOGW("IME_ERROR_INVALID_PARAMETER");
2197         return IME_ERROR_INVALID_PARAMETER;
2198     }
2199
2200     retVal = _check_privilege();
2201     if (retVal != IME_ERROR_NONE) return retVal;
2202
2203     if (!g_running) {
2204         LOGW("IME_ERROR_NOT_RUNNING");
2205         return IME_ERROR_NOT_RUNNING;
2206     }
2207
2208     //LCOV_EXCL_START
2209     *dev_class = dev_info->dev_class;
2210
2211     return IME_ERROR_NONE;
2212     //LCOV_EXCL_STOP
2213 }
2214
2215 EXPORT_API int ime_device_info_get_subclass(ime_device_info_h dev_info, Ecore_IMF_Device_Subclass *dev_subclass)
2216 {
2217     ime_error_e retVal = IME_ERROR_NONE;
2218
2219     if (!dev_info || !dev_subclass) {
2220         LOGW("IME_ERROR_INVALID_PARAMETER");
2221         return IME_ERROR_INVALID_PARAMETER;
2222     }
2223
2224     retVal = _check_privilege();
2225     if (retVal != IME_ERROR_NONE) return retVal;
2226
2227     if (!g_running) {
2228         LOGW("IME_ERROR_NOT_RUNNING");
2229         return IME_ERROR_NOT_RUNNING;
2230     }
2231
2232     //LCOV_EXCL_START
2233     *dev_subclass = dev_info->dev_subclass;
2234
2235     return IME_ERROR_NONE;
2236     //LCOV_EXCL_STOP
2237 }
2238
2239 //LCOV_EXCL_START
2240 EXPORT_API int ime_event_set_process_input_device_event_cb(ime_process_input_device_event_cb callback_func, void *user_data)
2241 {
2242     ime_error_e retVal = IME_ERROR_NONE;
2243
2244     if (!callback_func) {
2245         LOGW("IME_ERROR_INVALID_PARAMETER");
2246         return IME_ERROR_INVALID_PARAMETER;
2247     }
2248
2249     retVal = _check_privilege();
2250     if (retVal != IME_ERROR_NONE) return retVal;
2251
2252     g_event_callback.process_input_device_event = callback_func;
2253     g_event_callback.process_input_device_event_user_data = user_data;
2254
2255     return IME_ERROR_NONE;
2256 }
2257
2258 EXPORT_API int ime_event_unset_process_input_device_event_cb(void)
2259 {
2260     ime_error_e retVal = IME_ERROR_NONE;
2261
2262     retVal = _check_privilege();
2263     if (retVal != IME_ERROR_NONE) return retVal;
2264
2265     g_event_callback.process_input_device_event = NULL;
2266     g_event_callback.process_input_device_event_user_data = NULL;
2267
2268     return IME_ERROR_NONE;
2269 }
2270
2271 /* Functions for Rotary input device event */
2272 EXPORT_API int ime_input_device_rotary_get_direction(ime_input_device_event_h event_handle, ime_input_device_rotary_direction_e *direction)
2273 {
2274     ime_error_e retVal = IME_ERROR_NONE;
2275
2276     if (!event_handle || !direction) {
2277         LOGW("IME_ERROR_INVALID_PARAMETER");
2278         return IME_ERROR_INVALID_PARAMETER;
2279     }
2280
2281     ime_device_event_s *device_event = static_cast<ime_device_event_s*>(event_handle);
2282     if (device_event->device_type != IME_INPUT_DEVICE_TYPE_ROTARY) {
2283         LOGW("IME_ERROR_INVALID_PARAMETER");
2284         return IME_ERROR_INVALID_PARAMETER;
2285     }
2286
2287     retVal = _check_privilege();
2288     if (retVal != IME_ERROR_NONE) return retVal;
2289
2290     if (!g_running) {
2291         LOGW("IME_ERROR_OPERATION_FAILED");
2292         return IME_ERROR_OPERATION_FAILED;
2293     }
2294
2295     //LCOV_EXCL_START
2296     Ecore_Event_Detent_Rotate *rotary_device_event =
2297         static_cast<Ecore_Event_Detent_Rotate*>(device_event->event_data);
2298     if (rotary_device_event) {
2299         if (rotary_device_event->direction == ECORE_DETENT_DIRECTION_CLOCKWISE) {
2300             *direction = IME_INPUT_DEVICE_ROTARY_DIRECTION_CLOCKWISE;
2301         } else if (rotary_device_event->direction == ECORE_DETENT_DIRECTION_COUNTER_CLOCKWISE) {
2302             *direction = IME_INPUT_DEVICE_ROTARY_DIRECTION_COUNTER_CLOCKWISE;
2303         }
2304     }
2305
2306     return IME_ERROR_NONE;
2307     //LCOV_EXCL_STOP
2308 }
2309 //LCOV_EXCL_STOP
2310
2311 EXPORT_API int ime_event_set_prediction_hint_set_cb(ime_prediction_hint_set_cb callback_func, void *user_data)
2312 {
2313     ime_error_e retVal = IME_ERROR_NONE;
2314
2315     if (!callback_func) {
2316         LOGW("IME_ERROR_INVALID_PARAMETER");
2317         return IME_ERROR_INVALID_PARAMETER;
2318     }
2319
2320     retVal = _check_privilege();
2321     if (retVal != IME_ERROR_NONE) return retVal;
2322
2323     g_event_callback.prediction_hint_set = callback_func;
2324     g_event_callback.prediction_hint_set_user_data = user_data;
2325
2326     return IME_ERROR_NONE;
2327 }
2328
2329 EXPORT_API int ime_event_set_mime_type_set_request_cb(ime_mime_type_set_request_cb callback_func, void *user_data)
2330 {
2331     ime_error_e retVal = IME_ERROR_NONE;
2332
2333     if (!callback_func) {
2334         LOGW("IME_ERROR_INVALID_PARAMETER");
2335         return IME_ERROR_INVALID_PARAMETER;
2336     }
2337
2338     retVal = _check_privilege();
2339     if (retVal != IME_ERROR_NONE) return retVal;
2340
2341     g_event_callback.mime_type_set = callback_func;
2342     g_event_callback.mime_type_set_user_data = user_data;
2343
2344     return IME_ERROR_NONE;
2345 }
2346
2347 EXPORT_API int ime_set_floating_mode(bool floating_mode)
2348 {
2349     ime_error_e retVal = IME_ERROR_NONE;
2350
2351     retVal = _check_privilege();
2352     if (retVal != IME_ERROR_NONE) return retVal;
2353
2354     if (!g_running) {
2355         LOGW("IME_ERROR_NOT_RUNNING");
2356         return IME_ERROR_NOT_RUNNING;
2357     }
2358
2359     //LCOV_EXCL_START
2360     g_core.set_floating_mode(floating_mode);
2361
2362     return IME_ERROR_NONE;
2363     //LCOV_EXCL_STOP
2364 }
2365
2366 EXPORT_API int ime_set_floating_drag_start(void)
2367 {
2368     ime_error_e retVal = IME_ERROR_NONE;
2369
2370     retVal = _check_privilege();
2371     if (retVal != IME_ERROR_NONE) return retVal;
2372
2373     if (!g_running) {
2374         LOGW("IME_ERROR_NOT_RUNNING");
2375         return IME_ERROR_NOT_RUNNING;
2376     }
2377
2378     //LCOV_EXCL_START
2379     g_core.set_floating_drag_enabled(true);
2380
2381     return IME_ERROR_NONE;
2382     //LCOV_EXCL_STOP
2383 }
2384
2385 EXPORT_API int ime_set_floating_drag_end(void)
2386 {
2387     ime_error_e retVal = IME_ERROR_NONE;
2388
2389     retVal = _check_privilege();
2390     if (retVal != IME_ERROR_NONE) return retVal;
2391
2392     if (!g_running) {
2393         LOGW("IME_ERROR_NOT_RUNNING");
2394         return IME_ERROR_NOT_RUNNING;
2395     }
2396
2397     //LCOV_EXCL_START
2398     g_core.set_floating_drag_enabled(false);
2399
2400     return IME_ERROR_NONE;
2401     //LCOV_EXCL_STOP
2402 }
2403
2404 //LCOV_EXCL_START
2405 EXPORT_API int ime_set_window_creation_defer_flag(bool flag)
2406 {
2407     ime_error_e retVal = IME_ERROR_NONE;
2408
2409     retVal = _check_privilege();
2410     if (retVal != IME_ERROR_NONE) return retVal;
2411
2412     g_core.set_window_creation_defer_flag(flag);
2413
2414     return IME_ERROR_NONE;
2415 }
2416 //LCOV_EXCL_STOP
2417
2418 EXPORT_API int ime_event_set_prediction_hint_data_set_cb(ime_prediction_hint_data_set_cb callback_func, void *user_data)
2419 {
2420     ime_error_e retVal = IME_ERROR_NONE;
2421
2422     if (!callback_func) {
2423         LOGW("IME_ERROR_INVALID_PARAMETER");
2424         return IME_ERROR_INVALID_PARAMETER;
2425     }
2426
2427     retVal = _check_privilege();
2428     if (retVal != IME_ERROR_NONE) return retVal;
2429
2430     g_event_callback.prediction_hint_data_set = callback_func;
2431     g_event_callback.prediction_hint_data_set_user_data = user_data;
2432
2433     return IME_ERROR_NONE;
2434 }
2435
2436 //LCOV_EXCL_START
2437 EXPORT_API int ime_event_set_optimization_hint_set_cb(ime_optimization_hint_set_cb callback_func, void *user_data)
2438 {
2439     LOGD("");
2440     ime_error_e retVal = IME_ERROR_NONE;
2441
2442     if (!callback_func) {
2443         LOGW("IME_ERROR_INVALID_PARAMETER");
2444         return IME_ERROR_INVALID_PARAMETER;
2445     }
2446
2447     retVal = _check_privilege();
2448     if (retVal != IME_ERROR_NONE) return retVal;
2449
2450     g_event_callback.optimization_hint_set = callback_func;
2451     g_event_callback.optimization_hint_set_user_data = user_data;
2452
2453     return IME_ERROR_NONE;
2454 }
2455
2456 EXPORT_API int ime_event_set_process_key_event_with_imengine_cb(ime_process_key_event_with_imengine_cb callback_func, void *user_data)
2457 {
2458     LOGD("");
2459     ime_error_e retVal = IME_ERROR_NONE;
2460
2461     if (!callback_func) {
2462         LOGW("IME_ERROR_INVALID_PARAMETER");
2463         return IME_ERROR_INVALID_PARAMETER;
2464     }
2465
2466     retVal = _check_privilege();
2467     if (retVal != IME_ERROR_NONE) return retVal;
2468
2469     g_event_callback.process_key_event_with_imengine = callback_func;
2470     g_event_callback.process_key_event_with_imengine_user_data = user_data;
2471
2472     return IME_ERROR_NONE;
2473 }
2474
2475 EXPORT_API int ime_event_set_autocapital_type_set_cb(ime_autocapital_type_set_cb callback_func, void *user_data)
2476 {
2477     LOGD("");
2478     ime_error_e retVal = IME_ERROR_NONE;
2479
2480     if (!callback_func) {
2481         LOGW("IME_ERROR_INVALID_PARAMETER");
2482         return IME_ERROR_INVALID_PARAMETER;
2483     }
2484
2485     retVal = _check_privilege();
2486     if (retVal != IME_ERROR_NONE) return retVal;
2487
2488     g_event_callback.autocapital_type_set = callback_func;
2489     g_event_callback.autocapital_type_set_user_data = user_data;
2490
2491     return IME_ERROR_NONE;
2492 }
2493
2494 EXPORT_API int ime_event_set_prediction_allow_set_cb(ime_prediction_allow_set_cb callback_func, void *user_data)
2495 {
2496     LOGD("");
2497     ime_error_e retVal = IME_ERROR_NONE;
2498
2499     if (!callback_func) {
2500         LOGW("IME_ERROR_INVALID_PARAMETER");
2501         return IME_ERROR_INVALID_PARAMETER;
2502     }
2503
2504     retVal = _check_privilege();
2505     if (retVal != IME_ERROR_NONE) return retVal;
2506
2507     g_event_callback.prediction_allow_set = callback_func;
2508     g_event_callback.prediction_allow_set_user_data = user_data;
2509
2510     return IME_ERROR_NONE;
2511 }
2512
2513 EXPORT_API int ime_event_set_trigger_property_set_cb(ime_trigger_property_set_cb callback_func, void *user_data)
2514 {
2515     LOGD("");
2516     ime_error_e retVal = IME_ERROR_NONE;
2517
2518     if (!callback_func) {
2519         LOGW("IME_ERROR_INVALID_PARAMETER");
2520         return IME_ERROR_INVALID_PARAMETER;
2521     }
2522
2523     retVal = _check_privilege();
2524     if (retVal != IME_ERROR_NONE) return retVal;
2525
2526     g_event_callback.trigger_property_set = callback_func;
2527     g_event_callback.trigger_property_set_user_data = user_data;
2528
2529     return IME_ERROR_NONE;
2530 }
2531
2532 EXPORT_API int ime_event_set_candidate_more_window_show_cb(ime_candidate_more_window_show_cb callback_func, void *user_data)
2533 {
2534     LOGD("");
2535     ime_error_e retVal = IME_ERROR_NONE;
2536
2537     if (!callback_func) {
2538         LOGW("IME_ERROR_INVALID_PARAMETER");
2539         return IME_ERROR_INVALID_PARAMETER;
2540     }
2541
2542     retVal = _check_privilege();
2543     if (retVal != IME_ERROR_NONE) return retVal;
2544
2545     g_event_callback.candidate_more_window_show = callback_func;
2546     g_event_callback.candidate_more_window_show_user_data = user_data;
2547
2548     return IME_ERROR_NONE;
2549 }
2550
2551 EXPORT_API int ime_event_set_candidate_more_window_hide_cb(ime_candidate_more_window_hide_cb callback_func, void *user_data)
2552 {
2553     LOGD("");
2554     ime_error_e retVal = IME_ERROR_NONE;
2555
2556     if (!callback_func) {
2557         LOGW("IME_ERROR_INVALID_PARAMETER");
2558         return IME_ERROR_INVALID_PARAMETER;
2559     }
2560
2561     retVal = _check_privilege();
2562     if (retVal != IME_ERROR_NONE) return retVal;
2563
2564     g_event_callback.candidate_more_window_hide = callback_func;
2565     g_event_callback.candidate_more_window_hide_user_data = user_data;
2566
2567     return IME_ERROR_NONE;
2568 }
2569
2570 EXPORT_API int ime_event_set_aux_select_cb(ime_aux_select_cb callback_func, void *user_data)
2571 {
2572     LOGD("");
2573     ime_error_e retVal = IME_ERROR_NONE;
2574
2575     if (!callback_func) {
2576         LOGW("IME_ERROR_INVALID_PARAMETER");
2577         return IME_ERROR_INVALID_PARAMETER;
2578     }
2579
2580     retVal = _check_privilege();
2581     if (retVal != IME_ERROR_NONE) return retVal;
2582
2583     g_event_callback.aux_select = callback_func;
2584     g_event_callback.aux_select_user_data = user_data;
2585
2586     return IME_ERROR_NONE;
2587 }
2588
2589 EXPORT_API int ime_event_set_candidate_select_cb(ime_candidate_select_cb callback_func, void *user_data)
2590 {
2591     LOGD("");
2592     ime_error_e retVal = IME_ERROR_NONE;
2593
2594     if (!callback_func) {
2595         LOGW("IME_ERROR_INVALID_PARAMETER");
2596         return IME_ERROR_INVALID_PARAMETER;
2597     }
2598
2599     retVal = _check_privilege();
2600     if (retVal != IME_ERROR_NONE) return retVal;
2601
2602     g_event_callback.candidate_select = callback_func;
2603     g_event_callback.candidate_select_user_data = user_data;
2604
2605     return IME_ERROR_NONE;
2606 }
2607
2608 EXPORT_API int ime_event_set_candidate_table_page_up_cb(ime_candidate_table_page_up_cb callback_func, void *user_data)
2609 {
2610     LOGD("");
2611     ime_error_e retVal = IME_ERROR_NONE;
2612
2613     if (!callback_func) {
2614         LOGW("IME_ERROR_INVALID_PARAMETER");
2615         return IME_ERROR_INVALID_PARAMETER;
2616     }
2617
2618     retVal = _check_privilege();
2619     if (retVal != IME_ERROR_NONE) return retVal;
2620
2621     g_event_callback.candidate_table_page_up = callback_func;
2622     g_event_callback.candidate_table_page_up_user_data = user_data;
2623
2624     return IME_ERROR_NONE;
2625 }
2626
2627 EXPORT_API int ime_event_set_candidate_table_page_down_cb(ime_candidate_table_page_down_cb callback_func, void *user_data)
2628 {
2629     LOGD("");
2630     ime_error_e retVal = IME_ERROR_NONE;
2631
2632     if (!callback_func) {
2633         LOGW("IME_ERROR_INVALID_PARAMETER");
2634         return IME_ERROR_INVALID_PARAMETER;
2635     }
2636
2637     retVal = _check_privilege();
2638     if (retVal != IME_ERROR_NONE) return retVal;
2639
2640     g_event_callback.candidate_table_page_down = callback_func;
2641     g_event_callback.candidate_table_page_down_user_data = user_data;
2642
2643     return IME_ERROR_NONE;
2644 }
2645
2646 EXPORT_API int ime_event_set_candidate_table_page_size_chaned_cb(ime_candidate_table_page_size_chaned_cb callback_func, void *user_data)
2647 {
2648     LOGD("");
2649     ime_error_e retVal = IME_ERROR_NONE;
2650
2651     if (!callback_func) {
2652         LOGW("IME_ERROR_INVALID_PARAMETER");
2653         return IME_ERROR_INVALID_PARAMETER;
2654     }
2655
2656     retVal = _check_privilege();
2657     if (retVal != IME_ERROR_NONE) return retVal;
2658
2659     g_event_callback.candidate_table_page_size_chaned = callback_func;
2660     g_event_callback.candidate_table_page_size_chaned_user_data = user_data;
2661
2662     return IME_ERROR_NONE;
2663 }
2664
2665 EXPORT_API int ime_event_set_candidate_item_layout_set_cb(ime_candidate_item_layout_set_cb callback_func, void *user_data)
2666 {
2667     LOGD("");
2668     ime_error_e retVal = IME_ERROR_NONE;
2669
2670     if (!callback_func) {
2671         LOGW("IME_ERROR_INVALID_PARAMETER");
2672         return IME_ERROR_INVALID_PARAMETER;
2673     }
2674
2675     retVal = _check_privilege();
2676     if (retVal != IME_ERROR_NONE) return retVal;
2677
2678     g_event_callback.candidate_item_layout_set = callback_func;
2679     g_event_callback.candidate_item_layout_set_user_data = user_data;
2680
2681     return IME_ERROR_NONE;
2682 }
2683
2684 EXPORT_API int ime_event_set_displayed_candidate_number_chaned_cb(ime_displayed_candidate_number_chaned_cb callback_func, void *user_data)
2685 {
2686     LOGD("");
2687     ime_error_e retVal = IME_ERROR_NONE;
2688
2689     if (!callback_func) {
2690         LOGW("IME_ERROR_INVALID_PARAMETER");
2691         return IME_ERROR_INVALID_PARAMETER;
2692     }
2693
2694     retVal = _check_privilege();
2695     if (retVal != IME_ERROR_NONE) return retVal;
2696
2697     g_event_callback.displayed_candidate_number_chaned = callback_func;
2698     g_event_callback.displayed_candidate_number_chaned_user_data = user_data;
2699
2700     return IME_ERROR_NONE;
2701 }
2702
2703 EXPORT_API int ime_event_set_candidate_item_long_pressed_cb(ime_candidate_item_long_pressed_cb callback_func, void *user_data)
2704 {
2705     LOGD("");
2706     ime_error_e retVal = IME_ERROR_NONE;
2707
2708     if (!callback_func) {
2709         LOGW("IME_ERROR_INVALID_PARAMETER");
2710         return IME_ERROR_INVALID_PARAMETER;
2711     }
2712
2713     retVal = _check_privilege();
2714     if (retVal != IME_ERROR_NONE) return retVal;
2715
2716     g_event_callback.candidate_item_long_pressed = callback_func;
2717     g_event_callback.candidate_item_long_pressed_user_data = user_data;
2718
2719     return IME_ERROR_NONE;
2720 }
2721
2722 EXPORT_API int ime_show_aux_string(void)
2723 {
2724     ime_error_e retVal = IME_ERROR_NONE;
2725
2726     retVal = _check_privilege();
2727     if (retVal != IME_ERROR_NONE) return retVal;
2728
2729     if (!g_running) {
2730         LOGW("IME_ERROR_NOT_RUNNING");
2731         return IME_ERROR_NOT_RUNNING;
2732     }
2733
2734     g_core.show_aux_string();
2735
2736     return IME_ERROR_NONE;
2737 }
2738
2739 EXPORT_API int ime_hide_aux_string(void)
2740 {
2741     ime_error_e retVal = IME_ERROR_NONE;
2742
2743     retVal = _check_privilege();
2744     if (retVal != IME_ERROR_NONE) return retVal;
2745
2746     if (!g_running) {
2747         LOGW("IME_ERROR_NOT_RUNNING");
2748         return IME_ERROR_NOT_RUNNING;
2749     }
2750
2751     g_core.hide_aux_string();
2752
2753     return IME_ERROR_NONE;
2754 }
2755
2756 EXPORT_API int ime_show_lookup_table(void)
2757 {
2758     ime_error_e retVal = IME_ERROR_NONE;
2759
2760     retVal = _check_privilege();
2761     if (retVal != IME_ERROR_NONE) return retVal;
2762
2763     if (!g_running) {
2764         LOGW("IME_ERROR_NOT_RUNNING");
2765         return IME_ERROR_NOT_RUNNING;
2766     }
2767
2768     g_core.show_candidate_string();
2769
2770     return IME_ERROR_NONE;
2771 }
2772
2773 EXPORT_API int ime_hide_lookup_table(void)
2774 {
2775     ime_error_e retVal = IME_ERROR_NONE;
2776
2777     retVal = _check_privilege();
2778     if (retVal != IME_ERROR_NONE) return retVal;
2779
2780     if (!g_running) {
2781         LOGW("IME_ERROR_NOT_RUNNING");
2782         return IME_ERROR_NOT_RUNNING;
2783     }
2784
2785     g_core.hide_candidate_string();
2786
2787     return IME_ERROR_NONE;
2788 }
2789
2790 EXPORT_API int ime_update_preedit_caret(int caret)
2791 {
2792     ime_error_e retVal = IME_ERROR_NONE;
2793
2794     if (caret < 0) {
2795         LOGW("IME_ERROR_INVALID_PARAMETER");
2796         return IME_ERROR_INVALID_PARAMETER;
2797     }
2798
2799     if (!g_running) {
2800         LOGW("IME_ERROR_NOT_RUNNING");
2801         return IME_ERROR_NOT_RUNNING;
2802     }
2803
2804     retVal = _check_privilege();
2805     if (retVal != IME_ERROR_NONE) return retVal;
2806
2807     g_core.update_preedit_caret(caret);
2808
2809     return IME_ERROR_NONE;
2810 }
2811
2812 EXPORT_API int ime_update_preedit_string_with_commit(const char *preedit, const char *commit, scim::AttributeList &attrs, int caret)
2813 {
2814     ime_error_e retVal = IME_ERROR_NONE;
2815
2816     if (!preedit && !commit) {
2817         LOGW("IME_ERROR_INVALID_PARAMETER");
2818         return IME_ERROR_INVALID_PARAMETER;
2819     }
2820
2821     if (!g_running) {
2822         LOGW("IME_ERROR_NOT_RUNNING");
2823         return IME_ERROR_NOT_RUNNING;
2824     }
2825
2826     retVal = _check_privilege();
2827     if (retVal != IME_ERROR_NONE) return retVal;
2828
2829     g_core.update_preedit_string_with_commit(preedit, commit, attrs, caret);
2830
2831     return IME_ERROR_NONE;
2832 }
2833
2834 EXPORT_API int ime_update_aux_string(const char *str)
2835 {
2836     ime_error_e retVal = IME_ERROR_NONE;
2837
2838     if (!str) {
2839         LOGW("IME_ERROR_INVALID_PARAMETER");
2840         return IME_ERROR_INVALID_PARAMETER;
2841     }
2842
2843     if (!g_running) {
2844         LOGW("IME_ERROR_NOT_RUNNING");
2845         return IME_ERROR_NOT_RUNNING;
2846     }
2847
2848     retVal = _check_privilege();
2849     if (retVal != IME_ERROR_NONE) return retVal;
2850
2851     g_core.update_aux_string(str);
2852
2853     return IME_ERROR_NONE;
2854 }
2855
2856 EXPORT_API int ime_recapture_string(int offset, int len, const char *preedit, const char *commit, scim::AttributeList &attrs)
2857 {
2858     ime_error_e retVal = IME_ERROR_NONE;
2859
2860     if (len < 0) {
2861         LOGW("IME_ERROR_INVALID_PARAMETER");
2862         return IME_ERROR_INVALID_PARAMETER;
2863     }
2864
2865     if (!g_running) {
2866         LOGW("IME_ERROR_NOT_RUNNING");
2867         return IME_ERROR_NOT_RUNNING;
2868     }
2869
2870     retVal = _check_privilege();
2871     if (retVal != IME_ERROR_NONE) return retVal;
2872
2873     g_core.recapture_string(offset, len, preedit, commit, attrs);
2874
2875     return IME_ERROR_NONE;
2876 }
2877
2878 EXPORT_API int ime_update_lookup_table(scim::LookupTable &table)
2879 {
2880     ime_error_e retVal = IME_ERROR_NONE;
2881
2882     if (!g_running) {
2883         LOGW("IME_ERROR_NOT_RUNNING");
2884         return IME_ERROR_NOT_RUNNING;
2885     }
2886
2887     retVal = _check_privilege();
2888     if (retVal != IME_ERROR_NONE) return retVal;
2889
2890     g_core.update_lookup_table(table);
2891
2892     return IME_ERROR_NONE;
2893 }
2894
2895 EXPORT_API int ime_register_properties(scim::PropertyList &properties)
2896 {
2897     ime_error_e retVal = IME_ERROR_NONE;
2898
2899     if (!g_running) {
2900         LOGW("IME_ERROR_NOT_RUNNING");
2901         return IME_ERROR_NOT_RUNNING;
2902     }
2903
2904     retVal = _check_privilege();
2905     if (retVal != IME_ERROR_NONE) return retVal;
2906
2907     g_core.register_properties(properties);
2908
2909     return IME_ERROR_NONE;
2910 }
2911
2912 EXPORT_API int ime_update_property(scim::Property &property)
2913 {
2914     ime_error_e retVal = IME_ERROR_NONE;
2915
2916     if (!g_running) {
2917         LOGW("IME_ERROR_NOT_RUNNING");
2918         return IME_ERROR_NOT_RUNNING;
2919     }
2920
2921     retVal = _check_privilege();
2922     if (retVal != IME_ERROR_NONE) return retVal;
2923
2924     g_core.update_property(property);
2925
2926     return IME_ERROR_NONE;
2927 }
2928
2929 EXPORT_API int ime_expand_candidate(void)
2930 {
2931     ime_error_e retVal = IME_ERROR_NONE;
2932
2933     retVal = _check_privilege();
2934     if (retVal != IME_ERROR_NONE) return retVal;
2935
2936     if (!g_running) {
2937         LOGW("IME_ERROR_NOT_RUNNING");
2938         return IME_ERROR_NOT_RUNNING;
2939     }
2940
2941     g_core.expand_candidate();
2942
2943     return IME_ERROR_NONE;
2944 }
2945
2946 EXPORT_API int ime_contract_candidate(void)
2947 {
2948     ime_error_e retVal = IME_ERROR_NONE;
2949
2950     retVal = _check_privilege();
2951     if (retVal != IME_ERROR_NONE) return retVal;
2952
2953     if (!g_running) {
2954         LOGW("IME_ERROR_NOT_RUNNING");
2955         return IME_ERROR_NOT_RUNNING;
2956     }
2957
2958     g_core.contract_candidate();
2959
2960     return IME_ERROR_NONE;
2961 }
2962
2963 EXPORT_API int ime_set_candidate_style(scim::ISF_CANDIDATE_PORTRAIT_LINE_T portrait_line, scim::ISF_CANDIDATE_MODE_T mode)
2964 {
2965     ime_error_e retVal = IME_ERROR_NONE;
2966
2967     if (!g_running) {
2968         LOGW("IME_ERROR_NOT_RUNNING");
2969         return IME_ERROR_NOT_RUNNING;
2970     }
2971
2972     retVal = _check_privilege();
2973     if (retVal != IME_ERROR_NONE) return retVal;
2974
2975     g_core.set_candidate_style(portrait_line, mode);
2976
2977     return IME_ERROR_NONE;
2978 }
2979
2980 EXPORT_API int ime_set_engine_loader_flag(bool flag)
2981 {
2982     ime_error_e retVal = IME_ERROR_NONE;
2983
2984     if (!g_running) {
2985         LOGW("IME_ERROR_NOT_RUNNING");
2986         return IME_ERROR_NOT_RUNNING;
2987     }
2988
2989     retVal = _check_privilege();
2990     if (retVal != IME_ERROR_NONE) return retVal;
2991
2992     g_core.set_engine_loader_flag(flag);
2993
2994     return IME_ERROR_NONE;
2995 }
2996
2997 EXPORT_API int ime_send_key_event_processing_result(scim::KeyEvent &key, uint32_t serial, bool is_success)
2998 {
2999     ime_error_e retVal = IME_ERROR_NONE;
3000
3001     if (!g_running) {
3002         LOGW("IME_ERROR_NOT_RUNNING");
3003         return IME_ERROR_NOT_RUNNING;
3004     }
3005
3006     retVal = _check_privilege();
3007     if (retVal != IME_ERROR_NONE) return retVal;
3008
3009     g_core.send_key_event_processing_result(key, serial, is_success);
3010
3011     return IME_ERROR_NONE;
3012 }
3013 //LCOV_EXCL_STOP
3014
3015 EXPORT_API int ime_update_input_panel_event(ime_event_type_e type, unsigned int value)
3016 {
3017     ime_error_e retVal = IME_ERROR_NONE;
3018
3019     if (type < IME_EVENT_TYPE_LANGUAGE || type > IME_EVENT_TYPE_GEOMETRY) {
3020         LOGW("IME_ERROR_INVALID_PARAMETER");
3021         return IME_ERROR_INVALID_PARAMETER;
3022     }
3023
3024     if (!g_running) {
3025         LOGW("IME_ERROR_NOT_RUNNING");
3026         return IME_ERROR_NOT_RUNNING;
3027     }
3028
3029     //LCOV_EXCL_START
3030     retVal = _check_privilege();
3031     if (retVal != IME_ERROR_NONE) return retVal;
3032
3033     g_core.update_input_context((sclu32)type, value);
3034
3035     return IME_ERROR_NONE;
3036     //LCOV_EXCL_STOP
3037 }
3038
3039 EXPORT_API int ime_set_candidate_visibility_state(bool visible)
3040 {
3041     ime_error_e retVal = IME_ERROR_NONE;
3042
3043     if (!g_running) {
3044         LOGW("IME_ERROR_NOT_RUNNING");
3045         return IME_ERROR_NOT_RUNNING;
3046     }
3047
3048     //LCOV_EXCL_START
3049     retVal = _check_privilege();
3050     if (retVal != IME_ERROR_NONE) return retVal;
3051
3052     if (visible)
3053         g_core.show_candidate_string();
3054     else
3055         g_core.hide_candidate_string();
3056
3057     return IME_ERROR_NONE;
3058     //LCOV_EXCL_STOP
3059 }