Chapter 6. Cross-platform, Android

Now we will try to run TheGame spinning triangle sample on Android.

1. Start Visual Studio, open C:\CPP\a999hello\p_android\p_android.sln solution.

2. Under p_android.NativeActivity project add “xTheGame” filter:

Right-click on p_android.NativeActivity project -> Add -> New Filter. Name - xTheGame

  1. Under xTheGame add Existing Item:

Right-click on xTheGame -> Add -> Existing Item,

Navigate to C:\CPP\a999hello

Files – TheGame.cpp and TheGame.h


  1. Notify p_android.NativeActivity project where to look for TheGame.h.

Right-click on p_android.NativeActivity project -> Properties, All Configurations, ARM64, C/C++ -> General-> Additional Include Directories -> Edit, add new line.

Attention: this time instead of navigating to C:\CPP\a999hello (where TheGame is actually located), manually add


2 dots, slash, 2 dots, which means TWO folder levels up (from p_android.NativeActivity project root).

Ok, Apply, Ok.

  1. Add an access to linmath.h (required by TheGame class).

The file is located in C:/CPP/engine folder.

Add new filter under p_android.NativeActivity project, name - xEngine.

Under xEngine add Existing Item C:\CPP\engine\linmath.h

Add reference: right-click on p_android.NativeActivity project -> Properties, All Configurations, ARM64, C/C++ -> General, Additional Include Directories -> Edit, add new line, navigate to C:\CPP\engine, Select Folder, Ok, Apply, Ok.

6. Move Android implementations of myPollEvents and mySwapBuffers to platform.h/cpp. Will move mylog() to .cpp too.

Open platform.h and replace code by:

#pragma once

void mylog(const char* _Format, ...);
void mySwapBuffers();
void myPollEvents();

7. Under xPlatform add new C++ file,

Name - platform.cpp

Location: C:\CPP\p_android\


#include <android/log.h>
#include "stdio.h"
#include "TheGame.h"

extern struct android_app* androidApp;
extern const ASensor* accelerometerSensor;
extern ASensorEventQueue* sensorEventQueue;

extern EGLDisplay androidDisplay;
extern EGLSurface androidSurface;
extern TheGame theGame;

void mylog(const char* _Format, ...) {
#ifdef _DEBUG
    char outStr[1024];
    va_list _ArgList;
    va_start(_ArgList, _Format);
    vsprintf(outStr, _Format, _ArgList);
    __android_log_print(ANDROID_LOG_INFO, "mylog", outStr, NULL);

void mySwapBuffers() {
	eglSwapBuffers(androidDisplay, androidSurface);
void myPollEvents() {
	// Read all pending events.
	int ident;
	int events;
	struct android_poll_source* source;

	// If not animating, we will block forever waiting for events.
	// If animating, we loop until all events are read, then continue
	// to draw the next frame of animation.
	while ((ident = ALooper_pollAll(0, NULL, &events,
		(void**)&source)) >= 0) {

		// Process this event.
		if (source != NULL) {
			source->process(androidApp, source);

		// If a sensor has data, process it now.
		if (ident == LOOPER_ID_USER) {
			if (accelerometerSensor != NULL) {
				ASensorEvent event;
				while (ASensorEventQueue_getEvents(sensorEventQueue,
					&event, 1) > 0) {
					//LOGI("accelerometer: x=%f y=%f z=%f",
					//	event.acceleration.x, event.acceleration.y,
					//	event.acceleration.z);

		// Check if we are exiting.
		if (androidApp->destroyRequested != 0) {
			theGame.bExitGame = true;

8. Change main.cpp to call TheGame class instead of drawing green flashing screen.

Open main.cpp and replace code by:

#include "platform.h"
#include "TheGame.h"

TheGame theGame;

struct android_app* androidApp;

ASensorManager* sensorManager;
const ASensor* accelerometerSensor;
ASensorEventQueue* sensorEventQueue;

EGLDisplay androidDisplay;
EGLSurface androidSurface;
EGLContext androidContext;

* Initialize an EGL context for the current display.
static int engine_init_display(struct engine* engine) {
	// initialize OpenGL ES and EGL

	* Here specify the attributes of the desired configuration.
	* Below, we select an EGLConfig with at least 8 bits per color
	* component compatible with on-screen windows
	const EGLint attribs[] = {
	EGLint format;
	EGLint numConfigs;
	EGLConfig config;
	EGLSurface surface;
	EGLContext context;

	EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);

	eglInitialize(display, 0, 0);

	/* Here, the application chooses the configuration it desires. In this
	* sample, we have a very simplified selection process, where we pick
	* the first EGLConfig that matches our criteria */
	eglChooseConfig(display, attribs, &config, 1, &numConfigs);

	/* EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is
	* guaranteed to be accepted by ANativeWindow_setBuffersGeometry().
	* As soon as we picked a EGLConfig, we can safely reconfigure the
	* ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID. */
	eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);

	ANativeWindow_setBuffersGeometry(androidApp->window, 0, 0, format);

	surface = eglCreateWindowSurface(display, config, androidApp->window, NULL);

	EGLint contextAttribs[] =
	context = eglCreateContext(display, config, NULL, contextAttribs);

	if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) {
		mylog("ERROR: Unable to eglMakeCurrent");
		return -1;

	androidDisplay = display;
	androidContext = context;
	androidSurface = surface;

	// Initialize GL state.

	return 0;

* Tear down the EGL context currently associated with the display.
static void engine_term_display() {

	if (androidDisplay != EGL_NO_DISPLAY) {
		eglMakeCurrent(androidDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
		if (androidContext != EGL_NO_CONTEXT) {
			eglDestroyContext(androidDisplay, androidContext);
		if (androidSurface != EGL_NO_SURFACE) {
			eglDestroySurface(androidDisplay, androidSurface);
	androidDisplay = EGL_NO_DISPLAY;
	androidContext = EGL_NO_CONTEXT;
	androidSurface = EGL_NO_SURFACE;

* Process the next input event.
static int32_t engine_handle_input(struct android_app* app, AInputEvent* event) {
	if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) {
		//engine->state.x = AMotionEvent_getX(event, 0);
		//engine->state.y = AMotionEvent_getY(event, 0);
		return 1;
	return 0;

* Process the next main command.
static void engine_handle_cmd(struct android_app* app, int32_t cmd) {
	struct engine* engine = (struct engine*)app->userData;
	switch (cmd) {
		// The window is being shown, get it ready.
		if (androidApp->window != NULL) {
		// The window is being hidden or closed, clean it up.
		// When our app gains focus, we start monitoring the accelerometer.
		if (accelerometerSensor != NULL) {
			// We'd like to get 60 events per second (in microseconds).
				accelerometerSensor, (1000L / 60) * 1000);
		// When our app loses focus, we stop monitoring the accelerometer.
		// This is to avoid consuming battery while not being used.
		if (accelerometerSensor != NULL) {
		// Also stop animating.

* This is the main entry point of a native application that is using
* android_native_app_glue.  It runs in its own thread, with its own
* event loop for receiving input events and doing other things.
void android_main(struct android_app* state) {

	//state->userData = &engine;
	state->onAppCmd = engine_handle_cmd;
	state->onInputEvent = engine_handle_input;
	androidApp = state;

	// Prepare to monitor accelerometer
	sensorManager = ASensorManager_getInstance();
	accelerometerSensor = ASensorManager_getDefaultSensor(sensorManager,
	sensorEventQueue = ASensorManager_createEventQueue(sensorManager,
		state->looper, LOOPER_ID_USER, NULL, NULL);

	// Read all pending events.
	int ident;
	int events;
	struct android_poll_source* source;
	//wait for display
	while (androidDisplay == NULL) {
		// No display yet.
		mylog("No display yet\n");
		//wait for event
		while ((ident = ALooper_pollAll(0, NULL, &events,
			(void**)&source)) >= 0) {
			// Process this event.
			if (source != NULL) {
				source->process(state, source);

	EGLint w, h;
	eglQuerySurface(androidDisplay, androidSurface, EGL_WIDTH, &w);
	eglQuerySurface(androidDisplay, androidSurface, EGL_HEIGHT, &h);
	theGame.onScreenResize(w, h);;


  • Have 1 more 3.2-related change (eglCreateContext, highlighted too).

9. In current configuration the builder won't find math libraries. Need to build with -lm key.

Open p_android.NativeActivity properties, All Configurations, ARM64, proceed to Configuration Properties -> Linker -> All Options, open Additional Options -> Edit, add


Ok, Apply, Ok.

10. One more decorative touch for the sake of consistency with Windows project:

Under p_android.NativeActivity project add new filter Source Files

In Solution Explorer (right-side panel) drag-and-drop original source files to Source Files:

So, now structure is:

11. Switch on Android, unlock, plug in to PC with USB cable, allow debugging, build and run:


Runs BOTH on Android AND Windows!

Now we CAN say that we DO have a real cross-platform solution!

VS top menu -> Debug -> Stop Debugging.

Leave a Reply

Your email address will not be published. Required fields are marked *