libhomescreen/src/libhomescreen.cpp

   1 extern "C" {
   2 #include "homescreen.h" // generated from xml
   3 }
   4 #include "include/libhomescreen.hpp"
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8
   9 LibHomeScreen::LibHomeScreen()
  10 {
  11     GError *err = NULL;
  12
  13     mp_libHomeScreenHomescreen_Proxy = lib_home_screen_homescreen_proxy_new_for_bus_sync(
  14                 G_BUS_TYPE_SESSION,
  15                 G_DBUS_PROXY_FLAGS_NONE,
  16                 "org.agl.homescreen",
  17                 "/HomeScreen",
  18                 NULL,
  19                 &err);
  20
  21     if (NULL != err)
  22     {
  23         fprintf(stderr, "Unable to create proxy: %s\n", err->message);
  24     }
  25 }
  26
  27 LibHomeScreen::~LibHomeScreen()
  28 {
  29     g_object_unref(mp_libHomeScreenHomescreen_Proxy);
  30 }
  31
  32 std::list<int> LibHomeScreen::getAllSurfacesOfProcess(int pid)
  33 {
  34     std::list<int> result;
  35
  36     GError *err = NULL;
  37
  38     GVariant *out_surfaceIds;
  39
  40     lib_home_screen_homescreen_call_get_all_surfaces_of_process_sync(
  41                 mp_libHomeScreenHomescreen_Proxy,
  42                 pid,
  43                 &out_surfaceIds,
  44                 NULL,
  45                 &err);
  46
  47     if (NULL != err)
  48     {
  49         fprintf(stderr, "Unable to call getAllSurfacesOfProcess: %s\n", err->message);
  50     }
  51
  52
  53     GVariant *element;
  54     GVariantIter iter;
  55     int i;
  56
  57     if (g_variant_iter_init(&iter, out_surfaceIds))
  58     {
  59         while ((element = g_variant_iter_next_value(&iter)) != NULL)
  60         {
  61             g_variant_get(element, "i", &i);
  62             result.push_back(i);
  63             g_variant_unref(element);
  64         }
  65     }
  66
  67     return result;
  68 }
  69
  70 sRectangle LibHomeScreen::getLayoutRenderAreaForSurfaceId(int surfaceId)
  71 {
  72     sRectangle result;
  73     GError *err = NULL;
  74
  75     GVariant *out_renderArea;
  76
  77     lib_home_screen_homescreen_call_get_layout_render_area_for_surface_id_sync(
  78                 mp_libHomeScreenHomescreen_Proxy,
  79                 surfaceId,
  80                 &out_renderArea,
  81                 NULL,
  82                 &err);
  83
  84     if (NULL != err)
  85     {
  86         fprintf(stderr, "Unable to call getLayoutRenderAreaForSurfaceId: %s\n", err->message);
  87     }
  88
  89     g_variant_get(out_renderArea, "(iiii)", result.x, result.y, result.width, result.height);
  90
  91     return result;
  92 }
  93
  94 int LibHomeScreen::getSurfaceStatus(int surfaceId)
  95 {
  96     int result;
  97     GError *err = NULL;
  98
  99     GVariant *out_renderArea;
 100
 101     lib_home_screen_homescreen_call_get_surface_status_sync(
 102                 mp_libHomeScreenHomescreen_Proxy,
 103                 surfaceId,
 104                 &result,
 105                 NULL,
 106                 &err);
 107
 108     if (NULL != err)
 109     {
 110         fprintf(stderr, "Unable to call getSurfaceStatus: %s\n", err->message);
 111     }
 112
 113     return result;
 114 }
 115
 116 void LibHomeScreen::hardKeyPressed(int key)
 117 {
 118     GError *err = NULL;
 119
 120     lib_home_screen_homescreen_call_hard_key_pressed_sync(
 121                 mp_libHomeScreenHomescreen_Proxy,
 122                 key,
 123                 NULL,
 124                 &err);
 125
 126     if (NULL != err)
 127     {
 128         fprintf(stderr, "Unable to call hardKeyPressed: %s\n", err->message);
 129     }
 130 }
 131
 132 void LibHomeScreen::renderSurfaceToArea(int surfaceId, const sRectangle &renderArea)
 133 {
 134     GError *err = NULL;
 135
 136     GVariant *variant;
 137     GVariantBuilder *builder;
 138     builder = g_variant_builder_new(G_VARIANT_TYPE("(iiii)"));
 139     g_variant_builder_add(builder, "(iiii)", renderArea.x, renderArea.y, renderArea.width, renderArea.height);
 140     variant = g_variant_new("(iiii)", builder);
 141     g_variant_builder_unref(builder);
 142
 143     lib_home_screen_homescreen_call_render_surface_to_area_sync(
 144                 mp_libHomeScreenHomescreen_Proxy,
 145                 surfaceId,
 146                 variant,
 147                 NULL,
 148                 &err);
 149
 150     if (NULL != err)
 151     {
 152         fprintf(stderr, "Unable to call renderSurfaceToArea: %s\n", err->message);
 153     }
 154 }
 155
 156 void LibHomeScreen::requestSurfaceIdToFullScreen(int surfaceId)
 157 {
 158     GError *err = NULL;
 159
 160     lib_home_screen_homescreen_call_request_surface_id_to_full_screen_sync(
 161                 mp_libHomeScreenHomescreen_Proxy,
 162                 surfaceId,
 163                 NULL,
 164                 &err);
 165
 166     if (NULL != err)
 167     {
 168         fprintf(stderr, "Unable to call requestSurfaceIdToFullScreen: %s\n", err->message);
 169     }
 170 }