src/shell.c

   1 /*
   2  * Copyright © 2019 Collabora, Ltd.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial
  14  * portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  20  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  21  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  */
  25
  26 #include "ivi-compositor.h"
  27 #include "policy.h"
  28
  29 #include <assert.h>
  30 #include <errno.h>
  31 #include <fcntl.h>
  32 #include <signal.h>
  33 #include <string.h>
  34 #include <sys/socket.h>
  35 #include <sys/types.h>
  36 #include <unistd.h>
  37 #include <libweston/libweston.h>
  38 #include <libweston/config-parser.h>
  39
  40 #include "shared/os-compatibility.h"
  41
  42 #include "agl-shell-server-protocol.h"
  43 #include "agl-shell-desktop-server-protocol.h"
  44
  45 #ifdef HAVE_WALTHAM
  46 #include <waltham-transmitter/transmitter_api.h>
  47 #endif
  48
  49 static void
  50 create_black_surface_view(struct ivi_output *output);
  51
  52 void
  53 agl_shell_desktop_advertise_application_id(struct ivi_compositor *ivi,
  54                                            struct ivi_surface *surface)
  55 {
  56         struct desktop_client *dclient;
  57         static bool display_adv = false;
  58
  59         if (surface->advertised_on_launch)
  60                 return;
  61
  62         /* advertise to all desktop clients the new surface */
  63         wl_list_for_each(dclient, &ivi->desktop_clients, link) {
  64                 const char *app_id =
  65                         weston_desktop_surface_get_app_id(surface->dsurface);
  66                 if (app_id == NULL) {
  67                         if (!display_adv) {
  68                                 weston_log("WARNING app_is is null, unable to advertise\n");
  69                                 display_adv = true;
  70                         }
  71                         return;
  72                 }
  73                 agl_shell_desktop_send_application(dclient->resource, app_id);
  74                 surface->advertised_on_launch = true;
  75         }
  76 }
  77
  78 void
  79 ivi_set_desktop_surface(struct ivi_surface *surface)
  80 {
  81         struct ivi_compositor *ivi = surface->ivi;
  82         assert(surface->role == IVI_SURFACE_ROLE_NONE);
  83
  84         surface->role = IVI_SURFACE_ROLE_DESKTOP;
  85         wl_list_insert(&surface->ivi->surfaces, &surface->link);
  86
  87         agl_shell_desktop_advertise_application_id(ivi, surface);
  88 }
  89
  90 static void
  91 ivi_set_desktop_surface_popup(struct ivi_surface *surface)
  92 {
  93         struct ivi_compositor *ivi = surface->ivi;
  94         assert(surface->role == IVI_SURFACE_ROLE_NONE);
  95
  96         surface->role = IVI_SURFACE_ROLE_POPUP;
  97         wl_list_insert(&ivi->surfaces, &surface->link);
  98
  99         agl_shell_desktop_advertise_application_id(ivi, surface);
 100 }
 101
 102 static void
 103 ivi_set_desktop_surface_fullscreen(struct ivi_surface *surface)
 104 {
 105         struct ivi_compositor *ivi = surface->ivi;
 106         assert(surface->role == IVI_SURFACE_ROLE_NONE);
 107
 108         surface->role = IVI_SURFACE_ROLE_FULLSCREEN;
 109         wl_list_insert(&ivi->surfaces, &surface->link);
 110
 111         agl_shell_desktop_advertise_application_id(ivi, surface);
 112 }
 113
 114 #ifdef HAVE_WALTHAM
 115 void
 116 ivi_destroy_waltham_destroy(struct ivi_surface *surface)
 117 {
 118         struct ivi_compositor *ivi = surface->ivi;
 119         const struct weston_transmitter_api *api =
 120                 ivi->waltham_transmitter_api;
 121
 122         if (!api)
 123                 return;
 124
 125         if (surface->waltham_surface.transmitter_surface)
 126                 api->surface_destroy(surface->waltham_surface.transmitter_surface);
 127 }
 128
 129 static void
 130 ivi_output_notify_waltham_plugin(struct ivi_surface *surface)
 131 {
 132         struct ivi_compositor *ivi = surface->ivi;
 133         const struct weston_transmitter_api *api = ivi->waltham_transmitter_api;
 134         struct weston_transmitter *transmitter;
 135         struct weston_transmitter_remote *trans_remote;
 136         struct weston_surface *weston_surface;
 137         struct weston_output *woutput = surface->remote.output->output;
 138         const char *app_id;
 139
 140         if (!api)
 141                 return;
 142
 143         transmitter = api->transmitter_get(ivi->compositor);
 144         if (!transmitter)
 145                 return;
 146
 147         trans_remote = api->get_transmitter_remote(woutput->name, transmitter);
 148         if (!trans_remote) {
 149                 weston_log("Could not find a valie weston_transmitter_remote "
 150                                 "that matches the output %s\n", woutput->name);
 151                 return;
 152         }
 153
 154         app_id = weston_desktop_surface_get_app_id(surface->dsurface);
 155         weston_surface =
 156                 weston_desktop_surface_get_surface(surface->dsurface);
 157
 158         weston_log("Forwarding app_id %s to remote %s\n", app_id, woutput->name);
 159
 160         /* this will have the effect of informing the remote side to create a
 161          * surface with the name app_id. W/ xdg-shell the following happens:
 162          *
 163          * compositor (server):
 164          * surface_push_to_remote():
 165          *      waltham-transmitter plug-in
 166          *              -> wthp_ivi_app_id_surface_create()
 167          *
 168          * client -- on the receiver side:
 169          *      -> wthp_ivi_app_id_surface_create()
 170          *              -> wth_receiver_weston_main()
 171          *                      -> wl_compositor_create_surface()
 172          *                      -> xdg_wm_base_get_xdg_surface
 173          *                      -> xdg_toplevel_set_app_id()
 174          *                      -> gst_init()
 175          *                      -> gst_parse_launch()
 176          *
 177          * wth_receiver_weston_main() will be invoked from the handler of
 178          * wthp_ivi_app_id_surface_create() and is responsible for setting-up
 179          * the gstreamer pipeline as well.
 180          */
 181         surface->waltham_surface.transmitter_surface =
 182             api->surface_push_to_remote(weston_surface, app_id, trans_remote, NULL);
 183 }
 184
 185 #else
 186 void
 187 ivi_destroy_waltham_destroy(struct ivi_surface *surface)
 188 {
 189 }
 190 static void
 191 ivi_output_notify_waltham_plugin(struct ivi_surface *surface)
 192 {
 193 }
 194 #endif
 195
 196 static void
 197 ivi_set_desktop_surface_remote(struct ivi_surface *surface)
 198 {
 199         struct ivi_compositor *ivi = surface->ivi;
 200         struct weston_view *view;
 201         struct ivi_output *output = surface->remote.output;
 202
 203         assert(surface->role == IVI_SURFACE_ROLE_NONE);
 204
 205         /* remote type are the same as desktop just that client can tell
 206          * the compositor to start on another output */
 207         surface->role = IVI_SURFACE_ROLE_REMOTE;
 208
 209         /* if thew black surface view is mapped on the mean we need
 210          * to remove it in order to start showing the 'remote' surface
 211          * just being added */
 212         view = output->fullscreen_view.fs->view;
 213         if (view->is_mapped || view->surface->is_mapped)
 214                 remove_black_surface(output);
 215
 216         if (output->type == OUTPUT_WALTHAM)
 217                 ivi_output_notify_waltham_plugin(surface);
 218
 219         wl_list_insert(&ivi->surfaces, &surface->link);
 220 }
 221
 222
 223 static void
 224 ivi_set_desktop_surface_split(struct ivi_surface *surface)
 225 {
 226         struct ivi_compositor *ivi = surface->ivi;
 227         assert(surface->role == IVI_SURFACE_ROLE_NONE);
 228
 229         if (surface->split.orientation == AGL_SHELL_DESKTOP_APP_ROLE_SPLIT_VERTICAL)
 230                 surface->role = IVI_SURFACE_ROLE_SPLIT_V;
 231         else
 232                 surface->role = IVI_SURFACE_ROLE_SPLIT_H;
 233
 234         wl_list_insert(&ivi->surfaces, &surface->link);
 235
 236         agl_shell_desktop_advertise_application_id(ivi, surface);
 237 }
 238
 239 static struct pending_popup *
 240 ivi_ensure_popup(struct ivi_output *ioutput, int x, int y, int bx, int by,
 241                  int width, int height, const char *app_id)
 242 {
 243         struct pending_popup *p_popup = zalloc(sizeof(*p_popup));
 244         size_t len_app_id = strlen(app_id);
 245
 246         if (!p_popup)
 247                 return NULL;
 248         p_popup->app_id = zalloc(sizeof(char) * (len_app_id + 1));
 249         if (!p_popup->app_id) {
 250                 free(p_popup);
 251                 return NULL;
 252         }
 253         memcpy(p_popup->app_id, app_id, len_app_id);
 254         p_popup->ioutput = ioutput;
 255         p_popup->x = x;
 256         p_popup->y = y;
 257
 258         p_popup->bb.x = bx;
 259         p_popup->bb.y = by;
 260         p_popup->bb.width = width;
 261         p_popup->bb.height = height;
 262
 263         return p_popup;
 264 }
 265
 266 static void
 267 ivi_update_popup(struct ivi_output *ioutput, int x, int y, int bx, int by,
 268                  int width, int height, const char *app_id, struct pending_popup *p_popup)
 269 {
 270         size_t len_app_id = strlen(app_id);
 271
 272         wl_list_remove(&p_popup->link);
 273         wl_list_init(&p_popup->link);
 274
 275         memset(p_popup->app_id, 0, strlen(app_id) + 1);
 276         free(p_popup->app_id);
 277
 278         p_popup->app_id = zalloc(sizeof(char) * (len_app_id + 1));
 279         if (!p_popup->app_id)
 280                 return;
 281         memcpy(p_popup->app_id, app_id, len_app_id);
 282
 283         p_popup->ioutput = ioutput;
 284         p_popup->x = x;
 285         p_popup->y = y;
 286
 287         p_popup->bb.x = bx;
 288         p_popup->bb.y = by;
 289         p_popup->bb.width = width;
 290         p_popup->bb.height = height;
 291 }
 292
 293 static struct pending_fullscreen *
 294 ivi_ensure_fullscreen(struct ivi_output *ioutput, const char *app_id)
 295 {
 296         struct pending_fullscreen *p_fullscreen = zalloc(sizeof(*p_fullscreen));
 297         size_t len_app_id = strlen(app_id);
 298
 299         if (!p_fullscreen)
 300                 return NULL;
 301         p_fullscreen->app_id = zalloc(sizeof(char) * (len_app_id + 1));
 302         if (!p_fullscreen->app_id) {
 303                 free(p_fullscreen);
 304                 return NULL;
 305         }
 306         memcpy(p_fullscreen->app_id, app_id, len_app_id);
 307
 308         p_fullscreen->ioutput = ioutput;
 309         return p_fullscreen;
 310 }
 311
 312 static void
 313 ivi_update_fullscreen(struct ivi_output *ioutput, const char *app_id,
 314                       struct pending_fullscreen *p_fullscreen)
 315 {
 316         size_t len_app_id = strlen(app_id);
 317
 318         wl_list_remove(&p_fullscreen->link);
 319         wl_list_init(&p_fullscreen->link);
 320
 321         memset(p_fullscreen->app_id, 0, strlen(app_id) + 1);
 322         free(p_fullscreen->app_id);
 323
 324         p_fullscreen->app_id = zalloc(sizeof(char) * (len_app_id + 1));
 325         if (!p_fullscreen->app_id)
 326                 return;
 327         memcpy(p_fullscreen->app_id, app_id, len_app_id);
 328
 329         p_fullscreen->ioutput = ioutput;
 330 }
 331
 332 static struct pending_remote *
 333 ivi_ensure_remote(struct ivi_output *ioutput, const char *app_id)
 334 {
 335         struct pending_remote *p_remote = zalloc(sizeof(*p_remote));
 336         size_t len_app_id = strlen(app_id);
 337
 338         if (!p_remote)
 339                 return NULL;
 340         p_remote->app_id = zalloc(sizeof(char) * (len_app_id + 1));
 341         if (!p_remote->app_id) {
 342                 free(p_remote);
 343                 return NULL;
 344         }
 345         memcpy(p_remote->app_id, app_id, len_app_id);
 346
 347         p_remote->ioutput = ioutput;
 348         return p_remote;
 349 }
 350
 351 static void
 352 ivi_update_remote(struct ivi_output *ioutput, const char *app_id,
 353                       struct pending_remote *p_remote)
 354 {
 355         size_t len_app_id = strlen(app_id);
 356
 357         wl_list_remove(&p_remote->link);
 358         wl_list_init(&p_remote->link);
 359
 360         memset(p_remote->app_id, 0, strlen(app_id) + 1);
 361         free(p_remote->app_id);
 362
 363         p_remote->app_id = zalloc(sizeof(char) * (len_app_id + 1));
 364         if (!p_remote->app_id)
 365                 return;
 366         memcpy(p_remote->app_id, app_id, len_app_id);
 367
 368         p_remote->ioutput = ioutput;
 369 }
 370
 371 static void
 372 ivi_set_pending_desktop_surface_popup(struct ivi_output *ioutput, int x, int y, int bx,
 373                                       int by, int width, int height, const char *app_id)
 374 {
 375         struct ivi_compositor *ivi = ioutput->ivi;
 376         struct pending_popup *p_popup = NULL;
 377         struct pending_popup *popup;
 378
 379         wl_list_for_each(popup, &ivi->popup_pending_apps, link)
 380                 if (!strcmp(app_id, popup->app_id))
 381                         p_popup = popup;
 382
 383         if (!p_popup)
 384                 p_popup = ivi_ensure_popup(ioutput, x, y, bx, by, width, height, app_id);
 385         else
 386                 ivi_update_popup(ioutput, x, y, bx, by, width, height, app_id, p_popup);
 387         if (!p_popup)
 388                 return;
 389
 390         wl_list_insert(&ivi->popup_pending_apps, &p_popup->link);
 391 }
 392
 393 static void
 394 ivi_set_pending_desktop_surface_fullscreen(struct ivi_output *ioutput,
 395                                            const char *app_id)
 396 {
 397         struct ivi_compositor *ivi = ioutput->ivi;
 398         struct pending_fullscreen *p_fullscreen = NULL;
 399         struct pending_fullscreen *fullscreen;
 400
 401         wl_list_for_each(fullscreen, &ivi->fullscreen_pending_apps, link)
 402                 if (!strcmp(app_id, fullscreen->app_id))
 403                         p_fullscreen = fullscreen;
 404
 405         if (!p_fullscreen)
 406                 p_fullscreen = ivi_ensure_fullscreen(ioutput, app_id);
 407         else
 408                 ivi_update_fullscreen(ioutput, app_id, p_fullscreen);
 409
 410         if (!p_fullscreen)
 411                 return;
 412         wl_list_insert(&ivi->fullscreen_pending_apps, &p_fullscreen->link);
 413 }
 414
 415 static void
 416 ivi_set_pending_desktop_surface_split(struct ivi_output *ioutput,
 417                                       const char *app_id, uint32_t orientation)
 418 {
 419         struct ivi_compositor *ivi = ioutput->ivi;
 420         struct ivi_surface *surf;
 421         size_t len_app_id = strlen(app_id);
 422         struct pending_split *split;
 423
 424         if (orientation != AGL_SHELL_DESKTOP_APP_ROLE_SPLIT_VERTICAL &&
 425             orientation != AGL_SHELL_DESKTOP_APP_ROLE_SPLIT_HORIZONTAL)
 426                 return;
 427
 428         /* more than one is un-supported, do note we need to do
 429          * conversion for surface roles instead of using the protocol ones */
 430         wl_list_for_each(surf, &ivi->surfaces, link)
 431                 if (surf->role == IVI_SURFACE_ROLE_SPLIT_V ||
 432                     surf->role == IVI_SURFACE_ROLE_SPLIT_H)
 433                         return;
 434
 435         split = zalloc(sizeof(*split));
 436         if (!split)
 437                 return;
 438         split->app_id = zalloc(sizeof(char) * (len_app_id + 1));
 439         if (!split->app_id) {
 440                 free(split);
 441                 return;
 442         }
 443         memcpy(split->app_id, app_id, len_app_id);
 444
 445         split->ioutput = ioutput;
 446         split->orientation = orientation;
 447
 448         wl_list_insert(&ivi->split_pending_apps, &split->link);
 449 }
 450
 451 void
 452 ivi_set_pending_desktop_surface_remote(struct ivi_output *ioutput,
 453                 const char *app_id)
 454 {
 455         struct ivi_compositor *ivi = ioutput->ivi;
 456         struct pending_remote *remote;
 457         struct pending_remote *p_remote = NULL;
 458
 459         wl_list_for_each(remote, &ivi->remote_pending_apps, link)
 460                 if (!strcmp(app_id, remote->app_id))
 461                         p_remote = remote;
 462
 463         if (!p_remote)
 464                 p_remote = ivi_ensure_remote(ioutput, app_id);
 465         else
 466                 ivi_update_remote(ioutput, app_id, p_remote);
 467         if (!p_remote)
 468                 return;
 469
 470         wl_list_insert(&ivi->remote_pending_apps, &p_remote->link);
 471 }
 472
 473
 474 static void
 475 ivi_remove_pending_desktop_surface_split(struct pending_split *split)
 476 {
 477         free(split->app_id);
 478         wl_list_remove(&split->link);
 479         free(split);
 480 }
 481
 482 static void
 483 ivi_remove_pending_desktop_surface_fullscreen(struct pending_fullscreen *fs)
 484 {
 485         free(fs->app_id);
 486         wl_list_remove(&fs->link);
 487         free(fs);
 488 }
 489
 490 static void
 491 ivi_remove_pending_desktop_surface_popup(struct pending_popup *p_popup)
 492 {
 493         free(p_popup->app_id);
 494         wl_list_remove(&p_popup->link);
 495         free(p_popup);
 496 }
 497
 498 static void
 499 ivi_remove_pending_desktop_surface_remote(struct pending_remote *remote)
 500 {
 501         free(remote->app_id);
 502         wl_list_remove(&remote->link);
 503         free(remote);
 504 }
 505
 506 static bool
 507 ivi_compositor_keep_pending_surfaces(struct ivi_surface *surface)
 508 {
 509         return surface->ivi->keep_pending_surfaces;
 510 }
 511
 512 static bool
 513 ivi_check_pending_desktop_surface_popup(struct ivi_surface *surface)
 514 {
 515         struct ivi_compositor *ivi = surface->ivi;
 516         struct pending_popup *p_popup, *next_p_popup;
 517         const char *_app_id =
 518                         weston_desktop_surface_get_app_id(surface->dsurface);
 519
 520         if (wl_list_empty(&ivi->popup_pending_apps) || !_app_id)
 521                 return false;
 522
 523         wl_list_for_each_safe(p_popup, next_p_popup,
 524                               &ivi->popup_pending_apps, link) {
 525                 if (!strcmp(_app_id, p_popup->app_id)) {
 526                         surface->popup.output = p_popup->ioutput;
 527                         surface->popup.x = p_popup->x;
 528                         surface->popup.y = p_popup->y;
 529
 530                         surface->popup.bb.x = p_popup->bb.x;
 531                         surface->popup.bb.y = p_popup->bb.y;
 532                         surface->popup.bb.width = p_popup->bb.width;
 533                         surface->popup.bb.height = p_popup->bb.height;
 534
 535                         if (!ivi_compositor_keep_pending_surfaces(surface))
 536                                 ivi_remove_pending_desktop_surface_popup(p_popup);
 537                         return true;
 538                 }
 539         }
 540
 541         return false;
 542 }
 543
 544 static bool
 545 ivi_check_pending_desktop_surface_split(struct ivi_surface *surface)
 546 {
 547         struct pending_split *split_surf, *next_split_surf;
 548         struct ivi_compositor *ivi = surface->ivi;
 549         const char *_app_id =
 550                         weston_desktop_surface_get_app_id(surface->dsurface);
 551
 552         if (wl_list_empty(&ivi->split_pending_apps) || !_app_id)
 553                 return false;
 554
 555         wl_list_for_each_safe(split_surf, next_split_surf,
 556                               &ivi->split_pending_apps, link) {
 557                 if (!strcmp(_app_id, split_surf->app_id)) {
 558                         surface->split.output = split_surf->ioutput;
 559                         surface->split.orientation = split_surf->orientation;
 560                         if (!ivi_compositor_keep_pending_surfaces(surface))
 561                                 ivi_remove_pending_desktop_surface_split(split_surf);
 562                         return true;
 563                 }
 564         }
 565
 566         return false;
 567 }
 568
 569 static bool
 570 ivi_check_pending_desktop_surface_fullscreen(struct ivi_surface *surface)
 571 {
 572         struct pending_fullscreen *fs_surf, *next_fs_surf;
 573         struct ivi_compositor *ivi = surface->ivi;
 574         const char *_app_id =
 575                         weston_desktop_surface_get_app_id(surface->dsurface);
 576
 577         if (wl_list_empty(&ivi->fullscreen_pending_apps) || !_app_id)
 578                 return false;
 579
 580         wl_list_for_each_safe(fs_surf, next_fs_surf,
 581                               &ivi->fullscreen_pending_apps, link) {
 582                 if (!strcmp(_app_id, fs_surf->app_id)) {
 583                         surface->fullscreen.output = fs_surf->ioutput;
 584                         if (!ivi_compositor_keep_pending_surfaces(surface))
 585                                 ivi_remove_pending_desktop_surface_fullscreen(fs_surf);
 586                         return true;
 587                 }
 588         }
 589
 590         return false;
 591 }
 592
 593 static bool
 594 ivi_check_pending_desktop_surface_remote(struct ivi_surface *surface)
 595 {
 596         struct pending_remote *remote_surf, *next_remote_surf;
 597         struct ivi_compositor *ivi = surface->ivi;
 598         const char *_app_id =
 599                 weston_desktop_surface_get_app_id(surface->dsurface);
 600
 601         if (wl_list_empty(&ivi->remote_pending_apps) || !_app_id)
 602                 return false;
 603
 604         wl_list_for_each_safe(remote_surf, next_remote_surf,
 605                               &ivi->remote_pending_apps, link) {
 606                 if (!strcmp(_app_id, remote_surf->app_id)) {
 607                         surface->remote.output = remote_surf->ioutput;
 608                         if (!ivi_compositor_keep_pending_surfaces(surface))
 609                                 ivi_remove_pending_desktop_surface_remote(remote_surf);
 610                         return true;
 611                 }
 612         }
 613
 614         return false;
 615 }
 616 void
 617 ivi_check_pending_surface_desktop(struct ivi_surface *surface,
 618                                   enum ivi_surface_role *role)
 619 {
 620         struct ivi_compositor *ivi = surface->ivi;
 621         struct wl_list *role_pending_list;
 622         struct pending_popup *p_popup;
 623         struct pending_split *p_split;
 624         struct pending_fullscreen *p_fullscreen;
 625         struct pending_remote *p_remote;
 626         const char *app_id =
 627                 weston_desktop_surface_get_app_id(surface->dsurface);
 628
 629         role_pending_list = &ivi->popup_pending_apps;
 630         wl_list_for_each(p_popup, role_pending_list, link) {
 631                 if (app_id && !strcmp(app_id, p_popup->app_id)) {
 632                         *role = IVI_SURFACE_ROLE_POPUP;
 633                         return;
 634                 }
 635         }
 636
 637         role_pending_list = &ivi->split_pending_apps;
 638         wl_list_for_each(p_split, role_pending_list, link) {
 639                 if (app_id && !strcmp(app_id, p_split->app_id)) {
 640                         *role = IVI_SURFACE_ROLE_SPLIT_V;
 641                         return;
 642                 }
 643         }
 644
 645         role_pending_list = &ivi->fullscreen_pending_apps;
 646         wl_list_for_each(p_fullscreen, role_pending_list, link) {
 647                 if (app_id && !strcmp(app_id, p_fullscreen->app_id)) {
 648                         *role = IVI_SURFACE_ROLE_FULLSCREEN;
 649                         return;
 650                 }
 651         }
 652
 653         role_pending_list = &ivi->remote_pending_apps;
 654         wl_list_for_each(p_remote, role_pending_list, link) {
 655                 if (app_id && !strcmp(app_id, p_remote->app_id)) {
 656                         *role = IVI_SURFACE_ROLE_REMOTE;
 657                         return;
 658                 }
 659         }
 660
 661         /* else, we are a regular desktop surface */
 662         *role = IVI_SURFACE_ROLE_DESKTOP;
 663 }
 664
 665
 666 void
 667 ivi_check_pending_desktop_surface(struct ivi_surface *surface)
 668 {
 669         bool ret = false;
 670
 671         ret = ivi_check_pending_desktop_surface_popup(surface);
 672         if (ret) {
 673                 ivi_set_desktop_surface_popup(surface);
 674                 ivi_layout_popup_committed(surface);
 675                 return;
 676         }
 677
 678         ret = ivi_check_pending_desktop_surface_split(surface);
 679         if (ret) {
 680                 ivi_set_desktop_surface_split(surface);
 681                 ivi_layout_split_committed(surface);
 682                 return;
 683         }
 684
 685         ret = ivi_check_pending_desktop_surface_fullscreen(surface);
 686         if (ret) {
 687                 ivi_set_desktop_surface_fullscreen(surface);
 688                 ivi_layout_fullscreen_committed(surface);
 689                 return;
 690         }
 691
 692         ret = ivi_check_pending_desktop_surface_remote(surface);
 693         if (ret) {
 694                 ivi_set_desktop_surface_remote(surface);
 695                 ivi_layout_desktop_committed(surface);
 696                 return;
 697         }
 698
 699         /* if we end up here means we have a regular desktop app and
 700          * try to activate it */
 701         ivi_set_desktop_surface(surface);
 702         ivi_layout_desktop_committed(surface);
 703 }
 704
 705 void
 706 ivi_shell_init_black_fs(struct ivi_compositor *ivi)
 707 {
 708         struct ivi_output *out;
 709
 710         wl_list_for_each(out, &ivi->outputs, link) {
 711                 create_black_surface_view(out);
 712                 insert_black_surface(out);
 713         }
 714 }
 715
 716 int
 717 ivi_shell_init(struct ivi_compositor *ivi)
 718 {
 719         weston_layer_init(&ivi->hidden, ivi->compositor);
 720         weston_layer_init(&ivi->background, ivi->compositor);
 721         weston_layer_init(&ivi->normal, ivi->compositor);
 722         weston_layer_init(&ivi->panel, ivi->compositor);
 723         weston_layer_init(&ivi->popup, ivi->compositor);
 724         weston_layer_init(&ivi->fullscreen, ivi->compositor);
 725
 726         weston_layer_set_position(&ivi->hidden,
 727                                   WESTON_LAYER_POSITION_HIDDEN);
 728         weston_layer_set_position(&ivi->background,
 729                                   WESTON_LAYER_POSITION_BACKGROUND);
 730         weston_layer_set_position(&ivi->normal,
 731                                   WESTON_LAYER_POSITION_NORMAL);
 732         weston_layer_set_position(&ivi->panel,
 733                                   WESTON_LAYER_POSITION_UI);
 734         weston_layer_set_position(&ivi->popup,
 735                                   WESTON_LAYER_POSITION_TOP_UI);
 736         weston_layer_set_position(&ivi->fullscreen,
 737                                   WESTON_LAYER_POSITION_FULLSCREEN);
 738
 739         return 0;
 740 }
 741
 742
 743 static void
 744 ivi_surf_destroy(struct ivi_surface *surf)
 745 {
 746         struct weston_surface *wsurface = surf->view->surface;
 747
 748         if (weston_surface_is_mapped(wsurface)) {
 749                 weston_desktop_surface_unlink_view(surf->view);
 750                 weston_view_destroy(surf->view);
 751         }
 752
 753         wl_list_remove(&surf->link);
 754         free(surf);
 755 }
 756
 757 static void
 758 ivi_shell_destroy_views_on_layer(struct weston_layer *layer)
 759 {
 760         struct weston_view *view, *view_next;
 761
 762         wl_list_for_each_safe(view, view_next, &layer->view_list.link, layer_link.link) {
 763                 struct ivi_surface *ivi_surf =
 764                         get_ivi_shell_surface(view->surface);
 765                 if (ivi_surf)
 766                         ivi_surf_destroy(ivi_surf);
 767         }
 768 }
 769
 770 void
 771 ivi_shell_finalize(struct ivi_compositor *ivi)
 772 {
 773         struct ivi_output *output;
 774
 775         ivi_shell_destroy_views_on_layer(&ivi->hidden);
 776         weston_layer_fini(&ivi->hidden);
 777
 778         ivi_shell_destroy_views_on_layer(&ivi->background);
 779         weston_layer_fini(&ivi->background);
 780
 781         ivi_shell_destroy_views_on_layer(&ivi->normal);
 782         weston_layer_fini(&ivi->normal);
 783
 784         ivi_shell_destroy_views_on_layer(&ivi->panel);
 785         weston_layer_fini(&ivi->panel);
 786
 787         ivi_shell_destroy_views_on_layer(&ivi->popup);
 788         weston_layer_fini(&ivi->popup);
 789
 790         wl_list_for_each(output, &ivi->outputs, link) {
 791                 if (output->fullscreen_view.fs->view) {
 792                         weston_surface_destroy(output->fullscreen_view.fs->view->surface);
 793                         output->fullscreen_view.fs->view = NULL;
 794                 }
 795         }
 796         weston_layer_fini(&ivi->fullscreen);
 797 }
 798
 799 static void
 800 ivi_shell_advertise_xdg_surfaces(struct ivi_compositor *ivi, struct wl_resource *resource)
 801 {
 802         struct ivi_surface *surface;
 803
 804         wl_list_for_each(surface, &ivi->surfaces, link) {
 805                 const char *app_id =
 806                         weston_desktop_surface_get_app_id(surface->dsurface);
 807                 if (app_id == NULL) {
 808                         weston_log("WARNING app_is is null, unable to advertise\n");
 809                         return;
 810                 }
 811                 agl_shell_desktop_send_application(resource, app_id);
 812         }
 813 }
 814
 815 static void
 816 client_exec(const char *command, int fd)
 817 {
 818         sigset_t sig;
 819         char s[32];
 820
 821         /* Don't give the child our signal mask */
 822         sigfillset(&sig);
 823         sigprocmask(SIG_UNBLOCK, &sig, NULL);
 824
 825         /* Launch clients as the user; don't give them the wrong euid */
 826         if (seteuid(getuid()) == -1) {
 827                 weston_log("seteuid failed: %s\n", strerror(errno));
 828                 return;
 829         }
 830
 831         /* Duplicate fd to unset the CLOEXEC flag. We don't need to worry about
 832          * clobbering fd, as we'll exit/exec either way.
 833          */
 834         fd = dup(fd);
 835         if (fd == -1) {
 836                 weston_log("dup failed: %s\n", strerror(errno));
 837                 return;
 838         }
 839
 840         snprintf(s, sizeof s, "%d", fd);
 841         setenv("WAYLAND_SOCKET", s, 1);
 842
 843         execl("/bin/sh", "/bin/sh", "-c", command, NULL);
 844         weston_log("executing '%s' failed: %s", command, strerror(errno));
 845 }
 846
 847 static struct wl_client *
 848 launch_shell_client(struct ivi_compositor *ivi, const char *command)
 849 {
 850         struct wl_client *client;
 851         int sock[2];
 852         pid_t pid;
 853
 854         weston_log("launching' %s'\n", command);
 855
 856         if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sock) < 0) {
 857                 weston_log("socketpair failed while launching '%s': %s\n",
 858                            command, strerror(errno));
 859                 return NULL;
 860         }
 861
 862         pid = fork();
 863         if (pid == -1) {
 864                 close(sock[0]);
 865                 close(sock[1]);
 866                 weston_log("fork failed while launching '%s': %s\n",
 867                            command, strerror(errno));
 868                 return NULL;
 869         }
 870
 871         if (pid == 0) {
 872                 client_exec(command, sock[1]);
 873                 _Exit(EXIT_FAILURE);
 874         }
 875         close(sock[1]);
 876
 877         client = wl_client_create(ivi->compositor->wl_display, sock[0]);
 878         if (!client) {
 879                 close(sock[0]);
 880                 weston_log("Failed to create wayland client for '%s'",
 881                            command);
 882                 return NULL;
 883         }
 884
 885         return client;
 886 }
 887
 888 int
 889 ivi_launch_shell_client(struct ivi_compositor *ivi)
 890 {
 891         struct weston_config_section *section;
 892         char *command = NULL;
 893
 894         section = weston_config_get_section(ivi->config, "shell-client",
 895                                             NULL, NULL);
 896         if (section)
 897                 weston_config_section_get_string(section, "command",
 898                                                  &command, NULL);
 899
 900         if (!command)
 901                 return -1;
 902
 903         ivi->shell_client.client = launch_shell_client(ivi, command);
 904         if (!ivi->shell_client.client)
 905                 return -1;
 906
 907         return 0;
 908 }
 909
 910 static void
 911 destroy_black_view(struct wl_listener *listener, void *data)
 912 {
 913         struct fullscreen_view *fs =
 914                 wl_container_of(listener, fs, fs_destroy);
 915
 916
 917         if (fs && fs->fs) {
 918                 wl_list_remove(&fs->fs_destroy.link);
 919                 free(fs->fs);
 920         }
 921 }
 922
 923
 924 static void
 925 create_black_surface_view(struct ivi_output *output)
 926 {
 927         struct weston_surface *surface = NULL;
 928         struct weston_view *view;
 929         struct ivi_compositor *ivi = output->ivi;
 930         struct weston_compositor *wc= ivi->compositor;
 931         struct weston_output *woutput = output->output;
 932
 933         if (!woutput)
 934                 return;
 935
 936         surface = weston_surface_create(wc);
 937         if (!surface)
 938                 return;
 939         view = weston_view_create(surface);
 940         if (!view) {
 941                 weston_surface_destroy(surface);
 942                 return;
 943         }
 944
 945         weston_surface_set_color(surface, 0.0, 0.0, 0.0, 1);
 946         weston_surface_set_size(surface, woutput->width, woutput->height);
 947         weston_view_set_position(view, woutput->x, woutput->y);
 948
 949         output->fullscreen_view.fs = zalloc(sizeof(struct ivi_surface));
 950         if (!output->fullscreen_view.fs) {
 951                 weston_surface_destroy(surface);
 952                 return;
 953         }
 954         output->fullscreen_view.fs->view = view;
 955
 956         output->fullscreen_view.fs_destroy.notify = destroy_black_view;
 957         wl_signal_add(&woutput->destroy_signal,
 958                       &output->fullscreen_view.fs_destroy);
 959 }
 960
 961 void
 962 remove_black_surface(struct ivi_output *output)
 963 {
 964         struct weston_view *view;
 965
 966         if (!output &&
 967             !output->fullscreen_view.fs &&
 968             !output->fullscreen_view.fs->view) {
 969                 weston_log("Output %s doesn't have a surface installed!\n", output->name);
 970                 return;
 971         }
 972
 973         view = output->fullscreen_view.fs->view;
 974         assert(view->is_mapped == true ||
 975                view->surface->is_mapped == true);
 976
 977         view->is_mapped = false;
 978         view->surface->is_mapped = false;
 979
 980         weston_layer_entry_remove(&view->layer_link);
 981         weston_view_update_transform(view);
 982
 983         weston_view_damage_below(view);
 984 }
 985
 986 void
 987 insert_black_surface(struct ivi_output *output)
 988 {
 989         struct weston_view *view;
 990
 991         if ((!output &&
 992             !output->fullscreen_view.fs &&
 993             !output->fullscreen_view.fs->view) || !output->output) {
 994                 weston_log("Output %s doesn't have a surface installed!\n", output->name);
 995                 return;
 996         }
 997
 998         view = output->fullscreen_view.fs->view;
 999         if (view->is_mapped || view->surface->is_mapped)
1000                 return;
1001
1002         weston_layer_entry_remove(&view->layer_link);
1003         weston_layer_entry_insert(&output->ivi->fullscreen.view_list,
1004                                   &view->layer_link);
1005
1006         view->is_mapped = true;
1007         view->surface->is_mapped = true;
1008
1009         weston_view_update_transform(view);
1010         weston_view_damage_below(view);
1011 }
1012
1013 static void
1014 shell_ready(struct wl_client *client, struct wl_resource *shell_res)
1015 {
1016         struct ivi_compositor *ivi = wl_resource_get_user_data(shell_res);
1017         struct ivi_output *output;
1018         struct ivi_surface *surface, *tmp;
1019
1020         if (ivi->shell_client.resource &&
1021             ivi->shell_client.status == BOUND_FAILED) {
1022                 wl_resource_post_error(shell_res,
1023                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
1024                                        "agl_shell has already been bound. "
1025                                        "Check out bound_fail event");
1026                 return;
1027         }
1028
1029         /* Init already finished. Do nothing */
1030         if (ivi->shell_client.ready)
1031                 return;
1032
1033
1034         ivi->shell_client.ready = true;
1035
1036         wl_list_for_each(output, &ivi->outputs, link) {
1037                 if (output->background)
1038                         remove_black_surface(output);
1039                 ivi_layout_init(ivi, output);
1040         }
1041
1042         wl_list_for_each_safe(surface, tmp, &ivi->pending_surfaces, link) {
1043                 wl_list_remove(&surface->link);
1044                 wl_list_init(&surface->link);
1045                 ivi_check_pending_desktop_surface(surface);
1046                 surface->checked_pending = true;
1047         }
1048 }
1049
1050 static void
1051 shell_set_background(struct wl_client *client,
1052                      struct wl_resource *shell_res,
1053                      struct wl_resource *surface_res,
1054                      struct wl_resource *output_res)
1055 {
1056         struct weston_head *head = weston_head_from_resource(output_res);
1057         struct weston_output *woutput = weston_head_get_output(head);
1058         struct ivi_output *output = to_ivi_output(woutput);
1059         struct weston_surface *wsurface = wl_resource_get_user_data(surface_res);
1060         struct ivi_compositor *ivi = wl_resource_get_user_data(shell_res);
1061         struct weston_desktop_surface *dsurface;
1062         struct ivi_surface *surface;
1063
1064         if (ivi->shell_client.resource &&
1065             ivi->shell_client.status == BOUND_FAILED) {
1066                 wl_resource_post_error(shell_res,
1067                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
1068                                        "agl_shell has already been bound. "
1069                                        "Check out bound_fail event");
1070                 return;
1071         }
1072
1073         dsurface = weston_surface_get_desktop_surface(wsurface);
1074         if (!dsurface) {
1075                 wl_resource_post_error(shell_res,
1076                                        AGL_SHELL_ERROR_INVALID_ARGUMENT,
1077                                        "surface must be a desktop surface");
1078                 return;
1079         }
1080
1081         surface = weston_desktop_surface_get_user_data(dsurface);
1082         if (surface->role != IVI_SURFACE_ROLE_NONE) {
1083                 wl_resource_post_error(shell_res,
1084                                        AGL_SHELL_ERROR_INVALID_ARGUMENT,
1085                                        "surface already has another ivi role");
1086                 return;
1087         }
1088
1089         if (output->background) {
1090                 wl_resource_post_error(shell_res,
1091                                        AGL_SHELL_ERROR_BACKGROUND_EXISTS,
1092                                        "output already has background");
1093                 return;
1094         }
1095
1096         surface->checked_pending = true;
1097         surface->role = IVI_SURFACE_ROLE_BACKGROUND;
1098         surface->bg.output = output;
1099         wl_list_remove(&surface->link);
1100         wl_list_init(&surface->link);
1101
1102         output->background = surface;
1103
1104         weston_desktop_surface_set_maximized(dsurface, true);
1105         weston_desktop_surface_set_size(dsurface,
1106                                         output->output->width,
1107                                         output->output->height);
1108 }
1109
1110 static void
1111 shell_set_panel(struct wl_client *client,
1112                 struct wl_resource *shell_res,
1113                 struct wl_resource *surface_res,
1114                 struct wl_resource *output_res,
1115                 uint32_t edge)
1116 {
1117         struct weston_head *head = weston_head_from_resource(output_res);
1118         struct weston_output *woutput = weston_head_get_output(head);
1119         struct ivi_output *output = to_ivi_output(woutput);
1120         struct weston_surface *wsurface = wl_resource_get_user_data(surface_res);
1121         struct ivi_compositor *ivi = wl_resource_get_user_data(shell_res);
1122         struct weston_desktop_surface *dsurface;
1123         struct ivi_surface *surface;
1124         struct ivi_surface **member;
1125         int32_t width = 0, height = 0;
1126
1127         if (ivi->shell_client.resource &&
1128             ivi->shell_client.status == BOUND_FAILED) {
1129                 wl_resource_post_error(shell_res,
1130                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
1131                                        "agl_shell has already been bound. "
1132                                        "Check out bound_fail event");
1133                 return;
1134         }
1135
1136         dsurface = weston_surface_get_desktop_surface(wsurface);
1137         if (!dsurface) {
1138                 wl_resource_post_error(shell_res,
1139                                        AGL_SHELL_ERROR_INVALID_ARGUMENT,
1140                                        "surface must be a desktop surface");
1141                 return;
1142         }
1143
1144         surface = weston_desktop_surface_get_user_data(dsurface);
1145         if (surface->role != IVI_SURFACE_ROLE_NONE) {
1146                 wl_resource_post_error(shell_res,
1147                                        AGL_SHELL_ERROR_INVALID_ARGUMENT,
1148                                        "surface already has another ivi role");
1149                 return;
1150         }
1151
1152         switch (edge) {
1153         case AGL_SHELL_EDGE_TOP:
1154                 member = &output->top;
1155                 break;
1156         case AGL_SHELL_EDGE_BOTTOM:
1157                 member = &output->bottom;
1158                 break;
1159         case AGL_SHELL_EDGE_LEFT:
1160                 member = &output->left;
1161                 break;
1162         case AGL_SHELL_EDGE_RIGHT:
1163                 member = &output->right;
1164                 break;
1165         default:
1166                 wl_resource_post_error(shell_res,
1167                                        AGL_SHELL_ERROR_INVALID_ARGUMENT,
1168                                        "invalid edge for panel");
1169                 return;
1170         }
1171
1172         if (*member) {
1173                 wl_resource_post_error(shell_res,
1174                                        AGL_SHELL_ERROR_BACKGROUND_EXISTS,
1175                                        "output already has panel on this edge");
1176                 return;
1177         }
1178
1179         surface->checked_pending = true;
1180         surface->role = IVI_SURFACE_ROLE_PANEL;
1181         surface->panel.output = output;
1182         surface->panel.edge = edge;
1183         wl_list_remove(&surface->link);
1184         wl_list_init(&surface->link);
1185
1186         *member = surface;
1187
1188         switch (surface->panel.edge) {
1189         case AGL_SHELL_EDGE_TOP:
1190         case AGL_SHELL_EDGE_BOTTOM:
1191                 width = woutput->width;
1192                 break;
1193         case AGL_SHELL_EDGE_LEFT:
1194         case AGL_SHELL_EDGE_RIGHT:
1195                 height = woutput->height;
1196                 break;
1197         }
1198
1199         weston_desktop_surface_set_size(dsurface, width, height);
1200 }
1201
1202 void
1203 shell_advertise_app_state(struct ivi_compositor *ivi, const char *app_id,
1204                           const char *data, uint32_t app_state)
1205 {
1206         struct desktop_client *dclient;
1207         uint32_t app_role;
1208         struct ivi_surface *surf = ivi_find_app(ivi, app_id);
1209         struct ivi_policy *policy = ivi->policy;
1210
1211         /* FIXME: should queue it here and see when binding agl-shell-desktop
1212          * if there are any to be sent */
1213         if (!surf)
1214                 return;
1215
1216         if (!app_id)
1217                 return;
1218
1219         if (policy && policy->api.surface_advertise_state_change &&
1220             !policy->api.surface_advertise_state_change(surf, surf->ivi)) {
1221                 return;
1222         }
1223
1224         app_role = surf->role;
1225         if (app_role == IVI_SURFACE_ROLE_POPUP)
1226                 app_role = AGL_SHELL_DESKTOP_APP_ROLE_POPUP;
1227
1228         wl_list_for_each(dclient, &ivi->desktop_clients, link)
1229                 agl_shell_desktop_send_state_app(dclient->resource, app_id,
1230                                                  data, app_state, app_role);
1231 }
1232
1233 static void
1234 shell_activate_app(struct wl_client *client,
1235                    struct wl_resource *shell_res,
1236                    const char *app_id,
1237                    struct wl_resource *output_res)
1238 {
1239         struct weston_head *head = weston_head_from_resource(output_res);
1240         struct weston_output *woutput = weston_head_get_output(head);
1241         struct ivi_compositor *ivi = wl_resource_get_user_data(shell_res);
1242         struct ivi_output *output = to_ivi_output(woutput);
1243
1244         if (ivi->shell_client.resource &&
1245             ivi->shell_client.status == BOUND_FAILED) {
1246                 wl_resource_post_error(shell_res,
1247                                        WL_DISPLAY_ERROR_INVALID_OBJECT,
1248                                        "agl_shell has already been bound. "
1249                                        "Check out bound_fail event");
1250                 return;
1251         }
1252
1253         ivi_layout_activate(output, app_id);
1254 }
1255
1256 static void
1257 shell_desktop_activate_app(struct wl_client *client,
1258                            struct wl_resource *shell_res,
1259                            const char *app_id, const char *data,
1260                            struct wl_resource *output_res)
1261 {
1262         struct weston_head *head = weston_head_from_resource(output_res);
1263         struct weston_output *woutput = weston_head_get_output(head);
1264         struct ivi_output *output = to_ivi_output(woutput);
1265
1266         ivi_layout_activate(output, app_id);
1267         shell_advertise_app_state(output->ivi, app_id,
1268                                   data, AGL_SHELL_DESKTOP_APP_STATE_ACTIVATED);
1269 }
1270
1271 static void
1272 shell_deactivate_app(struct wl_client *client,
1273                    struct wl_resource *shell_res,
1274                    const char *app_id)
1275 {
1276         struct desktop_client *dclient = wl_resource_get_user_data(shell_res);
1277         struct ivi_compositor *ivi = dclient->ivi;
1278
1279         ivi_layout_deactivate(ivi, app_id);
1280         shell_advertise_app_state(ivi, app_id,
1281                                   NULL, AGL_SHELL_DESKTOP_APP_STATE_DEACTIVATED);
1282 }
1283
1284 /* stub, no usage for the time being */
1285 static void
1286 shell_destroy(struct wl_client *client, struct wl_resource *res)
1287 {
1288 }
1289
1290 static const struct agl_shell_interface agl_shell_implementation = {
1291         .destroy = shell_destroy,
1292         .ready = shell_ready,
1293         .set_background = shell_set_background,
1294         .set_panel = shell_set_panel,
1295         .activate_app = shell_activate_app,
1296 };
1297
1298 static void
1299 shell_desktop_set_app_property(struct wl_client *client,
1300                                struct wl_resource *shell_res,
1301                                const char *app_id, uint32_t role,
1302                                int x, int y, int bx, int by,
1303                                int width, int height,
1304                                struct wl_resource *output_res)
1305 {
1306         struct weston_head *head = weston_head_from_resource(output_res);
1307         struct weston_output *woutput = weston_head_get_output(head);
1308         struct ivi_output *output = to_ivi_output(woutput);
1309
1310         switch (role) {
1311         case AGL_SHELL_DESKTOP_APP_ROLE_POPUP:
1312                 ivi_set_pending_desktop_surface_popup(output, x, y, bx, by,
1313                                                       width, height, app_id);
1314                 break;
1315         case AGL_SHELL_DESKTOP_APP_ROLE_FULLSCREEN:
1316                 ivi_set_pending_desktop_surface_fullscreen(output, app_id);
1317                 break;
1318         case AGL_SHELL_DESKTOP_APP_ROLE_SPLIT_VERTICAL:
1319         case AGL_SHELL_DESKTOP_APP_ROLE_SPLIT_HORIZONTAL:
1320                 ivi_set_pending_desktop_surface_split(output, app_id, role);
1321                 break;
1322         case AGL_SHELL_DESKTOP_APP_ROLE_REMOTE:
1323                 ivi_set_pending_desktop_surface_remote(output, app_id);
1324                 break;
1325         default:
1326                 break;
1327         }
1328 }
1329
1330 void
1331 ivi_compositor_destroy_pending_surfaces(struct ivi_compositor *ivi)
1332 {
1333         struct pending_popup *p_popup, *next_p_popup;
1334         struct pending_split *split_surf, *next_split_surf;
1335         struct pending_fullscreen *fs_surf, *next_fs_surf;
1336         struct pending_remote *remote_surf, *next_remote_surf;
1337
1338         wl_list_for_each_safe(p_popup, next_p_popup,
1339                               &ivi->popup_pending_apps, link)
1340                 ivi_remove_pending_desktop_surface_popup(p_popup);
1341
1342         wl_list_for_each_safe(split_surf, next_split_surf,
1343                               &ivi->split_pending_apps, link)
1344                 ivi_remove_pending_desktop_surface_split(split_surf);
1345
1346         wl_list_for_each_safe(fs_surf, next_fs_surf,
1347                               &ivi->fullscreen_pending_apps, link)
1348                 ivi_remove_pending_desktop_surface_fullscreen(fs_surf);
1349
1350         wl_list_for_each_safe(remote_surf, next_remote_surf,
1351                               &ivi->remote_pending_apps, link)
1352                 ivi_remove_pending_desktop_surface_remote(remote_surf);
1353 }
1354
1355 static void
1356 shell_desktop_set_app_property_mode(struct wl_client *client,
1357                                     struct wl_resource *shell_res, uint32_t perm)
1358 {
1359         struct desktop_client *dclient = wl_resource_get_user_data(shell_res);
1360         if (perm) {
1361                 dclient->ivi->keep_pending_surfaces = true;
1362         } else {
1363                 dclient->ivi->keep_pending_surfaces = false;
1364                 /* remove any previous pending surfaces */
1365                 ivi_compositor_destroy_pending_surfaces(dclient->ivi);
1366         }
1367 }
1368
1369 static const struct agl_shell_desktop_interface agl_shell_desktop_implementation = {
1370         .activate_app = shell_desktop_activate_app,
1371         .set_app_property = shell_desktop_set_app_property,
1372         .deactivate_app = shell_deactivate_app,
1373         .set_app_property_mode = shell_desktop_set_app_property_mode,
1374 };
1375
1376 static void
1377 unbind_agl_shell(struct wl_resource *resource)
1378 {
1379         struct ivi_compositor *ivi;
1380         struct ivi_output *output;
1381         struct ivi_surface *surf, *surf_tmp;
1382
1383         ivi = wl_resource_get_user_data(resource);
1384
1385         /* reset status to allow other clients issue legit requests */
1386         if (ivi->shell_client.resource &&
1387             ivi->shell_client.status == BOUND_FAILED) {
1388                 ivi->shell_client.status = BOUND_OK;
1389                 return;
1390         }
1391
1392         wl_list_for_each(output, &ivi->outputs, link) {
1393                 /* reset the active surf if there's one present */
1394                 if (output->active) {
1395                         output->active->view->is_mapped = false;
1396                         output->active->view->surface->is_mapped = false;
1397
1398                         weston_layer_entry_remove(&output->active->view->layer_link);
1399                         output->active = NULL;
1400                 }
1401
1402                 insert_black_surface(output);
1403         }
1404
1405         wl_list_for_each_safe(surf, surf_tmp, &ivi->surfaces, link) {
1406                 wl_list_remove(&surf->link);
1407                 wl_list_init(&surf->link);
1408         }
1409
1410         wl_list_for_each_safe(surf, surf_tmp, &ivi->pending_surfaces, link) {
1411                 wl_list_remove(&surf->link);
1412                 wl_list_init(&surf->link);
1413         }
1414
1415         wl_list_init(&ivi->surfaces);
1416         wl_list_init(&ivi->pending_surfaces);
1417
1418         ivi->shell_client.ready = false;
1419         ivi->shell_client.resource = NULL;
1420         ivi->shell_client.client = NULL;
1421 }
1422
1423 static void
1424 bind_agl_shell(struct wl_client *client,
1425                void *data, uint32_t version, uint32_t id)
1426 {
1427         struct ivi_compositor *ivi = data;
1428         struct wl_resource *resource;
1429         struct ivi_policy *policy;
1430         void *interface;
1431
1432         policy = ivi->policy;
1433         interface = (void *) &agl_shell_interface;
1434         if (policy && policy->api.shell_bind_interface &&
1435             !policy->api.shell_bind_interface(client, interface)) {
1436                 wl_client_post_implementation_error(client,
1437                                        "client not authorized to use agl_shell");
1438                 return;
1439         }
1440
1441         resource = wl_resource_create(client, &agl_shell_interface, version, id);
1442         if (!resource) {
1443                 wl_client_post_no_memory(client);
1444                 return;
1445         }
1446
1447         if (ivi->shell_client.resource) {
1448                 if (wl_resource_get_version(resource) == 1) {
1449                         wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
1450                                                "agl_shell has already been bound");
1451                         return;
1452                 }
1453
1454                 agl_shell_send_bound_fail(resource);
1455                 ivi->shell_client.status = BOUND_FAILED;
1456         }
1457
1458         wl_resource_set_implementation(resource, &agl_shell_implementation,
1459                                        ivi, unbind_agl_shell);
1460         ivi->shell_client.resource = resource;
1461
1462         if (ivi->shell_client.status == BOUND_OK &&
1463             wl_resource_get_version(resource) >= AGL_SHELL_BOUND_OK_SINCE_VERSION)
1464                 agl_shell_send_bound_ok(ivi->shell_client.resource);
1465 }
1466
1467 static void
1468 unbind_agl_shell_desktop(struct wl_resource *resource)
1469 {
1470         struct desktop_client *dclient = wl_resource_get_user_data(resource);
1471
1472         wl_list_remove(&dclient->link);
1473         free(dclient);
1474 }
1475
1476 static void
1477 bind_agl_shell_desktop(struct wl_client *client,
1478                        void *data, uint32_t version, uint32_t id)
1479 {
1480         struct ivi_compositor *ivi = data;
1481         struct wl_resource *resource;
1482         struct ivi_policy *policy;
1483         struct desktop_client *dclient;
1484         void *interface;
1485
1486         policy = ivi->policy;
1487         interface  = (void *) &agl_shell_desktop_interface;
1488         if (policy && policy->api.shell_bind_interface &&
1489             !policy->api.shell_bind_interface(client, interface)) {
1490                 wl_client_post_implementation_error(client,
1491                                 "client not authorized to use agl_shell_desktop");
1492                 return;
1493         }
1494
1495         dclient = zalloc(sizeof(*dclient));
1496         if (!dclient) {
1497                 wl_client_post_no_memory(client);
1498                 return;
1499         }
1500
1501         resource = wl_resource_create(client, &agl_shell_desktop_interface,
1502                                       version, id);
1503         dclient->ivi = ivi;
1504         if (!resource) {
1505                 wl_client_post_no_memory(client);
1506                 return;
1507         }
1508
1509         wl_resource_set_implementation(resource, &agl_shell_desktop_implementation,
1510                                        dclient, unbind_agl_shell_desktop);
1511
1512         dclient->resource = resource;
1513         wl_list_insert(&ivi->desktop_clients, &dclient->link);
1514
1515         /* advertise xdg surfaces */
1516         ivi_shell_advertise_xdg_surfaces(ivi, resource);
1517 }
1518
1519 int
1520 ivi_shell_create_global(struct ivi_compositor *ivi)
1521 {
1522         ivi->agl_shell = wl_global_create(ivi->compositor->wl_display,
1523                                           &agl_shell_interface, 2,
1524                                           ivi, bind_agl_shell);
1525         if (!ivi->agl_shell) {
1526                 weston_log("Failed to create wayland global.\n");
1527                 return -1;
1528         }
1529
1530         ivi->agl_shell_desktop = wl_global_create(ivi->compositor->wl_display,
1531                                                   &agl_shell_desktop_interface, 2,
1532                                                   ivi, bind_agl_shell_desktop);
1533         if (!ivi->agl_shell_desktop) {
1534                 weston_log("Failed to create wayland global (agl_shell_desktop).\n");
1535                 return -1;
1536         }
1537
1538         return 0;
1539 }