+

#include <mutex>
+#include <chrono>
+#include <iostream>
+#include <string>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <thread>
+#include <exception>
+#include <vector>
+#include <sstream>
+#include <assert.h>
+#include <signal.h>
+#include <wayland-client.h>
+#include <wayland-egl.h>
+#include <GLES2/gl2.h>
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <unistd.h>
+#include <time.h>
+#include <libwindowmanager.h>
+#include <libhomescreen.hpp>
+#include <ilm/ivi-application-client-protocol.h>
+#include "hmi-debug.h"
+#include "platform.h"
+

+

+ + + + + + + + +

+Classes
struct	display

struct	geometry

struct	window

+ + + + + + + +

+Macros
#define	EGL_EXT_swap_buffers_with_damage 1

#define	EGL_EXT_buffer_age 1

#define	EGL_BUFFER_AGE_EXT 0x313D

+ + + + + + + +

+Typedefs
typedef EGLSurface	surface

typedef EGLSurface EGLint *	rects

typedef EGLSurface EGLint EGLint	n_rects

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Functions
typedef	EGLBoolean (EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)(EGLDisplay dpy

static void	init_egl (struct display display, struct window window)

static void	fini_egl (struct display *display)

static GLuint	create_shader (struct window window, const char source, GLenum shader_type)

static void	init_gl (struct window *window)

static void	create_ivi_surface (struct window window, struct display display)

static void	create_surface (struct window *window)

static void	destroy_surface (struct window *window)

static void	redraw (void data, struct wl_callback callback, uint32_t time)

static void	registry_handle_global (void data, struct wl_registry registry, uint32_t name, const char *interface, uint32_t version)

static void	registry_handle_global_remove (void data, struct wl_registry registry, uint32_t name)

static void	signal_int (int signum)

int	init_wm (LibWindowmanager wm, struct window window)

int	init_hs (LibHomeScreen *hs)

int	main (int argc, char **argv)

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Variables
const char *	log_prefix = "simple-egl"

uint32_t	g_id_ivisurf = 9009

long	port = 1700

string	token = string("wm")

string	app_name = string("Navigation")

const char *	main_role = "navigation"

LibHomeScreen *	hs

LibWindowmanager *	wm

static const struct wl_interface *	types []

static const struct wl_message	ivi_surface_requests []

static const struct wl_message	ivi_surface_events []

const struct wl_interface	ivi_surface_interface

static const struct wl_message	ivi_application_requests []

const struct wl_interface	ivi_application_interface

static const char *	vert_shader_text

static const char *	frag_shader_text

static int	running = 1

static const struct wl_registry_listener	registry_listener

+

Macro Definition Documentation

+ +

+

+ + + + +

#define EGL_BUFFER_AGE_EXT 0x313D

+

+ +

Definition at line 110 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

#define EGL_EXT_buffer_age 1

+

+ +

Definition at line 109 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

#define EGL_EXT_swap_buffers_with_damage 1

+

+ +

Definition at line 104 of file simple-egl.cpp.

+ +

+

Typedef Documentation

+ +

+

+ + + + +

typedef EGLSurface EGLint EGLint n_rects

+

+ +

Definition at line 105 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

typedef EGLSurface EGLint* rects

+

+ +

Definition at line 105 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

typedef EGLSurface surface

+

+ +

Definition at line 105 of file simple-egl.cpp.

+ +

+

Function Documentation

+ +

+

+ + + + + +

+ + + + + + + + + + + + + + + + + + +

static void create_ivi_surface	(	struct window *	window,
		struct display *	display
	)

+

+static

+

+ +

Definition at line 322 of file simple-egl.cpp.

+

 {
     uint32_t id_ivisurf = g_id_ivisurf;
     window->ivi_surface =
         ivi_application_surface_create(display->ivi_application,
                            id_ivisurf, window->surface);
 
     if (window->ivi_surface == NULL) {
         HMI_ERROR(log_prefix,"Failed to create ivi_client_surface");
         abort();
     }
 
 }

+
+
+
+
+
+

+

+ +

+

+ + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + +

static GLuint create_shader	(	struct window *	window,
		const char *	source,
		GLenum	shader_type
	)

+

+static

+

+ +

Definition at line 259 of file simple-egl.cpp.

+

 {
     GLuint shader;
     GLint status;
 
     shader = glCreateShader(shader_type);
     assert(shader != 0);
 
     glShaderSource(shader, 1, (const char **) &source, NULL);
     glCompileShader(shader);
 
     glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
     if (!status) {
         char log[1000];
         GLsizei len;
         glGetShaderInfoLog(shader, 1000, &len, log);
         HMI_ERROR(log_prefix,"Error: compiling %s: %*s",
             shader_type == GL_VERTEX_SHADER ? "vertex" : "fragment",
             len, log);
         exit(1);
     }
 
     return shader;
 }

+
+

+

+ +

+

+ + + + + +

+ + + + + + + + +

static void create_surface ( struct window * window )

+

+static

+

+ +

Definition at line 337 of file simple-egl.cpp.

+

 {
     struct display *display = window->display;
     EGLBoolean ret;
 
     window->surface = wl_compositor_create_surface(display->compositor);
 
     window->native =
         wl_egl_window_create(window->surface,
                      window->geometry.width,
                      window->geometry.height);
     window->egl_surface =
         weston_platform_create_egl_surface(display->egl.dpy,
                            display->egl.conf,
                            window->native, NULL);
 
 
     if (display->ivi_application ) {
         create_ivi_surface(window, display);
     } else {
         assert(0);
     }
 
     ret = eglMakeCurrent(window->display->egl.dpy, window->egl_surface,
                  window->egl_surface, window->display->egl.ctx);
     assert(ret == EGL_TRUE);
 
     if (!window->frame_sync)
         eglSwapInterval(display->egl.dpy, 0);
 
 }

+
+
+
+
+
+
+
+
+
+
+
+
+
+

+

+ +

+

+ + + + + +

+ + + + + + + + +

static void destroy_surface ( struct window * window )

+

+static

+

+ +

Definition at line 370 of file simple-egl.cpp.

+

 {
     /* Required, otherwise segfault in egl_dri2.c: dri2_make_current()
      * on eglReleaseThread(). */
     eglMakeCurrent(window->display->egl.dpy, EGL_NO_SURFACE, EGL_NO_SURFACE,
                EGL_NO_CONTEXT);
 
     eglDestroySurface(window->display->egl.dpy, window->egl_surface);
     wl_egl_window_destroy(window->native);
 
     if (window->display->ivi_application)
         ivi_surface_destroy(window->ivi_surface);
     wl_surface_destroy(window->surface);
 
     if (window->callback)
         wl_callback_destroy(window->callback);
 }

+
+
+
+
+
+
+
+
+

+

+ +

+

+ + + + + + + + +

typedef EGLBoolean ( EGLAPIENTRYP PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC )

+

+ +

+

+ +

+

+ + + + + +

+ + + + + + + + +

static void fini_egl ( struct display * display )

+

+static

+

+ +

Definition at line 252 of file simple-egl.cpp.

+

 {
     eglTerminate(display->egl.dpy);
     eglReleaseThread();
 }

+
+

+

+ +

+

+ + + + + +

+ + + + + + + + + + + + + + + + + + +

static void init_egl	(	struct display *	display,
		struct window *	window
	)

+

+static

+

+ +

Definition at line 174 of file simple-egl.cpp.

+

 {
     static const EGLint context_attribs[] = {
         EGL_CONTEXT_CLIENT_VERSION, 2,
         EGL_NONE
     };
     const char *extensions;
 
     EGLint config_attribs[] = {
         EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
         EGL_RED_SIZE, 1,
         EGL_GREEN_SIZE, 1,
         EGL_BLUE_SIZE, 1,
         EGL_ALPHA_SIZE, 1,
         EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
         EGL_NONE
     };
 
     EGLint major, minor, n, count, i, size;
     EGLConfig *configs;
     EGLBoolean ret;
 
     if (window->opaque || window->buffer_size == 16)
         config_attribs[9] = 0;
 
     display->egl.dpy = weston_platform_get_egl_display(EGL_PLATFORM_WAYLAND_KHR, display->display, NULL);
     assert(display->egl.dpy);
 
     ret = eglInitialize(display->egl.dpy, &major, &minor);
     assert(ret == EGL_TRUE);
     ret = eglBindAPI(EGL_OPENGL_ES_API);
     assert(ret == EGL_TRUE);
 
     if (!eglGetConfigs(display->egl.dpy, NULL, 0, &count) || count < 1)
         assert(0);
 
     configs = calloc(count, sizeof *configs);
     assert(configs);
 
     ret = eglChooseConfig(display->egl.dpy, config_attribs,
                   configs, count, &n);
     assert(ret && n >= 1);
 
     for (i = 0; i < n; i++) {
         eglGetConfigAttrib(display->egl.dpy,
                    configs[i], EGL_BUFFER_SIZE, &size);
         if (window->buffer_size == size) {
             display->egl.conf = configs[i];
             break;
         }
     }
     free(configs);
     if (display->egl.conf == NULL) {
         HMI_ERROR(log_prefix,"did not find config with buffer size %d",
             window->buffer_size);
         exit(EXIT_FAILURE);
     }
 
     display->egl.ctx = eglCreateContext(display->egl.dpy,
                         display->egl.conf,
                         EGL_NO_CONTEXT, context_attribs);
     assert(display->egl.ctx);
 
     display->swap_buffers_with_damage = NULL;
     extensions = eglQueryString(display->egl.dpy, EGL_EXTENSIONS);
     if (extensions &&
         strstr(extensions, "EGL_EXT_swap_buffers_with_damage") &&
         strstr(extensions, "EGL_EXT_buffer_age"))
         display->swap_buffers_with_damage =
             (PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC)
             eglGetProcAddress("eglSwapBuffersWithDamageEXT");
 
     if (display->swap_buffers_with_damage)
         HMI_DEBUG(log_prefix,"has EGL_EXT_buffer_age and EGL_EXT_swap_buffers_with_damage");
 
 }

+
+
+
+
+
+
+
+
+
+
+
+

+

+ +

+

+ + + + + +

+ + + + + + + + +

static void init_gl ( struct window * window )

+

+static

+

+ +

Definition at line 285 of file simple-egl.cpp.

+

 {
     GLuint frag, vert;
     GLuint program;
     GLint status;
 
     frag = create_shader(window, frag_shader_text, GL_FRAGMENT_SHADER);
     vert = create_shader(window, vert_shader_text, GL_VERTEX_SHADER);
 
     program = glCreateProgram();
     glAttachShader(program, frag);
     glAttachShader(program, vert);
     glLinkProgram(program);
 
     glGetProgramiv(program, GL_LINK_STATUS, &status);
     if (!status) {
         char log[1000];
         GLsizei len;
         glGetProgramInfoLog(program, 1000, &len, log);
         HMI_ERROR(log_prefix,"Error: linking:%*s", len, log);
         exit(1);
     }
 
     glUseProgram(program);
 
     window->gl.pos = 0;
     window->gl.col = 1;
 
     glBindAttribLocation(program, window->gl.pos, "pos");
     glBindAttribLocation(program, window->gl.col, "color");
     glLinkProgram(program);
 
     window->gl.rotation_uniform =
         glGetUniformLocation(program, "rotation");
 }

+
+
+
+
+
+
+
+
+

+

+ +

+

+ + + + + + + + +

int init_hs ( LibHomeScreen * hs )

+

+ +

Definition at line 565 of file simple-egl.cpp.

+

                           {
     if(hs->init(port, token)!=0)
     {
         HMI_ERROR(log_prefix,"homescreen init failed. ");
         return -1;
     }
 
     hs->set_event_handler(LibHomeScreen::Event_ShowWindow, [hs](json_object *object){
         HMI_DEBUG("simple-egl","try to activeWindow %s ", app_name.c_str());
 
         struct json_object *param_obj = json_object_object_get(object, hs->_keyParameter);
         const char *area = json_object_get_string(
             json_object_object_get(param_obj, hs->_keyArea));
         // Application should call LibWindowmanager::activateWindow() in showWindow handler
         if(area == nullptr)
             wm->activateWindow(main_role, hs->_areaNormal);
         else
             wm->activateWindow(main_role, area);
     });
 
     return 0;
 }

+
+
+
+
+
+
+
+
+
+
+
+
+
+

+

+ +

+

+ + + + + + + + + + + + + + + + + + +

int init_wm	(	LibWindowmanager *	wm,
		struct window *	window
	)

+

+ +

Definition at line 527 of file simple-egl.cpp.

+

 {
     HMI_DEBUG(log_prefix,"called");
 
     if (wm->init(port, token) != 0) {
         HMI_ERROR(log_prefix,"wm init failed. ");
         return -1;
     }
 
     g_id_ivisurf = wm->requestSurface(main_role);
     if (g_id_ivisurf < 0) {
         HMI_ERROR(log_prefix,"wm request surface failed ");
         return -1;
     }
     HMI_DEBUG(log_prefix,"IVI_SURFACE_ID: %d ", g_id_ivisurf);
 
     WMHandler wmh;
     wmh.on_visible = [](const char* role, bool visible){
         // Sample code if user uses visible event
         HMI_DEBUG(log_prefix, "role: %s, visible: %s", role, visible ? "true" : "false");
     };
     wmh.on_sync_draw = [wm, window](const char* role, const char* area, Rect rect) {
 
         HMI_DEBUG(log_prefix,"Surface %s got syncDraw! Area: %s. w:%d, h:%d", role, area, rect.width(), rect.height());
 
         wl_egl_window_resize(window->native, rect.width(), rect.height(), 0, 0);
         window->geometry.width  = rect.width();
         window->geometry.height = rect.height();
 
         wm->endDraw(role);
     };
 
     wm->setEventHandler(wmh);
 
     return 0;
 }

+
+
+
+
+
+
+
+
+

+

+ +

+

+ + + + + + + + + + + + + + + + + + +

int main	(	int	argc,
		char **	argv
	)

+

+ +

Definition at line 589 of file simple-egl.cpp.

+

 {
     struct sigaction sigint;
     struct window  window  = { 0 };
     struct display display = { 0 };
 
     window.display = &display;
     display.window = &window;
     window.geometry.width  = 1080;
     window.geometry.height = 1488;
     window.window_size = window.geometry;
     window.buffer_size = 32;
     window.frame_sync = 1;
 
     if(argc > 2){
         port = strtol(argv[1], NULL, 10);
         token = argv[2];
     }
 
     HMI_DEBUG(log_prefix,"main_role: %s, port: %d, token: %s. ", main_role, port, token.c_str());
 
     display.display = wl_display_connect(NULL);
     assert(display.display);
 
     display.registry = wl_display_get_registry(display.display);
     wl_registry_add_listener(display.registry,
                  &registry_listener, &display);
 
     wl_display_roundtrip(display.display);
 
     init_egl(&display, &window);
 
     wm = new LibWindowmanager();
     if(init_wm(wm, &window)!=0){
         fini_egl(&display);
         if (display.ivi_application)
             ivi_application_destroy(display.ivi_application);
         if (display.compositor)
             wl_compositor_destroy(display.compositor);
         wl_registry_destroy(display.registry);
         wl_display_flush(display.display);
         return -1;
     }
 
     hs = new LibHomeScreen();
     if(init_hs(hs)!=0){
         fini_egl(&display);
         if (display.ivi_application)
             ivi_application_destroy(display.ivi_application);
         if (display.compositor)
             wl_compositor_destroy(display.compositor);
         wl_registry_destroy(display.registry);
         wl_display_flush(display.display);
         return -1;
     }
 
     create_surface(&window);
     init_gl(&window);
 
     //Ctrl+C
     sigint.sa_handler = signal_int;
     sigemptyset(&sigint.sa_mask);
     sigint.sa_flags = SA_RESETHAND;
     sigaction(SIGINT, &sigint, NULL);
 
     eglSwapBuffers(window.display->egl.dpy, window.egl_surface);
 
     wm->activateWindow(main_role);
 
     /* The mainloop here is a little subtle.  Redrawing will cause
      * EGL to read events so we can just call
      * wl_display_dispatch_pending() to handle any events that got
      * queued up as a side effect. */
     while (running) {
         wl_display_dispatch_pending(display.display);
         redraw(&window, NULL, 0);
     }
 
     HMI_DEBUG(log_prefix,"simple-egl exiting! ");
 
     destroy_surface(&window);
     fini_egl(&display);
 
     if (display.ivi_application)
         ivi_application_destroy(display.ivi_application);
 
     if (display.compositor)
         wl_compositor_destroy(display.compositor);
 
     wl_registry_destroy(display.registry);
     wl_display_flush(display.display);
     wl_display_disconnect(display.display);
 
     return 0;
 }

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+

+ +

+

+ + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + +

static void redraw	(	void *	data,
		struct wl_callback *	callback,
		uint32_t	time
	)

+

+static

+

+ +

Definition at line 389 of file simple-egl.cpp.

+

 {
     struct window *window = data;
     struct display *display = window->display;
     static const GLfloat verts[3][2] = {
         { -0.5, -0.5 },
         {  0.5, -0.5 },
         {  0,    0.5 }
     };
 
     static const GLfloat colors[3][3] = {
         { 1, 0, 0 },
         { 0, 1, 0 },
         { 0, 0, 1 }
     };
 
     GLfloat angle;
     GLfloat rotation[4][4] = {
         { 1, 0, 0, 0 },
         { 0, 1, 0, 0 },
         { 0, 0, 1, 0 },
         { 0, 0, 0, 1 }
     };
     static const uint32_t speed_div = 5, benchmark_interval = 5;
     struct wl_region *region;
     EGLint rect[4];
     EGLint buffer_age = 0;
     struct timeval tv;
 
     assert(window->callback == callback);
     window->callback = NULL;
 
     if (callback)
         wl_callback_destroy(callback);
 
     gettimeofday(&tv, NULL);
     time = tv.tv_sec * 1000 + tv.tv_usec / 1000;
     if (window->frames == 0)
         window->benchmark_time = time;
 
     if (time - window->benchmark_time > (benchmark_interval * 1000)) {
         HMI_DEBUG(log_prefix,"%d frames in %d seconds: %f fps",
                window->frames,
                benchmark_interval,
                (float) window->frames / benchmark_interval);
         window->benchmark_time = time;
         window->frames = 0;
     }
 
     angle = (time / speed_div) % 360 * M_PI / 180.0;
     rotation[0][0] =  cos(angle);
     rotation[0][2] =  sin(angle);
     rotation[2][0] = -sin(angle);
     rotation[2][2] =  cos(angle);
 
     if (display->swap_buffers_with_damage)
         eglQuerySurface(display->egl.dpy, window->egl_surface,
                 EGL_BUFFER_AGE_EXT, &buffer_age);
 
     glViewport(0, 0, window->geometry.width, window->geometry.height);
 
     glUniformMatrix4fv(window->gl.rotation_uniform, 1, GL_FALSE,
                (GLfloat *) rotation);
 
     glClearColor(0.0, 0.0, 0.0, 0.5);
     glClear(GL_COLOR_BUFFER_BIT);
 
     glVertexAttribPointer(window->gl.pos, 2, GL_FLOAT, GL_FALSE, 0, verts);
     glVertexAttribPointer(window->gl.col, 3, GL_FLOAT, GL_FALSE, 0, colors);
     glEnableVertexAttribArray(window->gl.pos);
     glEnableVertexAttribArray(window->gl.col);
 
     glDrawArrays(GL_TRIANGLES, 0, 3);
 
     glDisableVertexAttribArray(window->gl.pos);
     glDisableVertexAttribArray(window->gl.col);
 
     if (window->opaque || window->fullscreen) {
         region = wl_compositor_create_region(window->display->compositor);
         wl_region_add(region, 0, 0,
                   window->geometry.width,
                   window->geometry.height);
         wl_surface_set_opaque_region(window->surface, region);
         wl_region_destroy(region);
     } else {
         wl_surface_set_opaque_region(window->surface, NULL);
     }
 
     if (display->swap_buffers_with_damage && buffer_age > 0) {
         rect[0] = window->geometry.width / 4 - 1;
         rect[1] = window->geometry.height / 4 - 1;
         rect[2] = window->geometry.width / 2 + 2;
         rect[3] = window->geometry.height / 2 + 2;
         display->swap_buffers_with_damage(display->egl.dpy,
                           window->egl_surface,
                           rect, 1);
     } else {
         eglSwapBuffers(display->egl.dpy, window->egl_surface);
     }
 
     window->frames++;
 }

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+

+ +

+

+ + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

static void registry_handle_global	(	void *	data,
		struct wl_registry *	registry,
		uint32_t	name,
		const char *	interface,
		uint32_t	version
	)

+

+static

+

+ +

Definition at line 493 of file simple-egl.cpp.

+

 {
     struct display *d = data;
 
     if (strcmp(interface, "wl_compositor") == 0) {
         d->compositor =
             wl_registry_bind(registry, name,
                      &wl_compositor_interface, 1);
     } else if (strcmp(interface, "ivi_application") == 0) {
         d->ivi_application =
             wl_registry_bind(registry, name,
                      &ivi_application_interface, 1);
     }
 }

+
+
+
+
+

+

+ +

+

+ + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + +

static void registry_handle_global_remove	(	void *	data,
		struct wl_registry *	registry,
		uint32_t	name
	)

+

+static

+

+ +

Definition at line 510 of file simple-egl.cpp.

+

512 {

513 }

+

+ +

+

+ + + + + +

+ + + + + + + + +

static void signal_int ( int signum )

+

+static

+

+ +

Definition at line 521 of file simple-egl.cpp.

+

 {
     running = 0;
 }

+

+

Variable Documentation

+ +

+

+ + + + +

string app_name = string("Navigation")

+

+ +

Definition at line 63 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + + +

+ + + + +

const char* frag_shader_text

+

+static

+

+Initial value:

=
    "precision mediump float;\n"
    "varying vec4 v_color;\n"
    "void main() {\n"
    "  gl_FragColor = v_color;\n"
    "}\n"

+

Definition at line 164 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

uint32_t g_id_ivisurf = 9009

+

+ +

Definition at line 59 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

LibHomeScreen* hs

+

+ +

Definition at line 66 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

const struct wl_interface ivi_application_interface

+

+Initial value:

= {
    "ivi_application", 1,
    1, ivi_application_requests,
    0, NULL,
}

+

+

Definition at line 95 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + + +

+ + + + +

const struct wl_message ivi_application_requests[]

+

+static

+

+Initial value:

= {
        { "surface_create", "uon", types + 2 },
}

+

+

Definition at line 91 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + + +

+ + + + +

const struct wl_message ivi_surface_events[]

+

+static

+

+Initial value:

= {
        { "configure", "ii", types + 0 },
}

+

+

Definition at line 81 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

const struct wl_interface ivi_surface_interface

+

+Initial value:

= {
        "ivi_surface", 1,
        1, ivi_surface_requests,
        1, ivi_surface_events,
}

+
+

+

Definition at line 85 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + + +

+ + + + +

const struct wl_message ivi_surface_requests[]

+

+static

+

+Initial value:

= {
        { "destroy", "", types + 0 },
}

+

+

Definition at line 77 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

const char* log_prefix = "simple-egl"

+

+ +

Definition at line 58 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

const char* main_role = "navigation"

+

+ +

Definition at line 64 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

long port = 1700

+

+ +

Definition at line 60 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + + +

+ + + + +

const struct wl_registry_listener registry_listener

+

+static

+

+Initial value:

= {
    registry_handle_global,
    registry_handle_global_remove
}

+
+

+

Definition at line 515 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + + +

+ + + + +

int running = 1

+

+static

+

+ +

Definition at line 171 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

string token = string("wm")

+

+ +

Definition at line 61 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + + +

+ + + + +

const struct wl_interface* types[]

+

+static

+

+Initial value:

= {
        NULL,
        NULL,
        NULL,
        &wl_surface_interface,
        &ivi_surface_interface,
}

+

+

Definition at line 69 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + + +

+ + + + +

const char* vert_shader_text

+

+static

+

+Initial value:

=
    "uniform mat4 rotation;\n"
    "attribute vec4 pos;\n"
    "attribute vec4 color;\n"
    "varying vec4 v_color;\n"
    "void main() {\n"
    "  gl_Position = rotation * pos;\n"
    "  v_color = color;\n"
    "}\n"

+

Definition at line 154 of file simple-egl.cpp.

+ +

+

+ +

+

+ + + + +

LibWindowmanager* wm

+

+ +

Definition at line 67 of file simple-egl.cpp.

+ +

+

+Classes
struct	HS_ClientCtxt

class	HS_ClientManager

Public Types
enum	EventType { Event_TapShortcut = 1, +
enum	EventType { + Event_ShowWindow = 1, +Event_TapShortcut = 1, Event_OnScreenMessage, -Event_OnScreenReply +Event_OnScreenReply, + + Event_HideWindow, +Event_ReplyShowWindow, +Event_ShowNotification, +Event_ShowInformation + }

using	handler_func = std::function< void(json_object *)>

LibHomeScreen &	operator= (const LibHomeScreen &)=delete

int	init (const int port, const std::string &token)
int	init (const int port, const std::string &token)

int	tapShortcut (const char *application_name)

int	tapShortcut (const char *application_id)

int	onScreenMessage (const char *display_message)

int	onScreenReply (const char *reply_message)

void	set_event_handler (enum EventType et, handler_func f)

void	registerCallback (void(event_cb)(const std::string &event, struct json_object event_contents), void(reply_cb)(struct json_object reply_contents), void(*hangup_cb)(void)=nullptr)
void	registerCallback (void(event_cb)(const std::string &event, struct json_object event_contents), void(reply_cb)(struct json_object reply_contents), void(*hangup_cb)(void)=nullptr)

int	call (const std::string &verb, struct json_object *arg)


int	unsubscribe (const std::string &event_name)

int	showWindow (const char application_id, json_object json)

int	hideWindow (const char *application_id)

int	replyShowWindow (const char application_id, json_object json)

int	showNotification (json_object *json)

int	showInformation (json_object *json)

void	on_hangup (void closure, struct afb_wsj1 wsj)

void	on_call (void closure, const char api, const char verb, struct afb_wsj1_msg msg)

void	on_event (void closure, const char event, struct afb_wsj1_msg *msg)
void	on_event (void closure, const char event, struct afb_wsj1_msg *msg)

void	on_reply (void closure, struct afb_wsj1_msg msg)

+Public Attributes
const char *	_keyParameter = "parameter"

const char *	_keyArea = "area"

const char *	_areaNormal = "normal"

const char *	_areaFullScreen = "fullscreen"

const char *	_areaSplitMain = "split.main"

const char *	_areaSplitSub = "split.sub"

Enumerator
Event_TapShortcut
Event_OnScreenMessage
Event_OnScreenReply
Enumerator
Event_ShowWindow	+
Event_TapShortcut	+
Event_OnScreenMessage	+
Event_OnScreenReply	+
Event_HideWindow	+
Event_ReplyShowWindow	+
Event_ShowNotification	+
Event_ShowInformation	+

int LibHomeScreen::replyShowWindow	(	const char *	application_id,
		json_object *	json
	)

Static Public Attributes
static const std::vector< std::string >	api_list

int LibHomeScreen::showWindow	(	const char *	application_id,
		json_object *	json
	)

+Classes

+Macros

+Typedefs

+Functions

+Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation

+Classes

+Typedefs

Typedef Documentation

Public Types

+Public Attributes

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ handler_func

Member Enumeration Documentation

◆ EventType

Constructor & Destructor Documentation

◆ LibHomeScreen() [1/2]

◆ ~LibHomeScreen()

◆ LibHomeScreen() [2/2]

Member Function Documentation

◆ call() [1/2]

◆ call() [2/2]

Note

◆ init()

Parameters

Return

Note

◆ on_call()

◆ on_event()

◆ on_hangup()

◆ on_reply()

◆ onScreenMessage()

◆ onScreenReply()

◆ operator=()

◆ registerCallback()

Note

◆ set_event_handler()

Parameters

Return

Return

Note

◆ subscribe()

Parameters

Return

Parameters

Return

Parameters

Return

Note

◆ tapShortcut()

Parameters

Return

◆ unsubscribe()

Note

Member Data Documentation

◆ api_list

◆ event_list