Android, Programming

No comments

Update (Oct 9th, 2012): The third message in this thread explains a simpler alternative to what’s explained below. I haven’t tried it myself but it seems cleaner and easier to implement, so you should probably try that one first.

Update 2 (Feb 21st, 2013): I’m now using the simplified method mentioned above in my engine. I copy the org.libsdl.app.SDLActivity into my project and inherit from it from a class with the package and class name that I want to use in my app.

The only change I had to do on the standard SDLActivity.java is to modify the static section of this file to load the rest of the remaining libraries I require, doing this in your inherited class doesn’t quite work depending on how each library depends on the others.

The method stated below is still useful if your app does something that the default SDLActivity can’t really handle, such as a live wallpaper.

The Android SDL backend works great, it comes with a full skeleton project that you can use to get up to speed quickly. There is however one minor problem, everything in said project is hardwired to use the “org.libsdl.app” app name, which is all fine and dandy until you want to make a real world app with your own name…and keep using the SDL source with as little modifications as possible to benefit from the latest and greatest modifications provided by the open source community.

So, it’s time to take out the glue gun and put it to good use. What I do is deploy a little piece of code that I call jni_glue.cpp and that goes into jni/src/jni_glue.cpp. In my case the app name is “com.mdqinc.dp”…

#include "jni.h"
#include "SDL_config.h"
#include "SDL_stdinc.h"

//static float fLastAccelerometer[3];
extern "C" {
    void Java_org_libsdl_app_SDLActivity_nativeRunAudioThread(JNIEnv* env, jclass cls);
    void Java_org_libsdl_app_SDLActivity_onNativeResize(
                                    JNIEnv* env, jclass jcls,
                                    jint width, jint height, jint format);
    void Java_org_libsdl_app_SDLActivity_onNativeKeyDown(
                                    JNIEnv* env, jclass jcls, jint keycode);
    void Java_org_libsdl_app_SDLActivity_onNativeKeyUp(
                                    JNIEnv* env, jclass jcls, jint keycode);
    void Java_org_libsdl_app_SDLActivity_onNativeTouch(
                                    JNIEnv* env, jclass jcls,
                                    jint touch_device_id_in, jint pointer_finger_id_in,
                                    jint action, jfloat x, jfloat y, jfloat p);
    void Java_org_libsdl_app_SDLActivity_onNativeAccel(
                                    JNIEnv* env, jclass jcls,
                                    jfloat x, jfloat y, jfloat z);
    void Java_org_libsdl_app_SDLActivity_nativeQuit(
                                    JNIEnv* env, jclass cls);
    void Java_org_libsdl_app_SDLActivity_nativeRunAudioThread(
                                    JNIEnv* env, jclass cls);
    void Java_org_libsdl_app_SDLActivity_nativeInit(JNIEnv* env, jclass cls, jobject obj);
};

// Resize
extern "C" void Java_com_mdqinc_dp_SDLActivity_onNativeResize(
                                    JNIEnv* env, jclass jcls,
                                    jint width, jint height, jint format)
{
    Java_org_libsdl_app_SDLActivity_onNativeResize(env, jcls, width, height, format);
}

// Keydown
extern "C" void Java_com_mdqinc_dp_SDLActivity_onNativeKeyDown(
                                    JNIEnv* env, jclass jcls, jint keycode)
{
    Java_org_libsdl_app_SDLActivity_onNativeKeyDown(env, jcls, keycode);
}

// Keyup
extern "C" void Java_com_mdqinc_dp_SDLActivity_onNativeKeyUp(
                                    JNIEnv* env, jclass jcls, jint keycode)
{
    Java_org_libsdl_app_SDLActivity_onNativeKeyUp(env, jcls, keycode);
}

// Touch
extern "C" void Java_com_mdqinc_dp_SDLActivity_onNativeTouch(
                                    JNIEnv* env, jclass jcls,
                                    jint touch_device_id_in, jint pointer_finger_id_in,
                                    jint action, jfloat x, jfloat y, jfloat p)
{
    Java_org_libsdl_app_SDLActivity_onNativeTouch(env, jcls, touch_device_id_in, pointer_finger_id_in, action, x, y, p);
}

// Accelerometer
extern "C" void Java_com_mdqinc_dp_SDLActivity_onNativeAccel(
                                    JNIEnv* env, jclass jcls,
                                    jfloat x, jfloat y, jfloat z)
{
     Java_org_libsdl_app_SDLActivity_onNativeAccel(env, jcls, x, y, z);
}

// Quit
extern "C" void Java_com_mdqinc_dp_SDLActivity_nativeQuit(
                                    JNIEnv* env, jclass cls)
{
    Java_org_libsdl_app_SDLActivity_nativeQuit(env, cls);
}

extern "C" void Java_com_mdqinc_dp_SDLActivity_nativeRunAudioThread(
                                    JNIEnv* env, jclass cls)
{
    Java_org_libsdl_app_SDLActivity_nativeRunAudioThread(env, cls);
}

extern "C" void Java_com_mdqinc_dp_SDLActivity_nativeInit(JNIEnv* env, jclass cls, jobject obj) {
    Java_org_libsdl_app_SDLActivity_nativeInit(env, cls, obj);
}

This glue code should be paired with a Java activity file based on the one SDL ships, but you need to modify the line that says “package org.libsdl.app;” for a name that suits your needs (and that matches the glue code function names posted above). The same modification needs to be applied to the AndroidManifest.xml.

Besides these changes you need to take care of a final minor adjustment, you have to place your activity file in the right location. It will no longer go in src/org/libsdl/app/SDLActivity.java but rather (for example, in my case) in src/org/mdqinc/dp/SDLActivity.java.

You can certainly achieve the same result by modifying the SDL source code directly, but you’ll find that updating it later is a hassle. This approach I’m describing stands separate from the actual SDL code, so you can update it without worries. The only thing you may want to keep an eye on is changes in the SDLActivity.java file, but in case that’s updated you only need to change a single line with the package name at the top.

Android, Programming

No comments

The SDL library supports the Android OS quite well. To get started, this guide is a great starting point.

I have a couple of points to add to that tutorial. I didn’t actually use the pre made SDL project, but rather took all the structure from SDL’s Mercurial repository. If you do that, the project will build, but you’ll have problems if you try to open a file via SDL (for example using IMG_Load). SDL seems to have good Asset Manager integration, but there’s a key piece of glue code missing, a static function called getContext that should be in the SDLActivity.java file. This is my fixed SDLActivity.java file, which also includes a workaround to disable OpenGL ES 2.x without recompiling SDL (it’s in the initEGL function).

package org.libsdl.app;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import javax.microedition.khronos.egl.*;

import android.app.*;
import android.content.*;
import android.view.*;
import android.os.*;
import android.util.Log;
import android.graphics.*;
import android.text.method.*;
import android.text.*;
import android.media.*;
import android.hardware.*;
import android.content.*;

import java.lang.*;

/**
    SDL Activity
*/
public class SDLActivity extends Activity {

    // Main components
    private static SDLActivity mSingleton;
    private static SDLSurface mSurface;

    // Audio
    private static Thread mAudioThread;
    private static AudioTrack mAudioTrack;

    // Load the .so
    static {
        System.loadLibrary("SDL");
        System.loadLibrary("SDL_image");
        System.loadLibrary("mikmod");
        System.loadLibrary("SDL_mixer");
        System.loadLibrary("SDL_ttf");
        System.loadLibrary("main");
    }

    // Setup
    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());
        setContentView(mSurface);
        SurfaceHolder holder = mSurface.getHolder();
        holder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
    }

    // Events
    protected void onPause() {
        //Log.v("SDL", "onPause()");
        super.onPause();
    }

    protected void onResume() {
        //Log.v("SDL", "onResume()");
        super.onResume();
    }

    // Messages from the SDLMain thread
    static int COMMAND_CHANGE_TITLE = 1;

    // Handler for the messages
    Handler commandHandler = new Handler() {
        public void handleMessage(Message msg) {
            if (msg.arg1 == COMMAND_CHANGE_TITLE) {
                setTitle((String)msg.obj);
            }
        }
    };

    // Send a message from the SDLMain thread
    void sendCommand(int command, Object data) {
        Message msg = commandHandler.obtainMessage();
        msg.arg1 = command;
        msg.obj = data;
        commandHandler.sendMessage(msg);
    }

    // C functions we call
    public static native void nativeInit();
    public static native void nativeQuit();
    public static native void onNativeResize(int x, int y, int format);
    public static native void onNativeKeyDown(int keycode);
    public static native void onNativeKeyUp(int keycode);
    public static native void onNativeTouch(int action, float x,
                                            float y, float p);
    public static native void onNativeAccel(float x, float y, float z);
    public static native void nativeRunAudioThread();

    // Java functions called from C

    public static boolean createGLContext(int majorVersion, int minorVersion) {
        return mSurface.initEGL(majorVersion, minorVersion);
    }

    public static void flipBuffers() {
        mSurface.flipEGL();
    }

    public static void setActivityTitle(String title) {
        // Called from SDLMain() thread and can't directly affect the view
        mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);
    }

    public static Context getContext() {
        return mSingleton;
    }

    // Audio
    private static Object buf;

    public static Object 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") + " " + ((float)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);

        mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate,
                channelConfig, audioFormat, desiredFrames * frameSize, AudioTrack.MODE_STREAM);

        audioStartThread();

        Log.v("SDL", "SDL audio: got " + ((mAudioTrack.getChannelCount() >= 2) ? "stereo" : "mono") + " " + ((mAudioTrack.getAudioFormat() == AudioFormat.ENCODING_PCM_16BIT) ? "16-bit" : "8-bit") + " " + ((float)mAudioTrack.getSampleRate() / 1000f) + "kHz, " + desiredFrames + " frames buffer");

        if (is16Bit) {
            buf = new short[desiredFrames * (isStereo ? 2 : 1)];
        } else {
            buf = new byte[desiredFrames * (isStereo ? 2 : 1)];
        }
        return buf;
    }

    public static void audioStartThread() {
        mAudioThread = new Thread(new Runnable() {
            public void run() {
                mAudioTrack.play();
                nativeRunAudioThread();
            }
        });

        // I'd take REALTIME if I could get it!
        mAudioThread.setPriority(Thread.MAX_PRIORITY);
        mAudioThread.start();
    }

    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(short)");
                return;
            }
        }
    }

    public static void audioQuit() {
        if (mAudioThread != null) {
            try {
                mAudioThread.join();
            } catch(Exception e) {
                Log.v("SDL", "Problem stopping audio thread: " + e);
            }
            mAudioThread = null;

            //Log.v("SDL", "Finished waiting for audio thread");
        }

        if (mAudioTrack != null) {
            mAudioTrack.stop();
            mAudioTrack = null;
        }
    }
}

/**
    Simple nativeInit() runnable
*/
class SDLMain implements Runnable {
    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  {

    // This is what SDL runs in. It invokes SDL_main(), eventually
    private Thread mSDLThread;

    // EGL private objects
    private EGLContext  mEGLContext;
    private EGLSurface  mEGLSurface;
    private EGLDisplay  mEGLDisplay;

    // Sensors
    private static SensorManager mSensorManager;

    // Startup
    public SDLSurface(Context context) {
        super(context);
        getHolder().addCallback(this);

        setFocusable(true);
        setFocusableInTouchMode(true);
        requestFocus();
        setOnKeyListener(this);
        setOnTouchListener(this);

        mSensorManager = (SensorManager)context.getSystemService("sensor");
    }

    // Called when we have a valid drawing surface
    public void surfaceCreated(SurfaceHolder holder) {
        //Log.v("SDL", "surfaceCreated()");

        enableSensor(Sensor.TYPE_ACCELEROMETER, true);
    }

    // Called when we lose the surface
    public void surfaceDestroyed(SurfaceHolder holder) {
        //Log.v("SDL", "surfaceDestroyed()");

        // Send a quit message to the application
        SDLActivity.nativeQuit();

        // Now wait for the SDL thread to quit
        if (mSDLThread != null) {
            try {
                mSDLThread.join();
            } catch(Exception e) {
                Log.v("SDL", "Problem stopping thread: " + e);
            }
            mSDLThread = null;

            //Log.v("SDL", "Finished waiting for SDL thread");
        }

        enableSensor(Sensor.TYPE_ACCELEROMETER, false);
    }

    // Called when the surface is resized
    public void surfaceChanged(SurfaceHolder holder,
                               int format, int width, int height) {
        //Log.v("SDL", "surfaceChanged()");

        int sdlFormat = 0x85151002; // 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 = 0x85421002; // SDL_PIXELFORMAT_RGBA4444
            break;
        case PixelFormat.RGBA_5551:
            Log.v("SDL", "pixel format RGBA_5551");
            sdlFormat = 0x85441002; // SDL_PIXELFORMAT_RGBA5551
            break;
        case PixelFormat.RGBA_8888:
            Log.v("SDL", "pixel format RGBA_8888");
            sdlFormat = 0x86462004; // SDL_PIXELFORMAT_RGBA8888
            break;
        case PixelFormat.RGBX_8888:
            Log.v("SDL", "pixel format RGBX_8888");
            sdlFormat = 0x86262004; // SDL_PIXELFORMAT_RGBX8888
            break;
        case PixelFormat.RGB_332:
            Log.v("SDL", "pixel format RGB_332");
            sdlFormat = 0x84110801; // SDL_PIXELFORMAT_RGB332
            break;
        case PixelFormat.RGB_565:
            Log.v("SDL", "pixel format RGB_565");
            sdlFormat = 0x85151002; // 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 = 0x86161804; // SDL_PIXELFORMAT_RGB888
            break;
        default:
            Log.v("SDL", "pixel format unknown " + format);
            break;
        }
        SDLActivity.onNativeResize(width, height, sdlFormat);

        // Now start up the C app thread
        if (mSDLThread == null) {
            mSDLThread = new Thread(new SDLMain(), "SDLThread");
            mSDLThread.start();
        }
    }

    // unused
    public void onDraw(Canvas canvas) {}

    // EGL functions
    public boolean initEGL(int majorVersion, int minorVersion) {
        // Temporarily disable OpenGL ES 2 as the SDL backend is buggy
        if (majorVersion != 1) return false;

        Log.v("SDL", "Starting up OpenGL ES " + majorVersion + "." + minorVersion);

        try {
            EGL10 egl = (EGL10)EGLContext.getEGL();

            EGLDisplay dpy = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

            int[] version = new int[2];
            egl.eglInitialize(dpy, version);

            int EGL_OPENGL_ES_BIT = 1;
            int EGL_OPENGL_ES2_BIT = 4;
            int renderableType = 0;
            if (majorVersion == 2) {
                renderableType = EGL_OPENGL_ES2_BIT;
            } else if (majorVersion == 1) {
                renderableType = EGL_OPENGL_ES_BIT;
            }
            int[] configSpec = {
                //EGL10.EGL_DEPTH_SIZE,   16,
                EGL10.EGL_RENDERABLE_TYPE, renderableType,
                EGL10.EGL_NONE
            };
            EGLConfig[] configs = new EGLConfig[1];
            int[] num_config = new int[1];
            if (!egl.eglChooseConfig(dpy, configSpec, configs, 1, num_config) || num_config[0] == 0) {
                Log.e("SDL", "No EGL config available");
                return false;
            }
            EGLConfig config = configs[0];

            EGLContext ctx = egl.eglCreateContext(dpy, config, EGL10.EGL_NO_CONTEXT, null);
            if (ctx == EGL10.EGL_NO_CONTEXT) {
                Log.e("SDL", "Couldn't create context");
                return false;
            }

            EGLSurface surface = egl.eglCreateWindowSurface(dpy, config, this, null);
            if (surface == EGL10.EGL_NO_SURFACE) {
                Log.e("SDL", "Couldn't create surface");
                return false;
            }

            if (!egl.eglMakeCurrent(dpy, surface, surface, ctx)) {
                Log.e("SDL", "Couldn't make context current");
                return false;
            }

            mEGLContext = ctx;
            mEGLDisplay = dpy;
            mEGLSurface = surface;

        } catch(Exception e) {
            Log.v("SDL", e + "");
            for (StackTraceElement s : e.getStackTrace()) {
                Log.v("SDL", s.toString());
            }
        }

        return true;
    }

    // EGL buffer flip
    public void flipEGL() {
        try {
            EGL10 egl = (EGL10)EGLContext.getEGL();

            egl.eglWaitNative(EGL10.EGL_NATIVE_RENDERABLE, null);

            // drawing here

            egl.eglWaitGL();

            egl.eglSwapBuffers(mEGLDisplay, mEGLSurface);

        } catch(Exception e) {
            Log.v("SDL", "flipEGL(): " + e);
            for (StackTraceElement s : e.getStackTrace()) {
                Log.v("SDL", s.toString());
            }
        }
    }

    // Key events
    public boolean onKey(View  v, int keyCode, KeyEvent event) {

        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
    public boolean onTouch(View v, MotionEvent event) {

        int action = event.getAction();
        float x = event.getX();
        float y = event.getY();
        float p = event.getPressure();

        // TODO: Anything else we need to pass?
        SDLActivity.onNativeTouch(action, x, y, p);
        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));
        }
    }

    public void onAccuracyChanged(Sensor sensor, int accuracy) {
        // TODO
    }

    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
            SDLActivity.onNativeAccel(event.values[0],
                                      event.values[1],
                                      event.values[2]);
        }
    }

}

The other issue I had happened when loading a bunch of files from native code (via de Android NDK). It so happens that there’s object reference stack that the JNI mechanism relies on, and while it gets properly handled by the Java VM internals, if your native code opens a series of files without returning to the Java VM, you run the risk of going over the 512 object reference’s limit and get an exception.

Luckily the solution to this problem is quite simple. In SDL_android.cpp, look for the function: static int Android_JNI_FileOpen(SDL_RWops* ctx)

At the beginning add

mEnv->PushLocalFrame(10);

and before every return expression:

mEnv->PopLocalFrame(NULL);

This will take care of freeing the object references that are no longer in use after the function returns, and then you can load as many images as you need in native code without hitting that limit.

Android, Programming

No comments

So, I got one of those wonderful Asus Transformers…I had to see if I could make something for it. And so I did! Having some Android experience from the 1.x days, I started looking around for a quick way to get something done, and it was then that I found the amazing AndEngine and its Live Wallpaper Extension . While the documentation is sparse (specially when it comes down to the newer changes in the engine), there’s a big enough community that if you search around in the forums and over the net you will find what you are looking for. Getting it all in place turned out to be quite simple once I figured out what changes needed to be done to adapt the provided example to the latest modifications done to the engine.

All in all, it’s pretty simple:

(LiveWallpaperService.java)

package org.anddev.wallpaper.live.donprimerizowp;

import java.io.File;
import java.util.Random;

import net.rbgrn.opengl.GLWallpaperService.GLEngine;

import org.anddev.andengine.engine.camera.Camera;
import org.anddev.andengine.engine.handler.timer.ITimerCallback;
import org.anddev.andengine.engine.handler.timer.TimerHandler;
import org.anddev.andengine.engine.options.EngineOptions;
import org.anddev.andengine.engine.options.EngineOptions.ScreenOrientation;
import org.anddev.andengine.engine.options.resolutionpolicy.FillResolutionPolicy;
import org.anddev.andengine.entity.particle.ParticleSystem;
import org.anddev.andengine.entity.particle.modifier.AlphaModifier;
import org.anddev.andengine.entity.particle.modifier.ExpireModifier;
import org.anddev.andengine.entity.scene.Scene;
import org.anddev.andengine.entity.sprite.AnimatedSprite.IAnimationListener;
import org.anddev.andengine.entity.sprite.Sprite;
import org.anddev.andengine.entity.sprite.AnimatedSprite;
import org.anddev.andengine.extension.ui.livewallpaper.BaseLiveWallpaperService;
import org.anddev.andengine.opengl.texture.Texture;
import org.anddev.andengine.opengl.texture.TextureOptions;
import org.anddev.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlas;
import org.anddev.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlasTextureRegionFactory;
import org.anddev.andengine.opengl.texture.region.TextureRegion;
import org.anddev.andengine.opengl.texture.region.TextureRegionFactory;
import org.anddev.andengine.opengl.texture.region.TiledTextureRegion;
import org.anddev.andengine.opengl.view.GLSurfaceView.Renderer;
import org.anddev.andengine.opengl.view.RenderSurfaceView;
import org.anddev.andengine.sensor.accelerometer.AccelerometerData;
import org.anddev.andengine.sensor.accelerometer.IAccelerometerListener;
import org.anddev.andengine.sensor.orientation.IOrientationListener;
import org.anddev.andengine.sensor.orientation.OrientationSensorOptions;

import android.app.WallpaperManager;
import android.content.res.Configuration;
import android.os.Bundle;

public class LiveWallpaperService extends BaseLiveWallpaperService implements IAccelerometerListener, IOffsetsChanged {

    protected class MyBaseWallpaperGLEngine extends GLEngine {
        // ===========================================================
        // Fields
        // ===========================================================

        private Renderer mRenderer;

        private IOffsetsChanged mOffsetsChangedListener = null;

        // ===========================================================
        // Constructors
        // ===========================================================

        public MyBaseWallpaperGLEngine(IOffsetsChanged pOffsetsChangedListener) {
                this.setEGLConfigChooser(false);
                this.mRenderer = new RenderSurfaceView.Renderer(LiveWallpaperService.this.mEngine);
                this.setRenderer(this.mRenderer);
                this.setRenderMode(RENDERMODE_CONTINUOUSLY);
                this.mOffsetsChangedListener = pOffsetsChangedListener;
        }

        // ===========================================================
        // Methods for/from SuperClass/Interfaces
        // ===========================================================

        @Override
        public Bundle onCommand(final String pAction, final int pX, final int pY, final int pZ, final Bundle pExtras, final boolean pResultRequested) {
                if(pAction.equals(WallpaperManager.COMMAND_TAP)) {
                    LiveWallpaperService.this.onTap(pX, pY);
                } else if (pAction.equals(WallpaperManager.COMMAND_DROP)) {
                    LiveWallpaperService.this.onDrop(pX, pY);
                }

                return super.onCommand(pAction, pX, pY, pZ, pExtras, pResultRequested);
        }

        @Override
        public void onResume() {
                super.onResume();
                LiveWallpaperService.this.getEngine().onResume();
                LiveWallpaperService.this.onResume();
        }

        @Override
        public void onPause() {
                super.onPause();
                LiveWallpaperService.this.getEngine().onPause();
                LiveWallpaperService.this.onPause();
        }

        @Override
        public void onDestroy() {
                super.onDestroy();
                if (this.mRenderer != null) {
                        // mRenderer.release();
                }
                this.mRenderer = null;
        }

        @Override
        public void onOffsetsChanged(float xOffset, float yOffset,
                        float xOffsetStep, float yOffsetStep, int xPixelOffset,
                        int yPixelOffset) {
                // TODO Auto-generated method stub
                super.onOffsetsChanged(xOffset, yOffset, xOffsetStep, yOffsetStep,
                                xPixelOffset, yPixelOffset);

                if(this.mOffsetsChangedListener != null)
                        this.mOffsetsChangedListener.offsetsChanged(xOffset, yOffset, xOffsetStep, yOffsetStep, xPixelOffset, yPixelOffset);

        }

    }

    // ===========================================================
    // Constants
    // ===========================================================

    private static final int CAMERA_WIDTH = 1280;
    private static final int CAMERA_HEIGHT = 800;

    // ===========================================================
    // Fields
    // ===========================================================

    private BitmapTextureAtlas mTexture;
    private BitmapTextureAtlas mTexture2;
    private BitmapTextureAtlas mTexture3;
    private BitmapTextureAtlas mTexture4;
    private BitmapTextureAtlas mTexture5;

    private TextureRegion mPulperia;
    private TextureRegion mCarreta;
    private TiledTextureRegion mPibito;
    private TiledTextureRegion mMosca;
    private TiledTextureRegion mDPSeq1;
    private TiledTextureRegion mDPSeq2;

    private Sprite mPulperiaSprite;
    private AnimatedSprite mPibitoSprite;
    private Sprite mCarretaSprite;
    private AnimatedSprite mMoscaSprite;
    private AnimatedSprite mDP1Sprite;
    private AnimatedSprite mDP2Sprite;

    private ScreenOrientation mScreenOrientation;
    private Camera mCamera;
    private Scene mScene;

    private IAnimationListener mDP1ListenerF, mDP1ListenerB, mDP2Listener; 

    // ===========================================================
    // Constructors
    // ===========================================================

    // ===========================================================
    // Getter & Setter
    // ===========================================================

    // ===========================================================
    // Methods for/from SuperClass/Interfaces
    // ===========================================================

    @Override
    public org.anddev.andengine.engine.Engine onLoadEngine() {
        mCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
        return new org.anddev.andengine.engine.Engine(new EngineOptions(true, this.mScreenOrientation, new FillResolutionPolicy(), mCamera));
    }

    @Override
    public void onLoadResources() {
        this.getEngine().disableOrientationSensor(this);
        this.mTexture = new BitmapTextureAtlas(2048, 2048, TextureOptions.BILINEAR);
        this.mTexture2 = new BitmapTextureAtlas(2048, 2048, TextureOptions.BILINEAR);
        this.mTexture3 = new BitmapTextureAtlas(2048, 2048, TextureOptions.BILINEAR);
        this.mTexture4 = new BitmapTextureAtlas(1024, 1024, TextureOptions.BILINEAR);
        this.mTexture5 = new BitmapTextureAtlas(1024, 2048, TextureOptions.BILINEAR);

        /* Creates the needed texture-regions on the texture. */
        this.mPulperia = BitmapTextureAtlasTextureRegionFactory.createFromAsset(this.mTexture, this, "gfx/pulperia.png", 0, 0); // 1280x800
        this.mCarreta = BitmapTextureAtlasTextureRegionFactory.createFromAsset(this.mTexture, this, "gfx/carreta.png", 0, 801); // 263x386
        this.mPibito = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(this.mTexture2, this, "gfx/pibito.png", 0, 0, 6, 6); // 2048x1980
        this.mMosca = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(this.mTexture3, this, "gfx/mosca.png", 0, 0, 11, 5); // 1980x1070
        this.mDPSeq1 = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(this.mTexture4, this, "gfx/dpseq1.png", 0, 0, 7, 4); // 1022x1000
        this.mDPSeq2 = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(this.mTexture5, this, "gfx/dpseq2.png", 0, 0, 10, 7); // 990x1393

        this.getEngine().getTextureManager().loadTexture(this.mTexture);
        this.getEngine().getTextureManager().loadTexture(this.mTexture2);
        this.getEngine().getTextureManager().loadTexture(this.mTexture3);
        this.getEngine().getTextureManager().loadTexture(this.mTexture4);
        this.getEngine().getTextureManager().loadTexture(this.mTexture5);
        this.enableAccelerometerSensor(this);
    }

    @Override
    public Scene onLoadScene() {
        mScene = new Scene();
        mPulperiaSprite = new Sprite(0, 0, this.mPulperia);
        mScene.attachChild(mPulperiaSprite);
        mPibitoSprite = new AnimatedSprite(88, 200, this.mPibito);
        mPibitoSprite.setScale((float) 1.6);

        mMoscaSprite = new AnimatedSprite(700, 550, this.mMosca);

        mDP1Sprite = new AnimatedSprite(530, 260, this.mDPSeq1);
        mDP2Sprite = new AnimatedSprite(530, 310, this.mDPSeq2);

        mDP1ListenerF = new IAnimationListener () {
            @Override
            public void onAnimationEnd(final AnimatedSprite pAnimatedSprite) {
                runOnUpdateThread(new Runnable() {
                    @Override
                    public void run() {
                        // Stop the animation, play it backwards
                        mDP1Sprite.stopAnimation();
                        mDP1Sprite.animate(
                                new long[]
                                {100,100,100,100,100,100,100,
                                 100,100,100,100,100,100,100,
                                 100,100,100,100,100,100,100,
                                 100,100,100,100,100,100,100,},
                                new int[] {27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0}, 0, mDP1ListenerB);

                    }
                });
           }
        };

        mDP1ListenerB = new IAnimationListener () {
            @Override
            public void onAnimationEnd(final AnimatedSprite pAnimatedSprite) {
                runOnUpdateThread(new Runnable() {
                    @Override
                    public void run() {
                        mScene.detachChild(mDP1Sprite);
                        mDP1Sprite.stopAnimation();
                        mDP2Sprite.animate(100, false, mDP2Listener);
                        mScene.attachChild(mDP2Sprite);

                    }
                });
           }
        };

        mDP2Listener = new IAnimationListener () {
            @Override
            public void onAnimationEnd(final AnimatedSprite pAnimatedSprite) {
                runOnUpdateThread(new Runnable() {
                    @Override
                    public void run() {
                        mScene.detachChild(mDP2Sprite);
                        mDP2Sprite.stopAnimation();
                        mDP1Sprite.animate(100, false, mDP1ListenerF);
                        mScene.attachChild(mDP1Sprite);
                    }
                });
           }
        };

        mDP1Sprite.animate(100, false, mDP1ListenerF);
        mScene.attachChild(mDP1Sprite);

        mCarretaSprite = new Sprite(-30, 414, this.mCarreta);
        mScene.attachChild(mCarretaSprite);

        //this.mVelocityInitializer = new VelocityInitializer(-20, 20, -100, -120);

//      this.getEngine().registerPreFrameHandler(new FPSCounter());

        mScene.registerUpdateHandler(new TimerHandler(10f, true, new ITimerCallback() {
            Random randomSrc = new Random();
            @Override
            public void onTimePassed(final TimerHandler pTimerHandler) {
                try {

                    int x = randomSrc.nextInt(10);

                    //Pibito runs 3 out of 10 times
                    if (x5 && ! mMoscaSprite.isAnimationRunning()) {
                        mScene.attachChild(mMoscaSprite);
                        mMoscaSprite.animate(100, false, new IAnimationListener () {
                            @Override
                            public void onAnimationEnd(final AnimatedSprite pAnimatedSprite) {
                                runOnUpdateThread(new Runnable() {
                                    @Override
                                    public void run() {
                                        mScene.detachChild(mMoscaSprite);
                                    }
                                });
                           }
                        });
                    }

                } catch (Exception e) {}
            }
        })); 

        return mScene;
    }

    @Override
    public void onLoadComplete() {

    }

    @Override
    public Engine onCreateEngine() {
            // TODO Auto-generated method stub
            return new MyBaseWallpaperGLEngine(this);
    }

    @Override
    public void offsetsChanged(float xOffset, float yOffset, float xOffsetStep, float yOffsetStep, int xPixelOffset, int yPixelOffset) {
           /* if(mCamera != null){
                // Emulator has 3 screens
                mCamera.setCenter( ((960 * xOffset ) - 240) , mCamera.getCenterY() );
                / *formel                mCamera.setCenter(( (Camera-WIDTH * (screensCount-1)) * xOffset ) - (Camera-WIDTH / 2) ,mCamera.getCenterY() ); * /
            }*/

        mCarretaSprite.setPosition(-xOffset*80, 414);
        mMoscaSprite.setPosition(-xOffset*300+700, 550);
    }

    @Override
    public void onAccelerometerChanged(final AccelerometerData pAccelerometerData) {
    /*  final float minVelocityX = (pAccelerometerData.getX() + 2) * 5;
        final float maxVelocityX = (pAccelerometerData.getX() - 2) * 5;

        final float minVelocityY = (pAccelerometerData.getY() - 8) * 10;
        final float maxVelocityY = (pAccelerometerData.getY() - 10) * 10;
        this.mVelocityInitializer.setVelocity(minVelocityX, maxVelocityX, minVelocityY, maxVelocityY);*/
    }

    @Override
    public void onUnloadResources() {
        // TODO Auto-generated method stub

    }

    @Override
    public void onPauseGame() {
        super.onPause();
        LiveWallpaperService.this.getEngine().onPause();
        LiveWallpaperService.this.onPause();
    }

    @Override
    public void onResumeGame() {
        super.onResume();
        LiveWallpaperService.this.getEngine().onResume();
        LiveWallpaperService.this.onResume();

    }

    @Override
    public void onConfigurationChanged (Configuration newConfig){
                    if(newConfig.orientation == Configuration.ORIENTATION_PORTRAIT)
                    {
                            mScene.setScaleX(1280.0f/800.0f);
                            mScene.setScaleY(1.0f);
                    }
                    else if(newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE)
                    {
                        mScene.setScale(1);
                    }

    }

    // ===========================================================
    // Methods
    // ===========================================================

    // ===========================================================
    // Inner and Anonymous Classes
    // ===========================================================

}

(IOffsetsChanged.java)

package org.anddev.wallpaper.live.donprimerizowp;
public interface IOffsetsChanged{

    public void offsetsChanged(float xOffset, float yOffset,
                    float xOffsetStep, float yOffsetStep, int xPixelOffset,
                    int yPixelOffset);

}

I’m making the full project available here . The Live Wallpaper is available from the Android Market.

The license for the code is “do as you please”, for the art it’s “All rights reserved under Creative Commons License”. All art is from the defunct (oh really? I hear him breathing!) “Epopeya de Don Primerizo Lata” and was created by the great Leonardo Falaschini, you should check his stuff at liondart.com