tests/iu/mmi_iu_feed_input_event_unittests.cpp

   1 /*
   2  * Copyright © 2021 Samsung Electronics co., Ltd. All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include <gtest/gtest.h>
  25 #include <string>
  26
  27 #include "mmi_iu.h"
  28 #include "mmi_iu_log.h"
  29 #include "mmi_iu_event.h"
  30
  31 #include <glib.h>
  32 #include <string>
  33 #include <json-glib/json-glib.h>
  34 #include <Ecore.h>
  35
  36 using namespace std;
  37
  38 #define TEST_APP_ID "org.tizen.iu-test"
  39 #define SYSTEM_APP_ID "org.tizen.system-app"
  40
  41 static string output_action;
  42
  43 static int g_received_event_type = -1;
  44 static void *g_received_event_data = NULL;
  45
  46 #define MMI_EVENT_VOICE_TYPE_GO 1000 // for test
  47
  48 namespace {
  49
  50 static void output_intent_received_cb(const char *app_id, const char *json_data, void *user_data)
  51 {
  52     JsonParser *parser = json_parser_new();
  53     GError *err_msg = NULL;
  54     JsonNode *root = NULL;
  55     JsonObject *root_obj = NULL;
  56     const gchar *action = NULL;
  57
  58     json_parser_load_from_data(parser, (char *)json_data, -1, &err_msg);
  59     if (err_msg) {
  60         _E("failed to load json file. error message: %s\n", err_msg->message);
  61         goto cleanup;
  62     }
  63
  64     root = json_parser_get_root(parser);
  65     if (root == NULL) {
  66         _E("failed to get root\n");
  67         goto cleanup;
  68     }
  69
  70     root_obj = json_node_get_object(root);
  71     if (root_obj == NULL) {
  72         _E("failed to get object\n");
  73         goto cleanup;
  74     }
  75
  76     action = json_object_get_string_member(root_obj, "Action");
  77     _D("Action: %s\n", action);
  78     output_action = string(action);
  79
  80 cleanup:
  81     if (err_msg)
  82         g_error_free(err_msg);
  83
  84     if (parser)
  85         g_object_unref(parser);
  86 }
  87
  88 static void output_event_received_cb(const char *app_id, int type, void *event, void *user_data)
  89 {
  90     g_received_event_type = type;
  91     g_received_event_data = event;
  92 }
  93
  94 class IUClientFeedInputEventTest : public testing::Test {
  95     public:
  96         virtual void SetUp() {
  97             ecore_init();
  98
  99             MMI_PROVIDER_EVENT_KEY = ecore_event_type_new();
 100             MMI_PROVIDER_EVENT_GESTURE = ecore_event_type_new();
 101             MMI_PROVIDER_EVENT_VOICE = ecore_event_type_new();
 102             MMI_PROVIDER_EVENT_VISION = ecore_event_type_new();
 103
 104             g_received_event_type = -1;
 105             g_received_event_data = NULL;
 106
 107             int ret = mmi_iu_init();
 108             EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 109
 110             output_action = string("");
 111
 112             ret = mmi_iu_set_output_intent_received_callback(output_intent_received_cb, NULL);
 113             EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 114
 115             ret = mmi_iu_set_output_event_received_callback(output_event_received_cb, NULL);
 116             EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 117         }
 118
 119         virtual void TearDown() {
 120             mmi_iu_shutdown();
 121
 122             MMI_PROVIDER_EVENT_KEY = -1;
 123             MMI_PROVIDER_EVENT_GESTURE = -1;
 124             MMI_PROVIDER_EVENT_VOICE = -1;
 125             MMI_PROVIDER_EVENT_VISION = -1;
 126
 127             ecore_shutdown();
 128         }
 129     private:
 130
 131 };
 132
 133 int feed_input_event_test(mmi_state app_state, int type, void *event)
 134 {
 135     int ret = mmi_iu_set_app_state(app_state);
 136     if (ret != MMI_IU_ERROR_NONE)
 137         return ret;
 138
 139     ret = mmi_iu_set_focus_app_id(TEST_APP_ID);
 140     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 141
 142     ret = mmi_iu_feed_input_event(TEST_APP_ID, type, event);
 143     return ret;
 144 }
 145
 146 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_key_input_press_up)
 147 {
 148     mmi_provider_event_key key_event;
 149     key_event.type = MMI_PROVIDER_EVENT_KEY;
 150     key_event.keycode = XKB_KEY_Up;
 151     key_event.keyname = (char *)"UP";
 152
 153     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_KEY, &key_event);
 154     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 155
 156     EXPECT_STREQ(output_action.c_str(), "MoveUp");
 157 }
 158
 159 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_key_input_press_down)
 160 {
 161     mmi_provider_event_key key_event;
 162     key_event.type = MMI_PROVIDER_EVENT_KEY;
 163     key_event.keycode = XKB_KEY_Down;
 164     key_event.keyname = (char *)"DOWN";
 165
 166     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_KEY, &key_event);
 167     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 168
 169     EXPECT_STREQ(output_action.c_str(), "MoveDown");
 170 }
 171
 172 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_key_input_press_right)
 173 {
 174     mmi_provider_event_key key_event;
 175     key_event.type = MMI_PROVIDER_EVENT_KEY;
 176     key_event.keycode = XKB_KEY_Right;
 177     key_event.keyname = (char *)"RIGHT";
 178
 179     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_KEY, &key_event);
 180     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 181
 182     EXPECT_STREQ(output_action.c_str(), "MoveRight");
 183 }
 184
 185 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_key_input_press_left)
 186 {
 187     mmi_provider_event_key key_event;
 188     key_event.type = MMI_PROVIDER_EVENT_KEY;
 189     key_event.keycode = XKB_KEY_Left;
 190     key_event.keyname = (char *)"LEFT";
 191
 192     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_KEY, &key_event);
 193     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 194
 195     EXPECT_STREQ(output_action.c_str(), "MoveLeft");
 196 }
 197
 198 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_move_up)
 199 {
 200     mmi_provider_event_voice ve = { 0, };
 201     ve.type = MMI_EVENT_VOICE_TYPE_UP;
 202
 203     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_VOICE, &ve);
 204     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 205
 206     EXPECT_STREQ(output_action.c_str(), "MoveUp");
 207 }
 208
 209 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_move_down)
 210 {
 211     mmi_provider_event_voice ve = { 0, };
 212     ve.type = MMI_EVENT_VOICE_TYPE_DOWN;
 213
 214     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_VOICE, &ve);
 215     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 216
 217     EXPECT_STREQ(output_action.c_str(), "MoveDown");
 218 }
 219
 220 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_move_right)
 221 {
 222     mmi_provider_event_voice ve = { 0, };
 223     ve.type = MMI_EVENT_VOICE_TYPE_RIGHT;
 224
 225     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_VOICE, &ve);
 226     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 227
 228     EXPECT_STREQ(output_action.c_str(), "MoveRight");
 229 }
 230
 231 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_move_left)
 232 {
 233     mmi_provider_event_voice ve = { 0, };
 234     ve.type = MMI_EVENT_VOICE_TYPE_LEFT;
 235
 236     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_VOICE, &ve);
 237     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 238
 239     EXPECT_STREQ(output_action.c_str(), "MoveLeft");
 240 }
 241
 242 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_gesture_hand_up)
 243 {
 244     mmi_provider_event_gesture ge = { 0, };
 245     ge.type = MMI_EVENT_GESTURE_TYPE_SWIPE_UP;
 246
 247     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_GESTURE, &ge);
 248     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 249
 250     EXPECT_STREQ(output_action.c_str(), "MoveUp");
 251 }
 252
 253 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_gesture_hand_down)
 254 {
 255     mmi_provider_event_gesture ge = { 0, };
 256     ge.type = MMI_EVENT_GESTURE_TYPE_SWIPE_DOWN;
 257
 258     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_GESTURE, &ge);
 259     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 260
 261     EXPECT_STREQ(output_action.c_str(), "MoveDown");
 262 }
 263
 264 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_gesture_hand_right)
 265 {
 266     mmi_provider_event_gesture ge = { 0, };
 267     ge.type = MMI_EVENT_GESTURE_TYPE_SWIPE_RIGHT;
 268
 269     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_GESTURE, &ge);
 270     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 271
 272     EXPECT_STREQ(output_action.c_str(), "MoveRight");
 273 }
 274
 275 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_gesture_hand_left)
 276 {
 277     mmi_provider_event_gesture ge = { 0, };
 278     ge.type = MMI_EVENT_GESTURE_TYPE_SWIPE_LEFT;
 279
 280     int ret = feed_input_event_test(MMI_STATE_EXPLORATION, MMI_PROVIDER_EVENT_GESTURE, &ge);
 281     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 282
 283     EXPECT_STREQ(output_action.c_str(), "MoveLeft");
 284 }
 285
 286 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_key_press_ok)
 287 {
 288     mmi_provider_event_key key_event;
 289     key_event.type = MMI_PROVIDER_EVENT_KEY;
 290     key_event.keycode = XKB_KEY_Return;
 291     key_event.keyname = (char *)"RETURN";
 292
 293     int ret = feed_input_event_test(MMI_STATE_EXECUTION, MMI_PROVIDER_EVENT_KEY, &key_event);
 294     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 295
 296     EXPECT_STREQ(output_action.c_str(), "Execute");
 297 }
 298
 299 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_execute)
 300 {
 301     mmi_provider_event_voice ve = { 0, };
 302     ve.type = MMI_EVENT_VOICE_TYPE_EXECUTE;
 303
 304     int ret = feed_input_event_test(MMI_STATE_EXECUTION, MMI_PROVIDER_EVENT_VOICE, &ve);
 305     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 306
 307     EXPECT_STREQ(output_action.c_str(), "Execute");
 308 }
 309
 310 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_play)
 311 {
 312     mmi_provider_event_voice ve = { 0, };
 313     ve.type = MMI_EVENT_VOICE_TYPE_PLAY;
 314
 315     int ret = feed_input_event_test(MMI_STATE_EXECUTION, MMI_PROVIDER_EVENT_VOICE, &ve);
 316     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 317
 318     EXPECT_STREQ(output_action.c_str(), "Play");
 319 }
 320
 321 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_yes)
 322 {
 323     mmi_provider_event_voice ve = { 0, };
 324     ve.type = MMI_EVENT_VOICE_TYPE_YES;
 325
 326     int ret = feed_input_event_test(MMI_STATE_EXECUTION,  MMI_PROVIDER_EVENT_VOICE, &ve);
 327     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 328
 329     EXPECT_STREQ(output_action.c_str(), "Yes");
 330 }
 331
 332 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_gesture_hand_push)
 333 {
 334     mmi_provider_event_gesture ge = { 0, };
 335     ge.type = MMI_EVENT_GESTURE_TYPE_PUSH;
 336
 337     int ret = feed_input_event_test(MMI_STATE_EXECUTION, MMI_PROVIDER_EVENT_GESTURE, &ge);
 338     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 339
 340     EXPECT_STREQ(output_action.c_str(), "Execute");
 341 }
 342
 343 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_key_back_button)
 344 {
 345     mmi_provider_event_key key_event;
 346     key_event.type = MMI_PROVIDER_EVENT_KEY;
 347     key_event.keycode = XKB_KEY_XF86Back;
 348     key_event.keyname = (char *)"XF86Back";
 349
 350     int ret = feed_input_event_test(MMI_STATE_FEEDBACK, MMI_PROVIDER_EVENT_KEY, &key_event);
 351     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 352
 353     EXPECT_STREQ(output_action.c_str(), "Cancel");
 354 }
 355
 356 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_cancel)
 357 {
 358     mmi_provider_event_voice ve = { 0, };
 359     ve.type = MMI_EVENT_VOICE_TYPE_CANCEL;
 360
 361     int ret = feed_input_event_test(MMI_STATE_FEEDBACK, MMI_PROVIDER_EVENT_VOICE, &ve);
 362     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 363
 364     EXPECT_STREQ(output_action.c_str(), "Cancel");
 365 }
 366
 367 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_back)
 368 {
 369     mmi_provider_event_voice ve = { 0, };
 370     ve.type = MMI_EVENT_VOICE_TYPE_BACK;
 371
 372     int ret = feed_input_event_test(MMI_STATE_FEEDBACK, MMI_PROVIDER_EVENT_VOICE, &ve);
 373     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 374
 375     EXPECT_STREQ(output_action.c_str(), "Cancel");
 376 }
 377
 378 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_vision_outofvision)
 379 {
 380     std::string input_intent_json_data =
 381     R"({
 382         "InputIntents" : [
 383             {
 384                 "Modality" : "Vision",
 385                 "Action" : "OutOfVision"
 386             }
 387         ]
 388     }
 389     )";
 390
 391     mmi_provider_event_vision vision_event = { 0, };
 392     vision_event.type = MMI_EVENT_VISION_TYPE_USER_MOVE_AWAY;
 393
 394     int ret = feed_input_event_test(MMI_STATE_OBSERVATION, MMI_PROVIDER_EVENT_VISION, &vision_event);
 395     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 396
 397     EXPECT_STREQ(output_action.c_str(), "Pause");
 398 }
 399
 400 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_key_back_terminate)
 401 {
 402     mmi_provider_event_key key_event;
 403     key_event.type = MMI_PROVIDER_EVENT_KEY;
 404     key_event.keycode = XKB_KEY_XF86Back;
 405     key_event.keyname = (char *)"XF86Back";
 406
 407     int ret = feed_input_event_test(MMI_STATE_TERMINATION, MMI_PROVIDER_EVENT_KEY, &key_event);
 408     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 409
 410     EXPECT_STREQ(output_action.c_str(), "Exit");
 411 }
 412
 413 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_exit)
 414 {
 415     mmi_provider_event_voice ve = { 0, };
 416     ve.type = MMI_EVENT_VOICE_TYPE_EXIT;
 417
 418     int ret = feed_input_event_test(MMI_STATE_TERMINATION, MMI_PROVIDER_EVENT_VOICE, &ve);
 419     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 420
 421     EXPECT_STREQ(output_action.c_str(), "Exit");
 422 }
 423
 424 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_stop)
 425 {
 426     mmi_provider_event_voice ve = { 0, };
 427     ve.type = MMI_EVENT_VOICE_TYPE_STOP;
 428
 429     int ret = feed_input_event_test(MMI_STATE_TERMINATION, MMI_PROVIDER_EVENT_VOICE, &ve);
 430     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 431
 432     EXPECT_STREQ(output_action.c_str(), "Stop");
 433 }
 434
 435 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_terminate)
 436 {
 437     mmi_provider_event_voice ve = { 0, };
 438     ve.type = MMI_EVENT_VOICE_TYPE_TERMINATE;
 439
 440     int ret = feed_input_event_test(MMI_STATE_TERMINATION, MMI_PROVIDER_EVENT_VOICE, &ve);
 441     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 442
 443     EXPECT_STREQ(output_action.c_str(), "Terminate");
 444 }
 445
 446 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_gesture_push_different_focus)
 447 {
 448     int ret = mmi_iu_set_output_intent_received_callback(output_intent_received_cb, NULL);
 449     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 450
 451     ret = mmi_iu_set_app_state(MMI_STATE_TERMINATION);
 452     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 453
 454     ret = mmi_iu_set_focus_app_id(SYSTEM_APP_ID);
 455     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 456
 457     mmi_provider_event_gesture ge = { 0, };
 458     ge.type = MMI_EVENT_GESTURE_TYPE_PUSH;
 459
 460     ret = mmi_iu_feed_input_event(TEST_APP_ID, MMI_PROVIDER_EVENT_GESTURE, &ge);
 461     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 462
 463     EXPECT_STREQ(output_action.c_str(), "");
 464 }
 465
 466 TEST_F(IUClientFeedInputEventTest, utc_mmi_iu_feed_intent_voice_go)
 467 {
 468     int timestamp = 1234;
 469     mmi_provider_event_voice ve = { 0, };
 470     ve.type = MMI_EVENT_VOICE_TYPE_GO;
 471     ve.timestamp = timestamp;
 472
 473     int ret = feed_input_event_test(MMI_STATE_TERMINATION, MMI_PROVIDER_EVENT_VOICE, &ve);
 474     EXPECT_EQ(ret, MMI_IU_ERROR_NONE);
 475
 476     EXPECT_EQ(g_received_event_type, MMI_PROVIDER_EVENT_VOICE);
 477     EXPECT_EQ(g_received_event_data, &ve);
 478
 479     mmi_provider_event_voice *rcv_ve = (mmi_provider_event_voice *)g_received_event_data;
 480     EXPECT_EQ(rcv_ve->timestamp, timestamp);
 481 }
 482
 483 } // namespace