[cogl/wip/public-atlas-apis: 8/9] examples: Add a new SDL2 based Android example
- From: Robert Bragg <rbragg src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [cogl/wip/public-atlas-apis: 8/9] examples: Add a new SDL2 based Android example
- Date: Sat, 8 Mar 2014 04:18:54 +0000 (UTC)
commit efbad32512073e005fded48ca481a7c6c96fe91f
Author: Robert Bragg <robert linux intel com>
Date: Thu Feb 13 20:29:25 2014 +0000
examples: Add a new SDL2 based Android example
This adds another examples/android project that uses SDL instead of
glib. The example itself is a copy of examples/cogl-sdl2-hello.c
which includes basic input handling to move a triangle around the
screen.
examples/android/{hello => hello-glib}/.gitignore | 0
.../{hello => hello-glib}/AndroidManifest.xml | 0
examples/android/{hello => hello-glib}/build.xml | 0
.../android/{hello => hello-glib}/jni/Android.mk | 0
.../{hello => hello-glib}/jni/Application.mk | 0
examples/android/{hello => hello-glib}/jni/main.c | 0
.../{hello => hello-glib}/res/values/strings.xml | 0
examples/android/hello-sdl/AndroidManifest.xml | 44 +
examples/android/hello-sdl/README | 26 +
examples/android/hello-sdl/ant.properties | 17 +
examples/android/hello-sdl/build.properties | 17 +
examples/android/hello-sdl/build.xml | 93 ++
examples/android/hello-sdl/default.properties | 11 +
examples/android/hello-sdl/jni/Android.mk | 4 +
examples/android/hello-sdl/jni/Application.mk | 6 +
examples/android/hello-sdl/jni/Cogl | 1 +
examples/android/hello-sdl/jni/src/Android.mk | 19 +
.../android/hello-sdl/jni/src/Android_static.mk | 12 +
.../android/hello-sdl/jni/src/cogl-sdl2-hello.c | 171 ++++
examples/android/hello-sdl/proguard-project.txt | 20 +
examples/android/hello-sdl/project.properties | 14 +
.../hello-sdl/res/drawable-hdpi/ic_launcher.png | Bin 0 -> 2683 bytes
.../hello-sdl/res/drawable-mdpi/ic_launcher.png | Bin 0 -> 1698 bytes
.../hello-sdl/res/drawable-xhdpi/ic_launcher.png | Bin 0 -> 3872 bytes
.../hello-sdl/res/drawable-xxhdpi/ic_launcher.png | Bin 0 -> 6874 bytes
examples/android/hello-sdl/res/layout/main.xml | 13 +
.../{hello => hello-sdl}/res/values/strings.xml | 2 +-
.../hello-sdl/src/org/libsdl/app/SDLActivity.java | 1030 ++++++++++++++++++++
28 files changed, 1499 insertions(+), 1 deletions(-)
---
diff --git a/examples/android/hello/.gitignore b/examples/android/hello-glib/.gitignore
similarity index 100%
rename from examples/android/hello/.gitignore
rename to examples/android/hello-glib/.gitignore
diff --git a/examples/android/hello/AndroidManifest.xml b/examples/android/hello-glib/AndroidManifest.xml
similarity index 100%
rename from examples/android/hello/AndroidManifest.xml
rename to examples/android/hello-glib/AndroidManifest.xml
diff --git a/examples/android/hello/build.xml b/examples/android/hello-glib/build.xml
similarity index 100%
rename from examples/android/hello/build.xml
rename to examples/android/hello-glib/build.xml
diff --git a/examples/android/hello/jni/Android.mk b/examples/android/hello-glib/jni/Android.mk
similarity index 100%
rename from examples/android/hello/jni/Android.mk
rename to examples/android/hello-glib/jni/Android.mk
diff --git a/examples/android/hello/jni/Application.mk b/examples/android/hello-glib/jni/Application.mk
similarity index 100%
rename from examples/android/hello/jni/Application.mk
rename to examples/android/hello-glib/jni/Application.mk
diff --git a/examples/android/hello/jni/main.c b/examples/android/hello-glib/jni/main.c
similarity index 100%
rename from examples/android/hello/jni/main.c
rename to examples/android/hello-glib/jni/main.c
diff --git a/examples/android/hello/res/values/strings.xml
b/examples/android/hello-glib/res/values/strings.xml
similarity index 100%
copy from examples/android/hello/res/values/strings.xml
copy to examples/android/hello-glib/res/values/strings.xml
diff --git a/examples/android/hello-sdl/AndroidManifest.xml b/examples/android/hello-sdl/AndroidManifest.xml
new file mode 100644
index 0000000..dc8450a
--- /dev/null
+++ b/examples/android/hello-sdl/AndroidManifest.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Replace org.libsdl.app with the identifier of your game below, e.g.
+ com.gamemaker.game
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android";
+ package="org.libsdl.app"
+ android:versionCode="1"
+ android:versionName="1.0"
+ android:installLocation="auto">
+
+ <!-- Create a Java class extending SDLActivity and place it in a
+ directory under src matching the package, e.g.
+ src/com/gamemaker/game/MyGame.java
+
+ then replace "SDLActivity" with the name of your class (e.g. "MyGame")
+ in the XML below.
+
+ An example Java class can be found in README-android.txt
+ -->
+ <application android:label="@string/app_name"
+ android:icon="@drawable/ic_launcher"
+ android:allowBackup="true"
+ android:theme="@android:style/Theme.NoTitleBar.Fullscreen"
+ android:hardwareAccelerated="true" >
+ <activity android:name="SDLActivity"
+ android:label="@string/app_name"
+ android:configChanges="keyboardHidden|orientation"
+ >
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN" />
+ <category android:name="android.intent.category.LAUNCHER" />
+ </intent-filter>
+ </activity>
+ </application>
+
+ <!-- Android 2.3.3 -->
+ <uses-sdk android:minSdkVersion="10" android:targetSdkVersion="12" />
+
+ <!-- OpenGL ES 2.0 -->
+ <uses-feature android:glEsVersion="0x00020000" />
+
+ <!-- Allow writing to external storage -->
+ <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+</manifest>
diff --git a/examples/android/hello-sdl/README b/examples/android/hello-sdl/README
new file mode 100644
index 0000000..59236c0
--- /dev/null
+++ b/examples/android/hello-sdl/README
@@ -0,0 +1,26 @@
+Before building this example you need to symlink a copy of the SDL
+source under the jni/ directory:
+
+$ cd jni/
+$ ln -s /path/to/sdl-source SDL
+
+You may need to update the project for your target:
+
+$ android list target
+$ android update project -p . -t android-15
+
+Build the example by running:
+
+$ ndk-build
+
+Or a debug build with:
+
+$ ndk-build NDK_BUILD=1
+
+Package the example by running:
+
+$ ant debug
+
+Install the example to a device with:
+
+$ ant debug install
diff --git a/examples/android/hello-sdl/ant.properties b/examples/android/hello-sdl/ant.properties
new file mode 100644
index 0000000..b0971e8
--- /dev/null
+++ b/examples/android/hello-sdl/ant.properties
@@ -0,0 +1,17 @@
+# This file is used to override default values used by the Ant build system.
+#
+# This file must be checked into Version Control Systems, as it is
+# integral to the build system of your project.
+
+# This file is only used by the Ant script.
+
+# You can use this to override default values such as
+# 'source.dir' for the location of your java source folder and
+# 'out.dir' for the location of your output folder.
+
+# You can also use it define how the release builds are signed by declaring
+# the following properties:
+# 'key.store' for the location of your keystore and
+# 'key.alias' for the name of the key to use.
+# The password will be asked during the build when you use the 'release' target.
+
diff --git a/examples/android/hello-sdl/build.properties b/examples/android/hello-sdl/build.properties
new file mode 100644
index 0000000..edc7f23
--- /dev/null
+++ b/examples/android/hello-sdl/build.properties
@@ -0,0 +1,17 @@
+# This file is used to override default values used by the Ant build system.
+#
+# This file must be checked in Version Control Systems, as it is
+# integral to the build system of your project.
+
+# This file is only used by the Ant script.
+
+# You can use this to override default values such as
+# 'source.dir' for the location of your java source folder and
+# 'out.dir' for the location of your output folder.
+
+# You can also use it define how the release builds are signed by declaring
+# the following properties:
+# 'key.store' for the location of your keystore and
+# 'key.alias' for the name of the key to use.
+# The password will be asked during the build when you use the 'release' target.
+
diff --git a/examples/android/hello-sdl/build.xml b/examples/android/hello-sdl/build.xml
new file mode 100644
index 0000000..9f19a07
--- /dev/null
+++ b/examples/android/hello-sdl/build.xml
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- This should be changed to the name of your project -->
+<project name="SDLActivity" default="help">
+
+ <!-- The local.properties file is created and updated by the 'android' tool.
+ It contains the path to the SDK. It should *NOT* be checked into
+ Version Control Systems. -->
+ <property file="local.properties" />
+
+ <!-- The ant.properties file can be created by you. It is only edited by the
+ 'android' tool to add properties to it.
+ This is the place to change some Ant specific build properties.
+ Here are some properties you may want to change/update:
+
+ source.dir
+ The name of the source directory. Default is 'src'.
+ out.dir
+ The name of the output directory. Default is 'bin'.
+
+ For other overridable properties, look at the beginning of the rules
+ files in the SDK, at tools/ant/build.xml
+
+ Properties related to the SDK location or the project target should
+ be updated using the 'android' tool with the 'update' action.
+
+ This file is an integral part of the build system for your
+ application and should be checked into Version Control Systems.
+
+ -->
+ <property file="ant.properties" />
+
+ <!-- if sdk.dir was not set from one of the property file, then
+ get it from the ANDROID_HOME env var.
+ This must be done before we load project.properties since
+ the proguard config can use sdk.dir -->
+ <property environment="env" />
+ <condition property="sdk.dir" value="${env.ANDROID_HOME}">
+ <isset property="env.ANDROID_HOME" />
+ </condition>
+
+ <!-- The project.properties file is created and updated by the 'android'
+ tool, as well as ADT.
+
+ This contains project specific properties such as project target, and library
+ dependencies. Lower level build properties are stored in ant.properties
+ (or in .classpath for Eclipse projects).
+
+ This file is an integral part of the build system for your
+ application and should be checked into Version Control Systems. -->
+ <loadproperties srcFile="project.properties" />
+
+ <!-- quick check on sdk.dir -->
+ <fail
+ message="sdk.dir is missing. Make sure to generate local.properties using 'android update
project' or to inject it through the ANDROID_HOME environment variable."
+ unless="sdk.dir"
+ />
+
+ <!--
+ Import per project custom build rules if present at the root of the project.
+ This is the place to put custom intermediary targets such as:
+ -pre-build
+ -pre-compile
+ -post-compile (This is typically used for code obfuscation.
+ Compiled code location: ${out.classes.absolute.dir}
+ If this is not done in place, override ${out.dex.input.absolute.dir})
+ -post-package
+ -post-build
+ -pre-clean
+ -->
+ <import file="custom_rules.xml" optional="true" />
+
+ <!-- Import the actual build file.
+
+ To customize existing targets, there are two options:
+ - Customize only one target:
+ - copy/paste the target into this file, *before* the
+ <import> task.
+ - customize it to your needs.
+ - Customize the whole content of build.xml
+ - copy/paste the content of the rules files (minus the top node)
+ into this file, replacing the <import> task.
+ - customize to your needs.
+
+ ***********************
+ ****** IMPORTANT ******
+ ***********************
+ In all cases you must update the value of version-tag below to read 'custom' instead of an integer,
+ in order to avoid having your file be overridden by tools such as "android update project"
+ -->
+ <!-- version-tag: 1 -->
+ <import file="${sdk.dir}/tools/ant/build.xml" />
+
+</project>
diff --git a/examples/android/hello-sdl/default.properties b/examples/android/hello-sdl/default.properties
new file mode 100644
index 0000000..0cdab95
--- /dev/null
+++ b/examples/android/hello-sdl/default.properties
@@ -0,0 +1,11 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system use,
+# "build.properties", and override values to adapt the script to your
+# project structure.
+
+# Project target.
+target=android-12
diff --git a/examples/android/hello-sdl/jni/Android.mk b/examples/android/hello-sdl/jni/Android.mk
new file mode 100644
index 0000000..bf676f4
--- /dev/null
+++ b/examples/android/hello-sdl/jni/Android.mk
@@ -0,0 +1,4 @@
+TOP_PATH := $(call my-dir)
+include $(TOP_PATH)/SDL/Android.mk
+include $(TOP_PATH)/Cogl/Android.mk
+include $(TOP_PATH)/src/Android.mk
diff --git a/examples/android/hello-sdl/jni/Application.mk b/examples/android/hello-sdl/jni/Application.mk
new file mode 100644
index 0000000..e5b5079
--- /dev/null
+++ b/examples/android/hello-sdl/jni/Application.mk
@@ -0,0 +1,6 @@
+
+# Uncomment this if you're using STL in your project
+# See CPLUSPLUS-SUPPORT.html in the NDK documentation for more information
+# APP_STL := stlport_static
+
+APP_ABI := armeabi armeabi-v7a x86
diff --git a/examples/android/hello-sdl/jni/Cogl b/examples/android/hello-sdl/jni/Cogl
new file mode 120000
index 0000000..11a54ed
--- /dev/null
+++ b/examples/android/hello-sdl/jni/Cogl
@@ -0,0 +1 @@
+../../../../
\ No newline at end of file
diff --git a/examples/android/hello-sdl/jni/src/Android.mk b/examples/android/hello-sdl/jni/src/Android.mk
new file mode 100644
index 0000000..8033438
--- /dev/null
+++ b/examples/android/hello-sdl/jni/src/Android.mk
@@ -0,0 +1,19 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := main
+
+SDL_PATH := ../SDL
+
+#LOCAL_C_INCLUDES := $(LOCAL_PATH)/$(SDL_PATH)/include
+
+# Add your application source files here...
+LOCAL_SRC_FILES := $(SDL_PATH)/src/main/android/SDL_android_main.c \
+ cogl-sdl2-hello.c
+
+LOCAL_SHARED_LIBRARIES := Cogl SDL2
+
+LOCAL_LDLIBS := -lGLESv2 -llog
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/examples/android/hello-sdl/jni/src/Android_static.mk
b/examples/android/hello-sdl/jni/src/Android_static.mk
new file mode 100644
index 0000000..faed669
--- /dev/null
+++ b/examples/android/hello-sdl/jni/src/Android_static.mk
@@ -0,0 +1,12 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := main
+
+LOCAL_SRC_FILES := YourSourceHere.c
+
+LOCAL_STATIC_LIBRARIES := SDL2_static
+
+include $(BUILD_SHARED_LIBRARY)
+$(call import-module,SDL)LOCAL_PATH := $(call my-dir)
diff --git a/examples/android/hello-sdl/jni/src/cogl-sdl2-hello.c
b/examples/android/hello-sdl/jni/src/cogl-sdl2-hello.c
new file mode 100644
index 0000000..01516a6
--- /dev/null
+++ b/examples/android/hello-sdl/jni/src/cogl-sdl2-hello.c
@@ -0,0 +1,171 @@
+#include <cogl/cogl.h>
+#include <cogl/cogl-sdl.h>
+#include <stdio.h>
+#include <SDL.h>
+
+/* This short example is just to demonstrate mixing SDL with Cogl as a
+ simple way to get portable support for events */
+
+typedef struct Data
+{
+ CoglPrimitive *triangle;
+ CoglPipeline *pipeline;
+ float center_x, center_y;
+ CoglFramebuffer *fb;
+ CoglBool quit;
+ CoglBool redraw_queued;
+ CoglBool ready_to_draw;
+} Data;
+
+static void
+redraw (Data *data)
+{
+ CoglFramebuffer *fb = data->fb;
+
+ cogl_framebuffer_clear4f (fb, COGL_BUFFER_BIT_COLOR, 0, 0, 0, 1);
+
+ cogl_framebuffer_push_matrix (fb);
+ cogl_framebuffer_translate (fb, data->center_x, -data->center_y, 0.0f);
+
+ cogl_primitive_draw (data->triangle, fb, data->pipeline);
+ cogl_framebuffer_pop_matrix (fb);
+
+ cogl_onscreen_swap_buffers (COGL_ONSCREEN (fb));
+}
+
+static void
+dirty_cb (CoglOnscreen *onscreen,
+ const CoglOnscreenDirtyInfo *info,
+ void *user_data)
+{
+ Data *data = user_data;
+
+ data->redraw_queued = TRUE;
+}
+
+static void
+handle_event (Data *data, SDL_Event *event)
+{
+ switch (event->type)
+ {
+ case SDL_WINDOWEVENT:
+ switch (event->window.event)
+ {
+ case SDL_WINDOWEVENT_CLOSE:
+ data->quit = TRUE;
+ break;
+ }
+ break;
+
+ case SDL_MOUSEMOTION:
+ {
+ int width =
+ cogl_framebuffer_get_width (data->fb);
+ int height =
+ cogl_framebuffer_get_height (data->fb);
+
+ data->center_x = event->motion.x * 2.0f / width - 1.0f;
+ data->center_y = event->motion.y * 2.0f / height - 1.0f;
+
+ data->redraw_queued = TRUE;
+ }
+ break;
+
+ case SDL_QUIT:
+ data->quit = TRUE;
+ break;
+ }
+}
+
+static void
+frame_cb (CoglOnscreen *onscreen,
+ CoglFrameEvent event,
+ CoglFrameInfo *info,
+ void *user_data)
+{
+ Data *data = user_data;
+
+ if (event == COGL_FRAME_EVENT_SYNC)
+ data->ready_to_draw = TRUE;
+}
+
+int
+main (int argc, char **argv)
+{
+ CoglContext *ctx;
+ CoglOnscreen *onscreen;
+ CoglError *error = NULL;
+ CoglVertexP2C4 triangle_vertices[] = {
+ {0, 0.7, 0xff, 0x00, 0x00, 0xff},
+ {-0.7, -0.7, 0x00, 0xff, 0x00, 0xff},
+ {0.7, -0.7, 0x00, 0x00, 0xff, 0xff}
+ };
+ Data data;
+ SDL_Event event;
+
+ SDL_VideoInit (NULL);
+
+ ctx = cogl_sdl_context_new (SDL_USEREVENT, &error);
+ if (!ctx)
+ {
+ fprintf (stderr, "Failed to create context: %s\n", error->message);
+ return 1;
+ }
+
+ onscreen = cogl_onscreen_new (ctx, 800, 600);
+ data.fb = onscreen;
+
+ cogl_onscreen_add_frame_callback (onscreen,
+ frame_cb,
+ &data,
+ NULL /* destroy callback */);
+ cogl_onscreen_add_dirty_callback (onscreen,
+ dirty_cb,
+ &data,
+ NULL /* destroy callback */);
+
+ data.center_x = 0.0f;
+ data.center_y = 0.0f;
+ data.quit = FALSE;
+
+ /* In SDL2, setting resizable only works before allocating the
+ * onscreen */
+ cogl_onscreen_set_resizable (onscreen, TRUE);
+
+ cogl_onscreen_show (onscreen);
+
+ data.triangle = cogl_primitive_new_p2c4 (ctx, COGL_VERTICES_MODE_TRIANGLES,
+ 3, triangle_vertices);
+ data.pipeline = cogl_pipeline_new (ctx);
+
+ data.redraw_queued = FALSE;
+ data.ready_to_draw = TRUE;
+
+ while (!data.quit)
+ {
+ if (!SDL_PollEvent (&event))
+ {
+ if (data.redraw_queued && data.ready_to_draw)
+ {
+ redraw (&data);
+ data.redraw_queued = FALSE;
+ data.ready_to_draw = FALSE;
+ continue;
+ }
+
+ cogl_sdl_idle (ctx);
+ if (!SDL_WaitEvent (&event))
+ {
+ fprintf (stderr, "Error waiting for SDL events");
+ return 1;
+ }
+ }
+
+ handle_event (&data, &event);
+ cogl_sdl_handle_event (ctx, &event);
+ }
+
+ cogl_object_unref (ctx);
+
+ return 0;
+}
diff --git a/examples/android/hello-sdl/proguard-project.txt b/examples/android/hello-sdl/proguard-project.txt
new file mode 100644
index 0000000..f2fe155
--- /dev/null
+++ b/examples/android/hello-sdl/proguard-project.txt
@@ -0,0 +1,20 @@
+# To enable ProGuard in your project, edit project.properties
+# to define the proguard.config property as described in that file.
+#
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in ${sdk.dir}/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the ProGuard
+# include property in project.properties.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+# public *;
+#}
diff --git a/examples/android/hello-sdl/project.properties b/examples/android/hello-sdl/project.properties
new file mode 100644
index 0000000..0840b4a
--- /dev/null
+++ b/examples/android/hello-sdl/project.properties
@@ -0,0 +1,14 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system edit
+# "ant.properties", and override values to adapt the script to your
+# project structure.
+#
+# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir,
user.home):
+#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
+
+# Project target.
+target=android-15
diff --git a/examples/android/hello-sdl/res/drawable-hdpi/ic_launcher.png
b/examples/android/hello-sdl/res/drawable-hdpi/ic_launcher.png
new file mode 100644
index 0000000..d50bdaa
Binary files /dev/null and b/examples/android/hello-sdl/res/drawable-hdpi/ic_launcher.png differ
diff --git a/examples/android/hello-sdl/res/drawable-mdpi/ic_launcher.png
b/examples/android/hello-sdl/res/drawable-mdpi/ic_launcher.png
new file mode 100644
index 0000000..0a299eb
Binary files /dev/null and b/examples/android/hello-sdl/res/drawable-mdpi/ic_launcher.png differ
diff --git a/examples/android/hello-sdl/res/drawable-xhdpi/ic_launcher.png
b/examples/android/hello-sdl/res/drawable-xhdpi/ic_launcher.png
new file mode 100644
index 0000000..a336ad5
Binary files /dev/null and b/examples/android/hello-sdl/res/drawable-xhdpi/ic_launcher.png differ
diff --git a/examples/android/hello-sdl/res/drawable-xxhdpi/ic_launcher.png
b/examples/android/hello-sdl/res/drawable-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000..d423dac
Binary files /dev/null and b/examples/android/hello-sdl/res/drawable-xxhdpi/ic_launcher.png differ
diff --git a/examples/android/hello-sdl/res/layout/main.xml b/examples/android/hello-sdl/res/layout/main.xml
new file mode 100644
index 0000000..123c4b6
--- /dev/null
+++ b/examples/android/hello-sdl/res/layout/main.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android";
+ android:orientation="vertical"
+ android:layout_width="fill_parent"
+ android:layout_height="fill_parent"
+ >
+<TextView
+ android:layout_width="fill_parent"
+ android:layout_height="wrap_content"
+ android:text="Hello World, SDLActivity"
+ />
+</LinearLayout>
+
diff --git a/examples/android/hello/res/values/strings.xml b/examples/android/hello-sdl/res/values/strings.xml
similarity index 55%
rename from examples/android/hello/res/values/strings.xml
rename to examples/android/hello-sdl/res/values/strings.xml
index e4cdec0..aca4966 100644
--- a/examples/android/hello/res/values/strings.xml
+++ b/examples/android/hello-sdl/res/values/strings.xml
@@ -1,4 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<resources>
- <string name="app_name">TestCoglHello</string>
+ <string name="app_name">Cogl App</string>
</resources>
diff --git a/examples/android/hello-sdl/src/org/libsdl/app/SDLActivity.java
b/examples/android/hello-sdl/src/org/libsdl/app/SDLActivity.java
new file mode 100644
index 0000000..81420db
--- /dev/null
+++ b/examples/android/hello-sdl/src/org/libsdl/app/SDLActivity.java
@@ -0,0 +1,1030 @@
+package org.libsdl.app;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import android.app.*;
+import android.content.*;
+import android.view.*;
+import android.view.inputmethod.BaseInputConnection;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AbsoluteLayout;
+import android.os.*;
+import android.util.Log;
+import android.graphics.*;
+import android.media.*;
+import android.hardware.*;
+
+
+/**
+ SDL Activity
+*/
+public class SDLActivity extends Activity {
+ private static final String TAG = "SDL";
+
+ // Keep track of the paused state
+ public static boolean mIsPaused = false, mIsSurfaceReady = false, mHasFocus = true;
+ public static boolean mExitCalledFromJava;
+
+ // Main components
+ protected static SDLActivity mSingleton;
+ protected static SDLSurface mSurface;
+ protected static View mTextEdit;
+ protected static ViewGroup mLayout;
+ protected static SDLJoystickHandler mJoystickHandler;
+
+ // This is what SDL runs in. It invokes SDL_main(), eventually
+ protected static Thread mSDLThread;
+
+ // Audio
+ protected static Thread mAudioThread;
+ protected static AudioTrack mAudioTrack;
+
+ // Load the .so
+ static {
+ System.loadLibrary("SDL2");
+ //System.loadLibrary("SDL2_image");
+ //System.loadLibrary("SDL2_mixer");
+ //System.loadLibrary("SDL2_net");
+ //System.loadLibrary("SDL2_ttf");
+ System.loadLibrary("Cogl");
+ System.loadLibrary("main");
+ }
+
+ // Setup
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ //Log.v("SDL", "onCreate()");
+ super.onCreate(savedInstanceState);
+
+ // So we can call stuff from static callbacks
+ mSingleton = this;
+
+ // Set up the surface
+ mSurface = new SDLSurface(getApplication());
+
+ // Make sure this variable is initialized here!
+ mExitCalledFromJava = false;
+
+ if(Build.VERSION.SDK_INT >= 12) {
+ mJoystickHandler = new SDLJoystickHandler_API12();
+ }
+ else {
+ mJoystickHandler = new SDLJoystickHandler();
+ }
+
+ mLayout = new AbsoluteLayout(this);
+ mLayout.addView(mSurface);
+
+ setContentView(mLayout);
+ }
+
+ // Events
+ @Override
+ protected void onPause() {
+ Log.v("SDL", "onPause()");
+ super.onPause();
+ SDLActivity.handlePause();
+ }
+
+ @Override
+ protected void onResume() {
+ Log.v("SDL", "onResume()");
+ super.onResume();
+ SDLActivity.handleResume();
+ }
+
+
+ @Override
+ public void onWindowFocusChanged(boolean hasFocus) {
+ super.onWindowFocusChanged(hasFocus);
+ Log.v("SDL", "onWindowFocusChanged(): " + hasFocus);
+
+ SDLActivity.mHasFocus = hasFocus;
+ if (hasFocus) {
+ SDLActivity.handleResume();
+ }
+ }
+
+ @Override
+ public void onLowMemory() {
+ Log.v("SDL", "onLowMemory()");
+ super.onLowMemory();
+ SDLActivity.nativeLowMemory();
+ }
+
+ @Override
+ protected void onDestroy() {
+ super.onDestroy();
+ Log.v("SDL", "onDestroy()");
+ // Send a quit message to the application
+ SDLActivity.mExitCalledFromJava = true;
+ SDLActivity.nativeQuit();
+
+ // Now wait for the SDL thread to quit
+ if (SDLActivity.mSDLThread != null) {
+ try {
+ SDLActivity.mSDLThread.join();
+ } catch(Exception e) {
+ Log.v("SDL", "Problem stopping thread: " + e);
+ }
+ SDLActivity.mSDLThread = null;
+
+ //Log.v("SDL", "Finished waiting for SDL thread");
+ }
+ }
+
+ @Override
+ public boolean dispatchKeyEvent(KeyEvent event) {
+ int keyCode = event.getKeyCode();
+ // Ignore certain special keys so they're handled by Android
+ if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN ||
+ keyCode == KeyEvent.KEYCODE_VOLUME_UP ||
+ keyCode == KeyEvent.KEYCODE_CAMERA ||
+ keyCode == 168 || /* API 11: KeyEvent.KEYCODE_ZOOM_IN */
+ keyCode == 169 /* API 11: KeyEvent.KEYCODE_ZOOM_OUT */
+ ) {
+ return false;
+ }
+ return super.dispatchKeyEvent(event);
+ }
+
+ /** Called by onPause or surfaceDestroyed. Even if surfaceDestroyed
+ * is the first to be called, mIsSurfaceReady should still be set
+ * to 'true' during the call to onPause (in a usual scenario).
+ */
+ public static void handlePause() {
+ if (!SDLActivity.mIsPaused && SDLActivity.mIsSurfaceReady) {
+ SDLActivity.mIsPaused = true;
+ SDLActivity.nativePause();
+ mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, false);
+ }
+ }
+
+ /** Called by onResume or surfaceCreated. An actual resume should be done only when the surface is ready.
+ * Note: Some Android variants may send multiple surfaceChanged events, so we don't need to resume
+ * every time we get one of those events, only if it comes after surfaceDestroyed
+ */
+ public static void handleResume() {
+ if (SDLActivity.mIsPaused && SDLActivity.mIsSurfaceReady && SDLActivity.mHasFocus) {
+ SDLActivity.mIsPaused = false;
+ SDLActivity.nativeResume();
+ mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, true);
+ }
+ }
+
+ /* The native thread has finished */
+ public static void handleNativeExit() {
+ SDLActivity.mSDLThread = null;
+ mSingleton.finish();
+ }
+
+
+ // Messages from the SDLMain thread
+ static final int COMMAND_CHANGE_TITLE = 1;
+ static final int COMMAND_UNUSED = 2;
+ static final int COMMAND_TEXTEDIT_HIDE = 3;
+
+ protected static final int COMMAND_USER = 0x8000;
+
+ /**
+ * This method is called by SDL if SDL did not handle a message itself.
+ * This happens if a received message contains an unsupported command.
+ * Method can be overwritten to handle Messages in a different class.
+ * @param command the command of the message.
+ * @param param the parameter of the message. May be null.
+ * @return if the message was handled in overridden method.
+ */
+ protected boolean onUnhandledMessage(int command, Object param) {
+ return false;
+ }
+
+ /**
+ * A Handler class for Messages from native SDL applications.
+ * It uses current Activities as target (e.g. for the title).
+ * static to prevent implicit references to enclosing object.
+ */
+ protected static class SDLCommandHandler extends Handler {
+ @Override
+ public void handleMessage(Message msg) {
+ Context context = getContext();
+ if (context == null) {
+ Log.e(TAG, "error handling message, getContext() returned null");
+ return;
+ }
+ switch (msg.arg1) {
+ case COMMAND_CHANGE_TITLE:
+ if (context instanceof Activity) {
+ ((Activity) context).setTitle((String)msg.obj);
+ } else {
+ Log.e(TAG, "error handling message, getContext() returned no Activity");
+ }
+ break;
+ case COMMAND_TEXTEDIT_HIDE:
+ if (mTextEdit != null) {
+ mTextEdit.setVisibility(View.GONE);
+
+ InputMethodManager imm = (InputMethodManager)
context.getSystemService(Context.INPUT_METHOD_SERVICE);
+ imm.hideSoftInputFromWindow(mTextEdit.getWindowToken(), 0);
+ }
+ break;
+
+ default:
+ if ((context instanceof SDLActivity) && !((SDLActivity)
context).onUnhandledMessage(msg.arg1, msg.obj)) {
+ Log.e(TAG, "error handling message, command is " + msg.arg1);
+ }
+ }
+ }
+ }
+
+ // Handler for the messages
+ Handler commandHandler = new SDLCommandHandler();
+
+ // Send a message from the SDLMain thread
+ boolean sendCommand(int command, Object data) {
+ Message msg = commandHandler.obtainMessage();
+ msg.arg1 = command;
+ msg.obj = data;
+ return commandHandler.sendMessage(msg);
+ }
+
+ // C functions we call
+ public static native void nativeInit();
+ public static native void nativeLowMemory();
+ public static native void nativeQuit();
+ public static native void nativePause();
+ public static native void nativeResume();
+ public static native void onNativeResize(int x, int y, int format);
+ public static native int onNativePadDown(int device_id, int keycode);
+ public static native int onNativePadUp(int device_id, int keycode);
+ public static native void onNativeJoy(int device_id, int axis,
+ float value);
+ public static native void onNativeKeyDown(int keycode);
+ public static native void onNativeKeyUp(int keycode);
+ public static native void onNativeKeyboardFocusLost();
+ public static native void onNativeTouch(int touchDevId, int pointerFingerId,
+ int action, float x,
+ float y, float p);
+ public static native void onNativeAccel(float x, float y, float z);
+ public static native void onNativeSurfaceChanged();
+ public static native void onNativeSurfaceDestroyed();
+ public static native void nativeFlipBuffers();
+ public static native int nativeAddJoystick(int device_id, String name,
+ int is_accelerometer, int nbuttons,
+ int naxes, int nhats, int nballs);
+ public static native int nativeRemoveJoystick(int device_id);
+
+ public static void flipBuffers() {
+ SDLActivity.nativeFlipBuffers();
+ }
+
+ public static boolean setActivityTitle(String title) {
+ // Called from SDLMain() thread and can't directly affect the view
+ return mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);
+ }
+
+ public static boolean sendMessage(int command, int param) {
+ return mSingleton.sendCommand(command, Integer.valueOf(param));
+ }
+
+ public static Context getContext() {
+ return mSingleton;
+ }
+
+ /**
+ * @return result of getSystemService(name) but executed on UI thread.
+ */
+ public Object getSystemServiceFromUiThread(final String name) {
+ final Object lock = new Object();
+ final Object[] results = new Object[2]; // array for writable variables
+ synchronized (lock) {
+ runOnUiThread(new Runnable() {
+ @Override
+ public void run() {
+ synchronized (lock) {
+ results[0] = getSystemService(name);
+ results[1] = Boolean.TRUE;
+ lock.notify();
+ }
+ }
+ });
+ if (results[1] == null) {
+ try {
+ lock.wait();
+ } catch (InterruptedException ex) {
+ ex.printStackTrace();
+ }
+ }
+ }
+ return results[0];
+ }
+
+ static class ShowTextInputTask implements Runnable {
+ /*
+ * This is used to regulate the pan&scan method to have some offset from
+ * the bottom edge of the input region and the top edge of an input
+ * method (soft keyboard)
+ */
+ static final int HEIGHT_PADDING = 15;
+
+ public int x, y, w, h;
+
+ public ShowTextInputTask(int x, int y, int w, int h) {
+ this.x = x;
+ this.y = y;
+ this.w = w;
+ this.h = h;
+ }
+
+ @Override
+ public void run() {
+ AbsoluteLayout.LayoutParams params = new AbsoluteLayout.LayoutParams(
+ w, h + HEIGHT_PADDING, x, y);
+
+ if (mTextEdit == null) {
+ mTextEdit = new DummyEdit(getContext());
+
+ mLayout.addView(mTextEdit, params);
+ } else {
+ mTextEdit.setLayoutParams(params);
+ }
+
+ mTextEdit.setVisibility(View.VISIBLE);
+ mTextEdit.requestFocus();
+
+ InputMethodManager imm = (InputMethodManager)
getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+ imm.showSoftInput(mTextEdit, 0);
+ }
+ }
+
+ public static boolean showTextInput(int x, int y, int w, int h) {
+ // Transfer the task to the main thread as a Runnable
+ return mSingleton.commandHandler.post(new ShowTextInputTask(x, y, w, h));
+ }
+
+ public static Surface getNativeSurface() {
+ return SDLActivity.mSurface.getNativeSurface();
+ }
+
+ // Audio
+ public static int audioInit(int sampleRate, boolean is16Bit, boolean isStereo, int desiredFrames) {
+ int channelConfig = isStereo ? AudioFormat.CHANNEL_CONFIGURATION_STEREO :
AudioFormat.CHANNEL_CONFIGURATION_MONO;
+ int audioFormat = is16Bit ? AudioFormat.ENCODING_PCM_16BIT : AudioFormat.ENCODING_PCM_8BIT;
+ int frameSize = (isStereo ? 2 : 1) * (is16Bit ? 2 : 1);
+
+ Log.v("SDL", "SDL audio: wanted " + (isStereo ? "stereo" : "mono") + " " + (is16Bit ? "16-bit" :
"8-bit") + " " + (sampleRate / 1000f) + "kHz, " + desiredFrames + " frames buffer");
+
+ // Let the user pick a larger buffer if they really want -- but ye
+ // gods they probably shouldn't, the minimums are horrifyingly high
+ // latency already
+ desiredFrames = Math.max(desiredFrames, (AudioTrack.getMinBufferSize(sampleRate, channelConfig,
audioFormat) + frameSize - 1) / frameSize);
+
+ if (mAudioTrack == null) {
+ mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,
+ channelConfig, audioFormat, desiredFrames * frameSize, AudioTrack.MODE_STREAM);
+
+ // Instantiating AudioTrack can "succeed" without an exception and the track may still be invalid
+ // Ref:
https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/media/java/android/media/AudioTrack.java
+ // Ref: http://developer.android.com/reference/android/media/AudioTrack.html#getState()
+
+ if (mAudioTrack.getState() != AudioTrack.STATE_INITIALIZED) {
+ Log.e("SDL", "Failed during initialization of Audio Track");
+ mAudioTrack = null;
+ return -1;
+ }
+
+ mAudioTrack.play();
+ }
+
+ Log.v("SDL", "SDL audio: got " + ((mAudioTrack.getChannelCount() >= 2) ? "stereo" : "mono") + " " +
((mAudioTrack.getAudioFormat() == AudioFormat.ENCODING_PCM_16BIT) ? "16-bit" : "8-bit") + " " +
(mAudioTrack.getSampleRate() / 1000f) + "kHz, " + desiredFrames + " frames buffer");
+
+ return 0;
+ }
+
+ public static void audioWriteShortBuffer(short[] buffer) {
+ for (int i = 0; i < buffer.length; ) {
+ int result = mAudioTrack.write(buffer, i, buffer.length - i);
+ if (result > 0) {
+ i += result;
+ } else if (result == 0) {
+ try {
+ Thread.sleep(1);
+ } catch(InterruptedException e) {
+ // Nom nom
+ }
+ } else {
+ Log.w("SDL", "SDL audio: error return from write(short)");
+ return;
+ }
+ }
+ }
+
+ public static void audioWriteByteBuffer(byte[] buffer) {
+ for (int i = 0; i < buffer.length; ) {
+ int result = mAudioTrack.write(buffer, i, buffer.length - i);
+ if (result > 0) {
+ i += result;
+ } else if (result == 0) {
+ try {
+ Thread.sleep(1);
+ } catch(InterruptedException e) {
+ // Nom nom
+ }
+ } else {
+ Log.w("SDL", "SDL audio: error return from write(byte)");
+ return;
+ }
+ }
+ }
+
+ public static void audioQuit() {
+ if (mAudioTrack != null) {
+ mAudioTrack.stop();
+ mAudioTrack = null;
+ }
+ }
+
+ // Input
+
+ /**
+ * @return an array which may be empty but is never null.
+ */
+ public static int[] inputGetInputDeviceIds(int sources) {
+ int[] ids = InputDevice.getDeviceIds();
+ int[] filtered = new int[ids.length];
+ int used = 0;
+ for (int i = 0; i < ids.length; ++i) {
+ InputDevice device = InputDevice.getDevice(ids[i]);
+ if ((device != null) && ((device.getSources() & sources) != 0)) {
+ filtered[used++] = device.getId();
+ }
+ }
+ return Arrays.copyOf(filtered, used);
+ }
+
+ // Joystick glue code, just a series of stubs that redirect to the SDLJoystickHandler instance
+ public static boolean handleJoystickMotionEvent(MotionEvent event) {
+ return mJoystickHandler.handleMotionEvent(event);
+ }
+
+ public static void pollInputDevices() {
+ if (SDLActivity.mSDLThread != null) {
+ mJoystickHandler.pollInputDevices();
+ }
+ }
+
+}
+
+/**
+ Simple nativeInit() runnable
+*/
+class SDLMain implements Runnable {
+ @Override
+ public void run() {
+ // Runs SDL_main()
+ SDLActivity.nativeInit();
+
+ //Log.v("SDL", "SDL thread terminated");
+ }
+}
+
+
+/**
+ SDLSurface. This is what we draw on, so we need to know when it's created
+ in order to do anything useful.
+
+ Because of this, that's where we set up the SDL thread
+*/
+class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
+ View.OnKeyListener, View.OnTouchListener, SensorEventListener {
+
+ // Sensors
+ protected static SensorManager mSensorManager;
+ protected static Display mDisplay;
+
+ // Keep track of the surface size to normalize touch events
+ protected static float mWidth, mHeight;
+
+ // Startup
+ public SDLSurface(Context context) {
+ super(context);
+ getHolder().addCallback(this);
+
+ setFocusable(true);
+ setFocusableInTouchMode(true);
+ requestFocus();
+ setOnKeyListener(this);
+ setOnTouchListener(this);
+
+ mDisplay = ((WindowManager)context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
+ mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
+
+ if(Build.VERSION.SDK_INT >= 12) {
+ setOnGenericMotionListener(new SDLGenericMotionListener_API12());
+ }
+
+ // Some arbitrary defaults to avoid a potential division by zero
+ mWidth = 1.0f;
+ mHeight = 1.0f;
+ }
+
+ public Surface getNativeSurface() {
+ return getHolder().getSurface();
+ }
+
+ // Called when we have a valid drawing surface
+ @Override
+ public void surfaceCreated(SurfaceHolder holder) {
+ Log.v("SDL", "surfaceCreated()");
+ holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
+ }
+
+ // Called when we lose the surface
+ @Override
+ public void surfaceDestroyed(SurfaceHolder holder) {
+ Log.v("SDL", "surfaceDestroyed()");
+ // Call this *before* setting mIsSurfaceReady to 'false'
+ SDLActivity.handlePause();
+ SDLActivity.mIsSurfaceReady = false;
+ SDLActivity.onNativeSurfaceDestroyed();
+ }
+
+ // Called when the surface is resized
+ @Override
+ public void surfaceChanged(SurfaceHolder holder,
+ int format, int width, int height) {
+ Log.v("SDL", "surfaceChanged()");
+
+ int sdlFormat = 0x15151002; // SDL_PIXELFORMAT_RGB565 by default
+ switch (format) {
+ case PixelFormat.A_8:
+ Log.v("SDL", "pixel format A_8");
+ break;
+ case PixelFormat.LA_88:
+ Log.v("SDL", "pixel format LA_88");
+ break;
+ case PixelFormat.L_8:
+ Log.v("SDL", "pixel format L_8");
+ break;
+ case PixelFormat.RGBA_4444:
+ Log.v("SDL", "pixel format RGBA_4444");
+ sdlFormat = 0x15421002; // SDL_PIXELFORMAT_RGBA4444
+ break;
+ case PixelFormat.RGBA_5551:
+ Log.v("SDL", "pixel format RGBA_5551");
+ sdlFormat = 0x15441002; // SDL_PIXELFORMAT_RGBA5551
+ break;
+ case PixelFormat.RGBA_8888:
+ Log.v("SDL", "pixel format RGBA_8888");
+ sdlFormat = 0x16462004; // SDL_PIXELFORMAT_RGBA8888
+ break;
+ case PixelFormat.RGBX_8888:
+ Log.v("SDL", "pixel format RGBX_8888");
+ sdlFormat = 0x16261804; // SDL_PIXELFORMAT_RGBX8888
+ break;
+ case PixelFormat.RGB_332:
+ Log.v("SDL", "pixel format RGB_332");
+ sdlFormat = 0x14110801; // SDL_PIXELFORMAT_RGB332
+ break;
+ case PixelFormat.RGB_565:
+ Log.v("SDL", "pixel format RGB_565");
+ sdlFormat = 0x15151002; // SDL_PIXELFORMAT_RGB565
+ break;
+ case PixelFormat.RGB_888:
+ Log.v("SDL", "pixel format RGB_888");
+ // Not sure this is right, maybe SDL_PIXELFORMAT_RGB24 instead?
+ sdlFormat = 0x16161804; // SDL_PIXELFORMAT_RGB888
+ break;
+ default:
+ Log.v("SDL", "pixel format unknown " + format);
+ break;
+ }
+
+ mWidth = width;
+ mHeight = height;
+ SDLActivity.onNativeResize(width, height, sdlFormat);
+ Log.v("SDL", "Window size:" + width + "x"+height);
+
+ // Set mIsSurfaceReady to 'true' *before* making a call to handleResume
+ SDLActivity.mIsSurfaceReady = true;
+ SDLActivity.onNativeSurfaceChanged();
+
+
+ if (SDLActivity.mSDLThread == null) {
+ // This is the entry point to the C app.
+ // Start up the C app thread and enable sensor input for the first time
+
+ SDLActivity.mSDLThread = new Thread(new SDLMain(), "SDLThread");
+ enableSensor(Sensor.TYPE_ACCELEROMETER, true);
+ SDLActivity.mSDLThread.start();
+
+ // Set up a listener thread to catch when the native thread ends
+ new Thread(new Runnable(){
+ @Override
+ public void run(){
+ try {
+ SDLActivity.mSDLThread.join();
+ }
+ catch(Exception e){}
+ finally{
+ // Native thread has finished
+ if (! SDLActivity.mExitCalledFromJava) {
+ SDLActivity.handleNativeExit();
+ }
+ }
+ }
+ }).start();
+ }
+ }
+
+ // unused
+ @Override
+ public void onDraw(Canvas canvas) {}
+
+
+ // Key events
+ @Override
+ public boolean onKey(View v, int keyCode, KeyEvent event) {
+ // Dispatch the different events depending on where they come from
+ // Some SOURCE_DPAD or SOURCE_GAMEPAD are also SOURCE_KEYBOARD
+ // So, we try to process them as DPAD or GAMEPAD events first, if that fails we try them as KEYBOARD
+
+ if ( (event.getSource() & 0x00000401) != 0 || /* API 12: SOURCE_GAMEPAD */
+ (event.getSource() & InputDevice.SOURCE_DPAD) != 0 ) {
+ if (event.getAction() == KeyEvent.ACTION_DOWN) {
+ if (SDLActivity.onNativePadDown(event.getDeviceId(), keyCode) == 0) {
+ return true;
+ }
+ } else if (event.getAction() == KeyEvent.ACTION_UP) {
+ if (SDLActivity.onNativePadUp(event.getDeviceId(), keyCode) == 0) {
+ return true;
+ }
+ }
+ }
+
+ if( (event.getSource() & InputDevice.SOURCE_KEYBOARD) != 0) {
+ if (event.getAction() == KeyEvent.ACTION_DOWN) {
+ //Log.v("SDL", "key down: " + keyCode);
+ SDLActivity.onNativeKeyDown(keyCode);
+ return true;
+ }
+ else if (event.getAction() == KeyEvent.ACTION_UP) {
+ //Log.v("SDL", "key up: " + keyCode);
+ SDLActivity.onNativeKeyUp(keyCode);
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ // Touch events
+ @Override
+ public boolean onTouch(View v, MotionEvent event) {
+ /* Ref: http://developer.android.com/training/gestures/multi.html */
+ final int touchDevId = event.getDeviceId();
+ final int pointerCount = event.getPointerCount();
+ int action = event.getActionMasked();
+ int pointerFingerId;
+ int i = -1;
+ float x,y,p;
+
+ switch(action) {
+ case MotionEvent.ACTION_MOVE:
+ for (i = 0; i < pointerCount; i++) {
+ pointerFingerId = event.getPointerId(i);
+ x = event.getX(i) / mWidth;
+ y = event.getY(i) / mHeight;
+ p = event.getPressure(i);
+ SDLActivity.onNativeTouch(touchDevId, pointerFingerId, action, x, y, p);
+ }
+ break;
+
+ case MotionEvent.ACTION_UP:
+ case MotionEvent.ACTION_DOWN:
+ // Primary pointer up/down, the index is always zero
+ i = 0;
+ case MotionEvent.ACTION_POINTER_UP:
+ case MotionEvent.ACTION_POINTER_DOWN:
+ // Non primary pointer up/down
+ if (i == -1) {
+ i = event.getActionIndex();
+ }
+
+ pointerFingerId = event.getPointerId(i);
+ x = event.getX(i) / mWidth;
+ y = event.getY(i) / mHeight;
+ p = event.getPressure(i);
+ SDLActivity.onNativeTouch(touchDevId, pointerFingerId, action, x, y, p);
+ break;
+
+ default:
+ break;
+ }
+
+ return true;
+ }
+
+ // Sensor events
+ public void enableSensor(int sensortype, boolean enabled) {
+ // TODO: This uses getDefaultSensor - what if we have >1 accels?
+ if (enabled) {
+ mSensorManager.registerListener(this,
+ mSensorManager.getDefaultSensor(sensortype),
+ SensorManager.SENSOR_DELAY_GAME, null);
+ } else {
+ mSensorManager.unregisterListener(this,
+ mSensorManager.getDefaultSensor(sensortype));
+ }
+ }
+
+ @Override
+ public void onAccuracyChanged(Sensor sensor, int accuracy) {
+ // TODO
+ }
+
+ @Override
+ public void onSensorChanged(SensorEvent event) {
+ if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
+ float x, y;
+ switch (mDisplay.getRotation()) {
+ case Surface.ROTATION_90:
+ x = -event.values[1];
+ y = event.values[0];
+ break;
+ case Surface.ROTATION_270:
+ x = event.values[1];
+ y = -event.values[0];
+ break;
+ case Surface.ROTATION_180:
+ x = -event.values[1];
+ y = -event.values[0];
+ break;
+ default:
+ x = event.values[0];
+ y = event.values[1];
+ break;
+ }
+ SDLActivity.onNativeAccel(-x / SensorManager.GRAVITY_EARTH,
+ y / SensorManager.GRAVITY_EARTH,
+ event.values[2] / SensorManager.GRAVITY_EARTH - 1);
+ }
+ }
+}
+
+/* This is a fake invisible editor view that receives the input and defines the
+ * pan&scan region
+ */
+class DummyEdit extends View implements View.OnKeyListener {
+ InputConnection ic;
+
+ public DummyEdit(Context context) {
+ super(context);
+ setFocusableInTouchMode(true);
+ setFocusable(true);
+ setOnKeyListener(this);
+ }
+
+ @Override
+ public boolean onCheckIsTextEditor() {
+ return true;
+ }
+
+ @Override
+ public boolean onKey(View v, int keyCode, KeyEvent event) {
+
+ // This handles the hardware keyboard input
+ if (event.isPrintingKey()) {
+ if (event.getAction() == KeyEvent.ACTION_DOWN) {
+ ic.commitText(String.valueOf((char) event.getUnicodeChar()), 1);
+ }
+ return true;
+ }
+
+ if (event.getAction() == KeyEvent.ACTION_DOWN) {
+ SDLActivity.onNativeKeyDown(keyCode);
+ return true;
+ } else if (event.getAction() == KeyEvent.ACTION_UP) {
+ SDLActivity.onNativeKeyUp(keyCode);
+ return true;
+ }
+
+ return false;
+ }
+
+ //
+ @Override
+ public boolean onKeyPreIme (int keyCode, KeyEvent event) {
+ // As seen on StackOverflow: http://stackoverflow.com/questions/7634346/keyboard-hide-event
+ // FIXME: Discussion at http://bugzilla.libsdl.org/show_bug.cgi?id=1639
+ // FIXME: This is not a 100% effective solution to the problem of detecting if the keyboard is
showing or not
+ // FIXME: A more effective solution would be to change our Layout from AbsoluteLayout to Relative or
Linear
+ // FIXME: And determine the keyboard presence doing this:
http://stackoverflow.com/questions/2150078/how-to-check-visibility-of-software-keyboard-in-android
+ // FIXME: An even more effective way would be if Android provided this out of the box, but where
would the fun be in that :)
+ if (event.getAction()==KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK) {
+ if (SDLActivity.mTextEdit != null && SDLActivity.mTextEdit.getVisibility() == View.VISIBLE) {
+ SDLActivity.onNativeKeyboardFocusLost();
+ }
+ }
+ return super.onKeyPreIme(keyCode, event);
+ }
+
+ @Override
+ public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
+ ic = new SDLInputConnection(this, true);
+
+ outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_EXTRACT_UI
+ | 33554432 /* API 11: EditorInfo.IME_FLAG_NO_FULLSCREEN */;
+
+ return ic;
+ }
+}
+
+class SDLInputConnection extends BaseInputConnection {
+
+ public SDLInputConnection(View targetView, boolean fullEditor) {
+ super(targetView, fullEditor);
+
+ }
+
+ @Override
+ public boolean sendKeyEvent(KeyEvent event) {
+
+ /*
+ * This handles the keycodes from soft keyboard (and IME-translated
+ * input from hardkeyboard)
+ */
+ int keyCode = event.getKeyCode();
+ if (event.getAction() == KeyEvent.ACTION_DOWN) {
+ if (event.isPrintingKey()) {
+ commitText(String.valueOf((char) event.getUnicodeChar()), 1);
+ }
+ SDLActivity.onNativeKeyDown(keyCode);
+ return true;
+ } else if (event.getAction() == KeyEvent.ACTION_UP) {
+
+ SDLActivity.onNativeKeyUp(keyCode);
+ return true;
+ }
+ return super.sendKeyEvent(event);
+ }
+
+ @Override
+ public boolean commitText(CharSequence text, int newCursorPosition) {
+
+ nativeCommitText(text.toString(), newCursorPosition);
+
+ return super.commitText(text, newCursorPosition);
+ }
+
+ @Override
+ public boolean setComposingText(CharSequence text, int newCursorPosition) {
+
+ nativeSetComposingText(text.toString(), newCursorPosition);
+
+ return super.setComposingText(text, newCursorPosition);
+ }
+
+ public native void nativeCommitText(String text, int newCursorPosition);
+
+ public native void nativeSetComposingText(String text, int newCursorPosition);
+
+ @Override
+ public boolean deleteSurroundingText(int beforeLength, int afterLength) {
+ // Workaround to capture backspace key. Ref:
http://stackoverflow.com/questions/14560344/android-backspace-in-webview-baseinputconnection
+ if (beforeLength == 1 && afterLength == 0) {
+ // backspace
+ return super.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL))
+ && super.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_DEL));
+ }
+
+ return super.deleteSurroundingText(beforeLength, afterLength);
+ }
+}
+
+/* A null joystick handler for API level < 12 devices (the accelerometer is handled separately) */
+class SDLJoystickHandler {
+
+ public boolean handleMotionEvent(MotionEvent event) {
+ return false;
+ }
+
+ public void pollInputDevices() {
+ }
+}
+
+/* Actual joystick functionality available for API >= 12 devices */
+class SDLJoystickHandler_API12 extends SDLJoystickHandler {
+
+ class SDLJoystick {
+ public int device_id;
+ public String name;
+ public ArrayList<InputDevice.MotionRange> axes;
+ }
+
+ private ArrayList<SDLJoystick> mJoysticks;
+
+ public SDLJoystickHandler_API12() {
+
+ mJoysticks = new ArrayList<SDLJoystick>();
+ }
+
+ @Override
+ public void pollInputDevices() {
+ int[] deviceIds = InputDevice.getDeviceIds();
+ // It helps processing the device ids in reverse order
+ // For example, in the case of the XBox 360 wireless dongle,
+ // so the first controller seen by SDL matches what the receiver
+ // considers to be the first controller
+
+ for(int i=deviceIds.length-1; i>-1; i--) {
+ SDLJoystick joystick = getJoystick(deviceIds[i]);
+ if (joystick == null) {
+ joystick = new SDLJoystick();
+ InputDevice joystickDevice = InputDevice.getDevice(deviceIds[i]);
+ if( (joystickDevice.getSources() & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) {
+ joystick.device_id = deviceIds[i];
+ joystick.name = joystickDevice.getName();
+ joystick.axes = new ArrayList<InputDevice.MotionRange>();
+
+ for (InputDevice.MotionRange range : joystickDevice.getMotionRanges()) {
+ if ( (range.getSource() & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) {
+ joystick.axes.add(range);
+ }
+ }
+
+ mJoysticks.add(joystick);
+ SDLActivity.nativeAddJoystick(joystick.device_id, joystick.name, 0, -1,
joystick.axes.size(), 0, 0);
+ }
+ }
+ }
+
+ /* Check removed devices */
+ ArrayList<Integer> removedDevices = new ArrayList<Integer>();
+ for(int i=0; i < mJoysticks.size(); i++) {
+ int device_id = mJoysticks.get(i).device_id;
+ int j;
+ for (j=0; j < deviceIds.length; j++) {
+ if (device_id == deviceIds[j]) break;
+ }
+ if (j == deviceIds.length) {
+ removedDevices.add(device_id);
+ }
+ }
+
+ for(int i=0; i < removedDevices.size(); i++) {
+ int device_id = removedDevices.get(i);
+ SDLActivity.nativeRemoveJoystick(device_id);
+ for (int j=0; j < mJoysticks.size(); j++) {
+ if (mJoysticks.get(j).device_id == device_id) {
+ mJoysticks.remove(j);
+ break;
+ }
+ }
+ }
+ }
+
+ protected SDLJoystick getJoystick(int device_id) {
+ for(int i=0; i < mJoysticks.size(); i++) {
+ if (mJoysticks.get(i).device_id == device_id) {
+ return mJoysticks.get(i);
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public boolean handleMotionEvent(MotionEvent event) {
+ if ( (event.getSource() & InputDevice.SOURCE_JOYSTICK) != 0) {
+ int actionPointerIndex = event.getActionIndex();
+ int action = event.getActionMasked();
+ switch(action) {
+ case MotionEvent.ACTION_MOVE:
+ SDLJoystick joystick = getJoystick(event.getDeviceId());
+ if ( joystick != null ) {
+ for (int i = 0; i < joystick.axes.size(); i++) {
+ InputDevice.MotionRange range = joystick.axes.get(i);
+ /* Normalize the value to -1...1 */
+ float value = ( event.getAxisValue( range.getAxis(), actionPointerIndex) -
range.getMin() ) / range.getRange() * 2.0f - 1.0f;
+ SDLActivity.onNativeJoy(joystick.device_id, i, value );
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ return true;
+ }
+}
+
+class SDLGenericMotionListener_API12 implements View.OnGenericMotionListener {
+ // Generic Motion (mouse hover, joystick...) events go here
+ // We only have joysticks yet
+ @Override
+ public boolean onGenericMotion(View v, MotionEvent event) {
+ return SDLActivity.handleJoystickMotionEvent(event);
+ }
+}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
