tests/tc_screenshooter.cpp

   1 #include <libds/output.h>
   2 #include <libds/backend/wayland.h>
   3 #include <libds-tizen/screenshooter.h>
   4 #ifdef TIZEN_SCREENMIRROR_STOP
   5 #undef TIZEN_SCREENMIRROR_STOP
   6 #endif
   7 #include <tizen-extension-client-protocol.h>
   8 #include <wayland-tbm-client.h>
   9 #include <tbm_surface.h>
  10 #include <sys/mman.h>
  11 #include "tc_main.h"
  12 #include "mockclient.h"
  13 #include "mockcompositor.h"
  14
  15 #define TIZEN_SCREENSHOOTER_VERSION 3
  16 #define SHM_BUF_WIDTH 1920
  17 #define SHM_BUF_HEIGHT 1080
  18 #define SHM_BUF_STRIDE 7680 //width * 4
  19 #define SHM_BUF_FORMAT WL_SHM_FORMAT_XRGB8888
  20
  21 class MockScreenShooterCompositor : public MockCompositor
  22 {
  23 public:
  24     MockScreenShooterCompositor()
  25         : MockCompositor(&MockScreenShooterCompositor::TestSetup, this)
  26     {
  27         ds_inf("%s : this(%p)", __func__, this);
  28
  29         bDestroyed = false;
  30         bMirror = false;
  31         bDestroyMirror = false;
  32         bShoot = false;
  33         bStart = false;
  34         bAutoRotation = false;
  35         mBackend = nullptr;
  36         mBuffer = nullptr;
  37         mOutput = nullptr;;
  38         mScreenShooter = nullptr;
  39         mScreenMirror = nullptr;
  40         new_output = {};
  41
  42         mDestroyListener = {};
  43         mNewScreenMirrorListener = {};
  44         mScreenShootListener = {};
  45         mScreenMirrorDestroyListener = {};
  46         mScreenMirrorSetStretchListener = {};
  47         mScreenMirrorQueueListener = {};
  48         mScreenMirrorDequeueListener = {};
  49         mScreenMirrorStartListener = {};
  50         mScreenMirrorStopListener = {};
  51         mScreenMirrorAutoRotationListener = {};
  52     }
  53
  54     ~MockScreenShooterCompositor()
  55     {
  56         ds_inf("%s : this(%p)", __func__, this);
  57     }
  58
  59     static void TestSetup(void *data)
  60     {
  61         MockScreenShooterCompositor *mockComp =
  62             static_cast<MockScreenShooterCompositor *>(data);
  63         Compositor *comp = mockComp->compositor;
  64
  65         ds_inf("%s: mockComp(%p)", __func__, mockComp);
  66
  67         mockComp->mBackend = ds_wl_backend_create(comp->display, NULL);
  68         mockComp->new_output.notify = screenshooter_backend_handle_new_output;
  69         ds_backend_add_new_output_listener(mockComp->mBackend, &mockComp->new_output);
  70         ds_backend_start(mockComp->mBackend);
  71
  72         mockComp->mScreenShooter =
  73             ds_tizen_screenshooter_create(comp->display);
  74
  75         // add destroy listener
  76         mockComp->mDestroyListener.notify =
  77             MockScreenShooterCompositor::DestroyCallback;
  78         mockComp->mDestroyListener.parent = mockComp;
  79         ds_tizen_screenshooter_add_destroy_listener(mockComp->mScreenShooter,
  80             &mockComp->mDestroyListener);
  81
  82         // add newscreenmirror listener
  83         mockComp->mNewScreenMirrorListener.notify =
  84             MockScreenShooterCompositor::NewScreenMirrorCallback;
  85         mockComp->mNewScreenMirrorListener.parent = mockComp;
  86         ds_tizen_screenshooter_add_get_screenmirror_listener(mockComp->mScreenShooter,
  87             &mockComp->mNewScreenMirrorListener);
  88
  89         // add shoot listener
  90         mockComp->mScreenShootListener.notify =
  91             MockScreenShooterCompositor::ScreenShootCallback;
  92         mockComp->mScreenShootListener.parent = mockComp;
  93         ds_tizen_screenshooter_add_shoot_listener(mockComp->mScreenShooter,
  94             &mockComp->mScreenShootListener);
  95     }
  96
  97     static void screenshooter_backend_handle_new_output(struct wl_listener *listener,
  98         void *data)
  99     {
 100         MockScreenShooterCompositor *mockComp;
 101
 102         mockComp = wl_container_of(listener, mockComp, new_output);
 103         mockComp->mOutput = static_cast<struct ds_output *>(data);
 104
 105         ds_inf("New ds_output(%p)", mockComp->mOutput);
 106
 107         ds_output_create_global(mockComp->mOutput);
 108         ds_inf("create output global");
 109     }
 110
 111     static void DestroyCallback(struct wl_listener *listener, void *data)
 112     {
 113         ds_inf("%s", __func__);
 114
 115         MockScreenShooterCompositor *mockComp =
 116             reinterpret_cast<DestroyListener *>(listener)->parent;
 117
 118         mockComp->bDestroyed = true;
 119     }
 120
 121     static void NewScreenMirrorCallback(struct wl_listener *listener,
 122         void *data)
 123     {
 124         ds_inf("%s", __func__);
 125
 126         MockScreenShooterCompositor *mockComp =
 127             reinterpret_cast<NewScreenMirrorListener *>(listener)->parent;
 128         struct ds_tizen_screenmirror *mirror =
 129             static_cast<struct ds_tizen_screenmirror *>(data);
 130
 131         ds_inf("%s: mockComp(%p), mirror(%p)", __func__, mockComp, mirror);
 132
 133         mockComp->bMirror = true;
 134         mockComp->mScreenMirror = mirror;
 135
 136         // add destroy listener
 137         mockComp->mScreenMirrorDestroyListener.notify =
 138             MockScreenShooterCompositor::ScreenMirrorDestroyCallback;
 139         mockComp->mScreenMirrorDestroyListener.parent = mockComp;
 140         ds_tizen_screenmirror_add_destroy_listener(mockComp->mScreenMirror,
 141             &mockComp->mScreenMirrorDestroyListener);
 142
 143         // add set_stretch listener
 144         mockComp->mScreenMirrorSetStretchListener.notify =
 145             MockScreenShooterCompositor::ScreenMirrorSetStretchCallback;
 146         mockComp->mScreenMirrorSetStretchListener.parent = mockComp;
 147         ds_tizen_screenmirror_add_set_stretch_listener(mockComp->mScreenMirror,
 148             &mockComp->mScreenMirrorSetStretchListener);
 149
 150         // add queue listener
 151         mockComp->mScreenMirrorQueueListener.notify =
 152             MockScreenShooterCompositor::ScreenMirrorQueueCallback;
 153         mockComp->mScreenMirrorQueueListener.parent = mockComp;
 154         ds_tizen_screenmirror_add_queue_listener(mockComp->mScreenMirror,
 155             &mockComp->mScreenMirrorQueueListener);
 156
 157         // add dequeue listener
 158         mockComp->mScreenMirrorDequeueListener.notify =
 159             MockScreenShooterCompositor::ScreenMirrorDequeueCallback;
 160         mockComp->mScreenMirrorDequeueListener.parent = mockComp;
 161         ds_tizen_screenmirror_add_dequeue_listener(mockComp->mScreenMirror,
 162             &mockComp->mScreenMirrorDequeueListener);
 163
 164         // add start listener
 165         mockComp->mScreenMirrorStartListener.notify =
 166             MockScreenShooterCompositor::ScreenMirrorStartCallback;
 167         mockComp->mScreenMirrorStartListener.parent = mockComp;
 168         ds_tizen_screenmirror_add_start_listener(mockComp->mScreenMirror,
 169             &mockComp->mScreenMirrorStartListener);
 170
 171         // add stop listener
 172         mockComp->mScreenMirrorStopListener.notify =
 173             MockScreenShooterCompositor::ScreenMirrorStopCallback;
 174         mockComp->mScreenMirrorStopListener.parent = mockComp;
 175         ds_tizen_screenmirror_add_stop_listener(mockComp->mScreenMirror,
 176             &mockComp->mScreenMirrorStopListener);
 177
 178         // add auto rotation listener
 179         mockComp->mScreenMirrorAutoRotationListener.notify =
 180             MockScreenShooterCompositor::ScreenMirrorAutoRotationCallback;
 181         mockComp->mScreenMirrorAutoRotationListener.parent = mockComp;
 182         ds_tizen_screenmirror_add_auto_rotation_listener(mockComp->mScreenMirror,
 183             &mockComp->mScreenMirrorAutoRotationListener);
 184     }
 185
 186     static void ScreenShootCallback(struct wl_listener *listener,
 187         void *data)
 188     {
 189         ds_inf("%s", __func__);
 190
 191         MockScreenShooterCompositor *mockComp =
 192             reinterpret_cast<ScreenShootListener *>(listener)->parent;
 193         struct ds_tizen_screenshooter_event_shoot *event =
 194             static_cast<struct ds_tizen_screenshooter_event_shoot *>(data);
 195
 196
 197         ds_inf("%s: mockComp(%p), output(%p), buffer(%p), client(%p), auto_rotate:%d",
 198             __func__, mockComp, event->output, event->buffer, event->client,
 199             event->auto_rotation ? 1 : 0);
 200
 201         mockComp->bShoot = true;
 202         ds_tizen_screenshooter_send_shoot_done(mockComp->mScreenShooter, event->client);
 203     }
 204
 205     static void ScreenMirrorDestroyCallback(struct wl_listener *listener,
 206         void *data)
 207     {
 208         ds_inf("%s", __func__);
 209
 210         MockScreenShooterCompositor *mockComp =
 211             reinterpret_cast<ScreenMirrorDestroyListener *>(listener)->parent;
 212         struct ds_tizen_screenmirror *mirror =
 213             static_cast<struct ds_tizen_screenmirror *>(data);
 214
 215         ds_inf("%s: mockComp(%p), info(%p)", __func__, mockComp, mirror);
 216
 217         if (mockComp->mScreenMirror == mirror) {
 218             ds_inf("%s: info is deleted.", __func__);
 219             mockComp->bDestroyMirror = true;
 220         }
 221     }
 222
 223     static void ScreenMirrorSetStretchCallback(struct wl_listener *listener,
 224         void *data)
 225     {
 226         ds_inf("%s", __func__);
 227
 228         MockScreenShooterCompositor *mockComp =
 229             reinterpret_cast<ScreenMirrorSetStretchListener *>(listener)->parent;
 230         enum ds_tizen_screenmirror_stretch *stretch = (enum ds_tizen_screenmirror_stretch *)data;
 231
 232         ds_inf("%s: mockComp(%p), stretch(%d)", __func__, mockComp, *stretch);
 233     }
 234
 235     static void ScreenMirrorQueueCallback(struct wl_listener *listener,
 236         void *data)
 237     {
 238         ds_inf("%s", __func__);
 239
 240         MockScreenShooterCompositor *mockComp =
 241             reinterpret_cast<ScreenMirrorQueueListener *>(listener)->parent;
 242         struct ds_buffer *buffer =
 243             static_cast<struct ds_buffer *>(data);
 244
 245         ds_inf("%s: mockComp(%p), queue(%p)", __func__, mockComp, buffer);
 246     }
 247
 248     static void ScreenMirrorDequeueCallback(struct wl_listener *listener,
 249         void *data)
 250     {
 251         ds_inf("%s", __func__);
 252
 253         MockScreenShooterCompositor *mockComp =
 254             reinterpret_cast<ScreenMirrorDequeueListener *>(listener)->parent;
 255         struct ds_buffer *buffer =
 256             static_cast<struct ds_buffer *>(data);
 257
 258         ds_inf("%s: mockComp(%p), dequeue(%p)", __func__, mockComp, buffer);
 259
 260         ds_tizen_screenmirror_send_dequeued(mockComp->mScreenMirror, buffer);
 261     }
 262
 263     static void ScreenMirrorStartCallback(struct wl_listener *listener,
 264         void *data)
 265     {
 266         ds_inf("%s", __func__);
 267
 268         MockScreenShooterCompositor *mockComp =
 269             reinterpret_cast<ScreenMirrorDequeueListener *>(listener)->parent;
 270
 271         ds_inf("%s: mockComp(%p), start", __func__, mockComp);
 272
 273         mockComp->bStart = true;
 274     }
 275
 276     static void ScreenMirrorStopCallback(struct wl_listener *listener,
 277         void *data)
 278     {
 279         ds_inf("%s", __func__);
 280
 281         MockScreenShooterCompositor *mockComp =
 282             reinterpret_cast<ScreenMirrorDequeueListener *>(listener)->parent;
 283
 284         ds_inf("%s: mockComp(%p), stop", __func__, mockComp);
 285
 286         mockComp->bStart = false;
 287     }
 288
 289     static void ScreenMirrorAutoRotationCallback(struct wl_listener *listener,
 290         void *data)
 291     {
 292         ds_inf("%s", __func__);
 293
 294         MockScreenShooterCompositor *mockComp =
 295             reinterpret_cast<ScreenMirrorDequeueListener *>(listener)->parent;
 296         uint32_t *set = (uint32_t *)data;
 297
 298         ds_inf("%s: mockComp(%p), autorotation(%d)", __func__, mockComp, *set);
 299
 300         if (*set)
 301             mockComp->bAutoRotation = true;
 302         else
 303             mockComp->bAutoRotation = false;
 304     }
 305
 306 public:
 307     bool bDestroyed;
 308
 309     bool bMirror;
 310     bool bDestroyMirror;
 311     bool bShoot;
 312     bool bStart;
 313     bool bAutoRotation;
 314
 315 private:
 316     struct ds_backend *mBackend;
 317     struct ds_buffer *mBuffer;
 318     struct ds_output *mOutput;
 319     struct ds_tizen_screenshooter *mScreenShooter;
 320         struct ds_tizen_screenmirror *mScreenMirror;
 321     struct wl_listener new_output;
 322
 323     struct DestroyListener : ::wl_listener {
 324         MockScreenShooterCompositor *parent;
 325     };
 326     DestroyListener mDestroyListener;
 327
 328     struct NewScreenMirrorListener : ::wl_listener {
 329         MockScreenShooterCompositor *parent;
 330     };
 331     NewScreenMirrorListener mNewScreenMirrorListener;
 332
 333     struct ScreenShootListener : ::wl_listener {
 334         MockScreenShooterCompositor *parent;
 335     };
 336     ScreenShootListener mScreenShootListener;
 337
 338     struct ScreenMirrorDestroyListener : ::wl_listener {
 339         MockScreenShooterCompositor *parent;
 340     };
 341     ScreenMirrorDestroyListener mScreenMirrorDestroyListener;
 342
 343     struct ScreenMirrorSetStretchListener : ::wl_listener {
 344         MockScreenShooterCompositor *parent;
 345     };
 346     ScreenMirrorSetStretchListener mScreenMirrorSetStretchListener;
 347
 348     struct ScreenMirrorQueueListener : ::wl_listener {
 349         MockScreenShooterCompositor *parent;
 350     };
 351     ScreenMirrorQueueListener mScreenMirrorQueueListener;
 352
 353     struct ScreenMirrorDequeueListener : ::wl_listener {
 354         MockScreenShooterCompositor *parent;
 355     };
 356     ScreenMirrorDequeueListener mScreenMirrorDequeueListener;
 357
 358     struct ScreenMirrorStartListener : ::wl_listener {
 359         MockScreenShooterCompositor *parent;
 360     };
 361     ScreenMirrorStartListener mScreenMirrorStartListener;
 362
 363     struct ScreenMirrorStopListener : ::wl_listener {
 364         MockScreenShooterCompositor *parent;
 365     };
 366     ScreenMirrorStopListener mScreenMirrorStopListener;
 367
 368     struct ScreenMirrorAutoRotationListener : ::wl_listener {
 369         MockScreenShooterCompositor *parent;
 370     };
 371     ScreenMirrorAutoRotationListener mScreenMirrorAutoRotationListener;
 372 };
 373
 374 class MockScreenShooterClient : public MockClient
 375 {
 376 public:
 377     MockScreenShooterClient()
 378         : bShootEvent(false),
 379           bMirrorStartEvent(false),
 380           bMirrorStopEvent(false),
 381           output_res(nullptr),
 382           shm_res(nullptr),
 383           shm_pool(nullptr),
 384           screenshooter_res(nullptr),
 385           screenmirror_res(nullptr)
 386     {}
 387     MockScreenShooterClient(const struct wl_registry_listener *listener)
 388         : MockClient(listener, this)
 389     {
 390         ds_inf("%s", __func__);
 391
 392         bShootEvent = false;
 393         bMirrorStartEvent = false;
 394         bMirrorStopEvent = false;
 395         output_res = nullptr;
 396         shm_res = nullptr;
 397         shm_pool = nullptr;
 398         screenshooter_res = nullptr;
 399         screenmirror_res = nullptr;
 400     }
 401     ~MockScreenShooterClient()
 402     {
 403         ds_inf("%s", __func__);
 404     }
 405
 406     void SetWlOutput(struct wl_output *global_res)
 407     {
 408         ds_inf("%s", __func__);
 409
 410         output_res = global_res;
 411     }
 412
 413     struct wl_output *GetWlOutput()
 414     {
 415         ds_inf("%s", __func__);
 416
 417         return output_res;
 418     }
 419
 420     void SetWlShm(struct wl_shm *global_res)
 421     {
 422         ds_inf("%s", __func__);
 423
 424         shm_res = global_res;
 425     }
 426
 427     struct wl_shm *GetWlShm()
 428     {
 429         ds_inf("%s", __func__);
 430
 431         return shm_res;
 432     }
 433
 434     void SetWlShmPool(struct wl_shm_pool *_shm_pool)
 435     {
 436         ds_inf("%s", __func__);
 437
 438         shm_pool = _shm_pool;
 439     }
 440
 441     struct wl_shm_pool *GetWlShmPool()
 442     {
 443         ds_inf("%s", __func__);
 444
 445         return shm_pool;
 446     }
 447
 448     void SetTizenScreenShooter(struct tizen_screenshooter *resource)
 449     {
 450         ds_inf("%s", __func__);
 451
 452         screenshooter_res = resource;
 453     }
 454
 455     struct tizen_screenshooter *GetTizenScreenShooter()
 456     {
 457         ds_inf("%s", __func__);
 458
 459         return screenshooter_res;
 460     }
 461
 462
 463     void SetTizenScreenMirror(struct tizen_screenmirror *resource)
 464     {
 465         ds_inf("%s", __func__);
 466
 467         screenmirror_res = resource;
 468     }
 469
 470     struct tizen_screenmirror *GetTizenScreenMirror()
 471     {
 472         ds_inf("%s", __func__);
 473
 474         return screenmirror_res;
 475     }
 476
 477 public:
 478     bool bShootEvent;
 479     bool bMirrorStartEvent;
 480     bool bMirrorStopEvent;
 481
 482 private:
 483     struct wl_output *output_res;
 484     struct wl_shm *shm_res;
 485     struct wl_shm_pool *shm_pool;
 486     struct tizen_screenshooter *screenshooter_res;
 487     struct tizen_screenmirror *screenmirror_res;
 488 };
 489
 490 static void
 491 client_tizen_screenshooter_cb_format(void *data,
 492     struct tizen_screenshooter *screenshooter_res, uint32_t format)
 493 {
 494 }
 495
 496 static void
 497 client_tizen_screenshooter_cb_noti(void *data,
 498     struct tizen_screenshooter *screenshooter_res, uint32_t noti)
 499 {
 500     ds_inf("noti : %d");
 501 }
 502
 503 static void
 504 client_tizen_screenshooter_cb_done(void *data,
 505     struct tizen_screenshooter *screenshooter_res)
 506 {
 507     MockScreenShooterClient *client = static_cast<MockScreenShooterClient *>(data);
 508
 509     client->bShootEvent = true;
 510 }
 511
 512 static const struct
 513 tizen_screenshooter_listener screenshooter_cb_listener = {
 514     client_tizen_screenshooter_cb_format,
 515     client_tizen_screenshooter_cb_noti,
 516     client_tizen_screenshooter_cb_done,
 517 };
 518
 519 static void
 520 _client_tizen_screenshooter_destroy_anonymous_file(int fd)
 521 {
 522     if (fd < 0)
 523         return;
 524
 525     close(fd);
 526 }
 527
 528 static int
 529 _client_tizen_screenshooter_create_anonymous_file(off_t size)
 530 {
 531     static const char tempname[] = "/shooter-XXXXXX";
 532     const char *path;
 533     char *name = NULL;
 534     int fd = -1;
 535     int ret = -1;
 536     int path_len = 0;
 537
 538     path = getenv("XDG_RUNTIME_DIR");
 539     if (!path) {
 540         errno = ENOENT;
 541         return -1;
 542     }
 543     path_len = strlen(path);
 544     if (path_len == 0)
 545         return -1;
 546
 547     name = (char *)malloc(path_len + (int)sizeof(tempname));
 548     if (name == NULL)
 549         return -1;
 550
 551     strncpy(name, path, path_len);
 552     strncat(name, tempname, (int)sizeof(tempname));
 553
 554     fd = mkstemp(name);
 555     if (fd >= 0)
 556         unlink(name);
 557
 558     free(name);
 559
 560     if (fd < 0)
 561         return -1;
 562
 563     ret = ftruncate(fd, size);
 564     if (ret < 0) {
 565         close(fd);
 566         return -1;
 567     }
 568
 569     return fd;
 570 }
 571
 572 static struct wl_shm_pool *
 573 _client_tizen_screenshooter_create_shm_pool(struct wl_shm *shm, int size)
 574 {
 575     struct wl_shm_pool *shm_pool = NULL;
 576     void *data = NULL;
 577     int fd = -1;
 578
 579     fd = _client_tizen_screenshooter_create_anonymous_file(size);
 580     if (fd < 0)
 581         goto fail;
 582
 583     data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 584     if (data == NULL)
 585         goto fail;
 586
 587     memset(data, 0xff, size);
 588     munmap(data, size);
 589
 590     shm_pool = wl_shm_create_pool(shm, fd, size);
 591     if (shm_pool == NULL)
 592         goto fail;
 593
 594     _client_tizen_screenshooter_destroy_anonymous_file(fd);
 595
 596     return shm_pool;
 597
 598 fail:
 599     if (fd > 0)
 600         _client_tizen_screenshooter_destroy_anonymous_file(fd);
 601
 602     return NULL;
 603 }
 604
 605 void
 606 _client_tizen_screenshooter_destroy_shm_pool(struct wl_shm_pool *shm_pool)
 607 {
 608     if (!shm_pool)
 609         return;
 610
 611     wl_shm_pool_destroy(shm_pool);
 612 }
 613
 614 static void
 615 client_registry_cb_global(void *data, struct wl_registry *registry,
 616     uint32_t name, const char *interface, uint32_t version)
 617 {
 618     ds_inf("%s", __func__);
 619
 620     MockScreenShooterClient *client = static_cast<MockScreenShooterClient *>(data);
 621     struct tizen_screenshooter *screenshooter_res;
 622     struct wl_shm *shm_res;
 623     struct wl_shm_pool *shm_pool;
 624     struct wl_output *output_res;
 625
 626     if (!strcmp(interface, "wl_shm")) {
 627         shm_res = (struct wl_shm *)wl_registry_bind(registry,
 628             name, &wl_shm_interface, 1);
 629         if (shm_res == nullptr) {
 630             ds_err("wl_registry_bind() failed. wl_shm resource.");
 631             return;
 632         }
 633         shm_pool = _client_tizen_screenshooter_create_shm_pool(shm_res, SHM_BUF_WIDTH * 4 * SHM_BUF_HEIGHT);
 634         if (shm_pool == NULL) {
 635             ds_err("wl_registry_bind() failed. wl_shm_pool create fail.");
 636             wl_shm_destroy(shm_res);
 637             return;
 638         }
 639         client->SetWlShm(shm_res);
 640         client->SetWlShmPool(shm_pool);
 641     }  else if (!strcmp(interface, "wl_output")) {
 642         output_res = (struct wl_output *)wl_registry_bind(registry,
 643             name, &wl_output_interface, 1);
 644         if (output_res == nullptr) {
 645             ds_err("wl_registry_bind() failed. wl_output resource.");
 646             return;
 647         }
 648         client->SetWlOutput(output_res);
 649     } else if (!strcmp(interface, "tizen_screenshooter")) {
 650         screenshooter_res = (struct tizen_screenshooter *)wl_registry_bind(registry,
 651             name, &tizen_screenshooter_interface, TIZEN_SCREENSHOOTER_VERSION);
 652         if (screenshooter_res == nullptr) {
 653             ds_err("wl_registry_bind() failed. tizen_screenshooter resource.");
 654             return;
 655         }
 656         client->SetTizenScreenShooter(screenshooter_res);
 657
 658         tizen_screenshooter_add_listener(screenshooter_res,
 659             &screenshooter_cb_listener, client);
 660     }
 661 }
 662
 663 static void
 664 client_registry_cb_global_remove(void *data, struct wl_registry *registry,
 665     uint32_t name)
 666 {
 667     ds_inf("%s", __func__);
 668
 669     MockScreenShooterClient *client = static_cast<MockScreenShooterClient *>(data);
 670     struct wl_shm *shm_res = client->GetWlShm();
 671     struct wl_shm_pool *shm_pool = client->GetWlShmPool();
 672     struct tizen_screenshooter *screenshooter_res = client->GetTizenScreenShooter();
 673     struct tizen_screenmirror *screenmirror_res = client->GetTizenScreenMirror();
 674
 675     if (screenmirror_res)
 676         tizen_screenmirror_destroy(screenmirror_res);
 677     tizen_screenshooter_destroy(screenshooter_res);
 678     _client_tizen_screenshooter_destroy_shm_pool(shm_pool);
 679     wl_shm_destroy(shm_res);
 680 }
 681
 682 static const struct wl_registry_listener registry_listener = {
 683     .global = client_registry_cb_global,
 684     .global_remove = client_registry_cb_global_remove
 685 };
 686
 687 class ScreenShooterTest : public ::testing::Test
 688 {
 689 public:
 690     void SetUp(void) override;
 691     void TearDown(void) override;
 692
 693     MockScreenShooterCompositor *comp;
 694     MockScreenShooterClient *client;
 695     struct wl_output *output_res;
 696     struct wl_shm *shm_res;
 697     struct wl_shm_pool *shm_pool;
 698     struct wl_buffer *buffer_res1;
 699     struct wl_buffer *buffer_res2;
 700     struct wl_buffer *buffer_res3;
 701     struct tizen_screenshooter *screenshooter_res;
 702     struct tizen_screenmirror *screenmirror_res;
 703 };
 704
 705 void
 706 ScreenShooterTest::SetUp(void)
 707 {
 708     //ds_log_init(DS_DBG, NULL);
 709
 710     ds_inf("%s", __func__);
 711
 712     comp = new MockScreenShooterCompositor();
 713     client = new MockScreenShooterClient(&registry_listener);
 714     output_res = client->GetWlOutput();
 715     shm_res = client->GetWlShm();
 716     shm_pool = client->GetWlShmPool();
 717     screenshooter_res = client->GetTizenScreenShooter();
 718
 719     client->RoundTrip();
 720 }
 721
 722 void
 723 ScreenShooterTest::TearDown(void)
 724 {
 725     ds_inf("%s", __func__);
 726
 727     client->RoundTrip();
 728
 729     delete client;
 730     delete comp;
 731 }
 732
 733 TEST_F(ScreenShooterTest, Create_P)
 734 {
 735     EXPECT_TRUE(true);
 736 }
 737
 738 TEST_F(ScreenShooterTest, Req_TizenScreenShooterShot)
 739 {
 740     buffer_res1 = wl_shm_pool_create_buffer(shm_pool, 0,
 741         SHM_BUF_WIDTH, SHM_BUF_HEIGHT, SHM_BUF_STRIDE, SHM_BUF_FORMAT);
 742     tizen_screenshooter_shoot(screenshooter_res, output_res, buffer_res1);
 743     client->RoundTrip();
 744     EXPECT_TRUE(comp->bShoot);
 745     comp->Process();
 746     EXPECT_TRUE(client->bShootEvent);
 747 }