src/com/android/wallpaper/module/NoBackupImageWallpaper.java

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.wallpaper.module;

import static javax.microedition.khronos.egl.EGL10.EGL_NO_CONTEXT;
import static javax.microedition.khronos.egl.EGL10.EGL_NO_SURFACE;

import android.annotation.SuppressLint;
import android.app.WallpaperColors;
import android.app.WallpaperManager;
import android.content.BroadcastReceiver;
import android.content.ComponentCallbacks2;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Point;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.opengl.GLES20;
import android.opengl.GLUtils;
import android.os.AsyncTask;
import android.os.Build.VERSION;
import android.os.Build.VERSION_CODES;
import android.os.Handler;
import android.renderscript.Matrix4f;
import android.service.wallpaper.WallpaperService;
import android.util.Log;
import android.view.Display;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.WindowManager;

import com.android.wallpaper.util.ScreenSizeCalculator;

import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;

import androidx.annotation.RequiresApi;

/**
 * Live wallpaper service which simply renders a wallpaper from internal storage. Designed as a
 * workaround to WallpaperManager not having an allowBackup=false option on pre-N builds of Android.
 * <p>
 * Adapted from {@code com.android.systemui.ImageWallpaper}.
 */
@SuppressLint("ServiceCast")
public class NoBackupImageWallpaper extends WallpaperService {

    public static final String ACTION_ROTATING_WALLPAPER_CHANGED =
            ".ACTION_ROTATING_WALLPAPER_CHANGED";
    public static final String PERMISSION_NOTIFY_ROTATING_WALLPAPER_CHANGED =
            ".NOTIFY_ROTATING_WALLPAPER_CHANGED";
    public static final String PREVIEW_WALLPAPER_FILE_PATH = "preview_wallpaper.jpg";
    public static final String ROTATING_WALLPAPER_FILE_PATH = "rotating_wallpaper.jpg";

    private static final String TAG = "NoBackupImageWallpaper";
    private static final String GL_LOG_TAG = "ImageWallpaperGL";
    private static final boolean DEBUG = false;
    private static final boolean FIXED_SIZED_SURFACE = false;

    private final Handler mHandler = new Handler();

    private int mOpenGlContextCounter;
    private WallpaperManager mWallpaperManager;
    private DrawableEngine mEngine;
    private boolean mIsHardwareAccelerated;

    @Override
    public void onCreate() {
        super.onCreate();

        mOpenGlContextCounter = 0;
        mWallpaperManager = (WallpaperManager) getSystemService(WALLPAPER_SERVICE);

        // By default, use OpenGL for drawing the static wallpaper image.
        mIsHardwareAccelerated = true;
    }

    @Override
    public void onTrimMemory(int level) {
        if (mEngine != null) {
            mEngine.trimMemory(level);
        }
    }

    @Override
    public Engine onCreateEngine() {
        mEngine = new DrawableEngine();
        return mEngine;
    }

    private class DrawableEngine extends Engine {
        static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
        static final int EGL_OPENGL_ES2_BIT = 4;
        private static final String S_SIMPLE_VS =
                "attribute vec4 position;\n"
                        + "attribute vec2 texCoords;\n"
                        + "varying vec2 outTexCoords;\n"
                        + "uniform mat4 projection;\n"
                        + "\nvoid main(void) {\n"
                        + "    outTexCoords = texCoords;\n"
                        + "    gl_Position = projection * position;\n"
                        + "}\n\n";
        private static final String S_SIMPLE_FS =
                "precision mediump float;\n\n"
                        + "varying vec2 outTexCoords;\n"
                        + "uniform sampler2D texture;\n"
                        + "\nvoid main(void) {\n"
                        + "    gl_FragColor = texture2D(texture, outTexCoords);\n"
                        + "}\n\n";
        private static final int FLOAT_SIZE_BYTES = 4;
        private static final int TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES;
        private static final int TRIANGLE_VERTICES_DATA_POS_OFFSET = 0;
        private static final int TRIANGLE_VERTICES_DATA_UV_OFFSET = 3;
        Bitmap mBackground;
        WallpaperColors mCachedWallpaperColors;
        int mBackgroundWidth = -1, mBackgroundHeight = -1;
        int mLastSurfaceWidth = -1, mLastSurfaceHeight = -1;
        int mLastRotation = -1;
        float mXOffset = 0.5f;
        float mYOffset = 0.5f;
        float mScale = 1f;
        boolean mVisible = true;
        boolean mOffsetsChanged;
        int mLastXTranslation;
        int mLastYTranslation;
        private Display mDefaultDisplay;
        private EGL10 mEgl;
        private EGLDisplay mEglDisplay;
        private EGLConfig mEglConfig;
        private EGLContext mEglContext;
        private EGLSurface mEglSurface;
        private int mTexture;
        private int mProgram;
        private boolean mIsOpenGlTextureLoaded;
        private int mRotationAtLastSurfaceSizeUpdate = -1;
        private int mDisplayWidthAtLastSurfaceSizeUpdate = -1;
        private int mDisplayHeightAtLastSurfaceSizeUpdate = -1;

        private int mLastRequestedWidth = -1;
        private int mLastRequestedHeight = -1;
        private AsyncTask<Void, Void, Bitmap> mLoader;
        private boolean mNeedsDrawAfterLoadingWallpaper;
        private boolean mSurfaceValid;

        private BroadcastReceiver mReceiver;

        public DrawableEngine() {
            super();
        }

        public void trimMemory(int level) {
            if (level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW
                    && mBackground != null) {
                if (DEBUG) {
                    Log.d(TAG, "trimMemory");
                }
                mBackground.recycle();
                mBackground = null;
                mBackgroundWidth = -1;
                mBackgroundHeight = -1;
            }
        }

        @Override
        public void onCreate(SurfaceHolder surfaceHolder) {
            if (DEBUG) {
                Log.d(TAG, "onCreate");
            }

            super.onCreate(surfaceHolder);

            mIsOpenGlTextureLoaded = false;

            mDefaultDisplay = ((WindowManager) getSystemService(Context.WINDOW_SERVICE))
                    .getDefaultDisplay();

            updateSurfaceSize(surfaceHolder, mDefaultDisplay, false /* forDraw */);

            // Enable offset notifications to pan wallpaper for parallax effect.
            setOffsetNotificationsEnabled(true);

            // If not a preview, then register a local broadcast receiver for listening to changes in the
            // rotating wallpaper file.
            if (!isPreview()) {
                IntentFilter filter = new IntentFilter();
                filter.addAction(getPackageName() + ACTION_ROTATING_WALLPAPER_CHANGED);

                mReceiver = new BroadcastReceiver() {
                    @Override
                    public void onReceive(Context context, Intent intent) {
                        if (DEBUG) {
                            Log.i(TAG, "Broadcast received with intent: " + intent);
                        }

                        String action = intent.getAction();
                        if (action.equals(getPackageName() + ACTION_ROTATING_WALLPAPER_CHANGED)) {
                            DrawableEngine.this.invalidateAndRedrawWallpaper();
                        }
                    }
                };

                registerReceiver(mReceiver, filter, getPackageName()
                        + PERMISSION_NOTIFY_ROTATING_WALLPAPER_CHANGED, null /* handler */);
            }
        }

        @Override
        public void onDestroy() {
            super.onDestroy();
            mBackground = null;
            mWallpaperManager.forgetLoadedWallpaper();

            if (!isPreview() && mReceiver != null) {
                unregisterReceiver(mReceiver);
            }
        }

        boolean updateSurfaceSize(SurfaceHolder surfaceHolder, Display display, boolean forDraw) {
            boolean hasWallpaper = true;
            Point displaySize = ScreenSizeCalculator.getInstance().getScreenSize(display);

            // Load background image dimensions, if we haven't saved them yet
            if (mBackgroundWidth <= 0 || mBackgroundHeight <= 0) {
                // Need to load the image to get dimensions
                loadWallpaper(forDraw);
                if (DEBUG) {
                    Log.d(TAG, "Reloading, redoing updateSurfaceSize later.");
                }
                hasWallpaper = false;
            }

            // Force the wallpaper to cover the screen in both dimensions
            int surfaceWidth = Math.max(displaySize.x, mBackgroundWidth);
            int surfaceHeight = Math.max(displaySize.y, mBackgroundHeight);

            if (FIXED_SIZED_SURFACE) {
                // Used a fixed size surface, because we are special.  We can do
                // this because we know the current design of window animations doesn't
                // cause this to break.
                surfaceHolder.setFixedSize(surfaceWidth, surfaceHeight);
                mLastRequestedWidth = surfaceWidth;
                mLastRequestedHeight = surfaceHeight;
            } else {
                surfaceHolder.setSizeFromLayout();
            }
            return hasWallpaper;
        }

        @Override
        public void onVisibilityChanged(boolean visible) {
            if (DEBUG) {
                Log.d(TAG, "onVisibilityChanged: mVisible, visible=" + mVisible + ", " + visible);
            }

            if (mVisible != visible) {
                if (DEBUG) {
                    Log.d(TAG, "Visibility changed to visible=" + visible);
                }
                mVisible = visible;
                drawFrame(false /* forceRedraw */);
            }
        }

        @Override
        public void onTouchEvent(MotionEvent event) {
            super.onTouchEvent(event);
        }

        @Override
        public void onOffsetsChanged(float xOffset, float yOffset,
                                     float xOffsetStep, float yOffsetStep,
                                     int xPixels, int yPixels) {
            if (DEBUG) {
                Log.d(TAG, "onOffsetsChanged: xOffset=" + xOffset + ", yOffset=" + yOffset
                        + ", xOffsetStep=" + xOffsetStep + ", yOffsetStep=" + yOffsetStep
                        + ", xPixels=" + xPixels + ", yPixels=" + yPixels);
            }

            if (mXOffset != xOffset || mYOffset != yOffset) {
                if (DEBUG) {
                    Log.d(TAG, "Offsets changed to (" + xOffset + "," + yOffset + ").");
                }
                mXOffset = xOffset;
                mYOffset = yOffset;
                mOffsetsChanged = true;
            }
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    drawFrame(false /* forceRedraw */);
                }
            });
        }

        @Override
        public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) {
            if (DEBUG) {
                Log.d(TAG, "onSurfaceChanged: width=" + width + ", height=" + height);
            }

            super.onSurfaceChanged(holder, format, width, height);

            // Retrieve buffer in new size.
            if (mEgl != null) {
                mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);
            }
            drawFrame(false /* forceRedraw */);
        }

        @Override
        public void onSurfaceDestroyed(SurfaceHolder holder) {
            super.onSurfaceDestroyed(holder);
            if (DEBUG) {
                Log.d(TAG, "onSurfaceDestroyed");
            }
            mLastSurfaceWidth = mLastSurfaceHeight = -1;
            mSurfaceValid = false;

            if (mIsHardwareAccelerated) {
                finishGL(mTexture, mProgram);
            }
        }

        @Override
        public void onSurfaceCreated(SurfaceHolder holder) {
            super.onSurfaceCreated(holder);
            if (DEBUG) {
                Log.d(TAG, "onSurfaceCreated");
            }
            mLastSurfaceWidth = mLastSurfaceHeight = -1;
            mSurfaceValid = true;

            if (mIsHardwareAccelerated) {
                if (!initGL(holder)) {
                    // Fall back to canvas drawing if initializing OpenGL failed.
                    mIsHardwareAccelerated = false;
                    mEgl = null;
                }
            }
        }

        @Override
        public void onSurfaceRedrawNeeded(SurfaceHolder holder) {
            if (DEBUG) {
                Log.d(TAG, "onSurfaceRedrawNeeded");
            }
            super.onSurfaceRedrawNeeded(holder);

            drawFrame(true /* forceRedraw */);
        }

        @RequiresApi(VERSION_CODES.O_MR1)
        @Override
        public WallpaperColors onComputeColors() {
            // It's OK to return null here.
            return mCachedWallpaperColors;
        }

        /**
         * Invalidates the currently-drawn wallpaper image, causing the engine to reload the image from
         * disk and draw the new wallpaper image.
         */
        public void invalidateAndRedrawWallpaper() {
            // If a wallpaper load was already in flight, cancel it and restart a load in order to decode
            // the new image.
            if (mLoader != null) {
                mLoader.cancel(true /* mayInterruptIfRunning */);
                mLoader = null;
            }

            loadWallpaper(true /* needsDraw */);
        }

        void drawFrame(boolean forceRedraw) {
            if (!mSurfaceValid) {
                return;
            }

            Point screenSize = ScreenSizeCalculator.getInstance().getScreenSize(mDefaultDisplay);
            int newRotation = mDefaultDisplay.getRotation();

            // Sometimes a wallpaper is not large enough to cover the screen in one dimension.
            // Call updateSurfaceSize -- it will only actually do the update if the dimensions
            // should change
            if (newRotation != mLastRotation) {
                // Update surface size (if necessary)
                if (!updateSurfaceSize(getSurfaceHolder(), mDefaultDisplay, true /* forDraw */)) {
                    return;
                }
                mRotationAtLastSurfaceSizeUpdate = newRotation;
                mDisplayWidthAtLastSurfaceSizeUpdate = screenSize.x;
                mDisplayHeightAtLastSurfaceSizeUpdate = screenSize.y;
            }
            SurfaceHolder sh = getSurfaceHolder();
            final Rect frame = sh.getSurfaceFrame();
            final int dw = frame.width();
            final int dh = frame.height();
            boolean surfaceDimensionsChanged = dw != mLastSurfaceWidth
                    || dh != mLastSurfaceHeight;

            boolean redrawNeeded = surfaceDimensionsChanged || newRotation != mLastRotation
                    || forceRedraw;
            if (!redrawNeeded && !mOffsetsChanged) {
                if (DEBUG) {
                    Log.d(TAG, "Suppressed drawFrame since redraw is not needed "
                            + "and offsets have not changed.");
                }
                return;
            }
            mLastRotation = newRotation;

            // Load bitmap if its null and we're not using hardware acceleration.
            if ((mIsHardwareAccelerated && !mIsOpenGlTextureLoaded) // Using OpenGL but texture not loaded
                    || (!mIsHardwareAccelerated && mBackground == null)) { // Draw with Canvas but no bitmap
                if (DEBUG) {
                    Log.d(TAG, "Reloading bitmap: mBackground, bgw, bgh, dw, dh = "
                            + mBackground + ", " + ((mBackground == null) ? 0 : mBackground.getWidth()) + ", "
                            + ((mBackground == null) ? 0 : mBackground.getHeight()) + ", " + dw + ", " + dh);
                }
                loadWallpaper(true /* needDraw */);
                if (DEBUG) {
                    Log.d(TAG, "Reloading, resuming draw later");
                }
                return;
            }

            // Center the scaled image
            mScale = Math.max(1f, Math.max(dw / (float) mBackgroundWidth,
                    dh / (float) mBackgroundHeight));
            final int availw = dw - (int) (mBackgroundWidth * mScale);
            final int availh = dh - (int) (mBackgroundHeight * mScale);
            int xPixels = availw / 2;
            int yPixels = availh / 2;

            // Adjust the image for xOffset/yOffset values. If window manager is handling offsets,
            // mXOffset and mYOffset are set to 0.5f by default and therefore xPixels and yPixels
            // will remain unchanged
            final int availwUnscaled = dw - mBackgroundWidth;
            final int availhUnscaled = dh - mBackgroundHeight;
            if (availwUnscaled < 0) {
                xPixels += (int) (availwUnscaled * (mXOffset - .5f) + .5f);
            }
            if (availhUnscaled < 0) {
                yPixels += (int) (availhUnscaled * (mYOffset - .5f) + .5f);
            }

            mOffsetsChanged = false;
            if (surfaceDimensionsChanged) {
                mLastSurfaceWidth = dw;
                mLastSurfaceHeight = dh;
            }
            if (!redrawNeeded && xPixels == mLastXTranslation && yPixels == mLastYTranslation) {
                if (DEBUG) {
                    Log.d(TAG, "Suppressed drawFrame since the image has not "
                            + "actually moved an integral number of pixels.");
                }
                return;
            }
            mLastXTranslation = xPixels;
            mLastYTranslation = yPixels;

            if (DEBUG) {
                Log.d(TAG, "Redrawing wallpaper");
            }

            if (mIsHardwareAccelerated) {
                if (!drawWallpaperWithOpenGL(sh, availw, availh, xPixels, yPixels)) {
                    drawWallpaperWithCanvas(sh, availw, availh, xPixels, yPixels);
                } else {
                    // If OpenGL drawing was successful, then we can safely discard a reference to the
                    // wallpaper bitmap to save memory (since a copy has already been loaded into an OpenGL
                    // texture).
                    mBackground = null;
                }
            } else {
                drawWallpaperWithCanvas(sh, availw, availh, xPixels, yPixels);
            }
        }

        /**
         * Loads the wallpaper on background thread and schedules updating the surface frame,
         * and if {@param needsDraw} is set also draws a frame.
         * <p>
         * If loading is already in-flight, subsequent loads are ignored (but needDraw is or-ed to
         * the active request).
         * <p>
         * If {@param needsReset} is set also clears the cache in WallpaperManager first.
         */
        private void loadWallpaper(boolean needsDraw) {
            mNeedsDrawAfterLoadingWallpaper |= needsDraw;
            if (mLoader != null) {
                if (DEBUG) {
                    Log.d(TAG, "Skipping loadWallpaper, already in flight ");
                }
                return;
            }
            mLoader = new AsyncTask<Void, Void, Bitmap>() {
                @Override
                protected Bitmap doInBackground(Void... params) {
                    Throwable exception = null;
                    try {
                        // Decode bitmap of rotating image wallpaper.
                        String wallpaperFilePath = isPreview()
                                ? PREVIEW_WALLPAPER_FILE_PATH : ROTATING_WALLPAPER_FILE_PATH;
                        Context context = isPreview() ? getApplicationContext()
                                : getApplicationContext().createDeviceProtectedStorageContext();
                        FileInputStream fileInputStream = context.openFileInput(wallpaperFilePath);
                        Bitmap bitmap = BitmapFactory.decodeStream(fileInputStream);
                        fileInputStream.close();
                        return bitmap;
                    } catch (RuntimeException | FileNotFoundException | OutOfMemoryError e) {
                        Log.i(TAG, "couldn't decode stream: ", e);
                        exception = e;
                    } catch (IOException e) {
                        Log.i(TAG, "couldn't close stream: ", e);
                        exception = e;
                    }

                    if (isCancelled()) {
                        return null;
                    }

                    if (exception != null) {
                        // Note that if we do fail at this, and the default wallpaper can't
                        // be loaded, we will go into a cycle.  Don't do a build where the
                        // default wallpaper can't be loaded.
                        Log.w(TAG, "Unable to load wallpaper!", exception);
                        try {
                            return ((BitmapDrawable) getFallbackDrawable()).getBitmap();
                        } catch (OutOfMemoryError ex) {
                            // now we're really screwed.
                            Log.w(TAG, "Unable reset to default wallpaper!", ex);
                        }

                        if (isCancelled()) {
                            return null;
                        }
                    }
                    return null;
                }

                @Override
                protected void onPostExecute(Bitmap b) {
                    mBackground = null;
                    mBackgroundWidth = -1;
                    mBackgroundHeight = -1;

                    if (b != null) {
                        mBackground = b;
                        mBackgroundWidth = mBackground.getWidth();
                        mBackgroundHeight = mBackground.getHeight();

                        if (VERSION.SDK_INT >= VERSION_CODES.O_MR1) {
                            mCachedWallpaperColors = WallpaperColors.fromBitmap(mBackground);
                            notifyColorsChanged();
                        }
                    }

                    if (DEBUG) {
                        Log.d(TAG, "Wallpaper loaded: " + mBackground);
                    }
                    updateSurfaceSize(getSurfaceHolder(), mDefaultDisplay,
                            false /* forDraw */);
                    if (mTexture != 0 && mEgl != null) {
                        deleteTexture(mTexture);
                    }
                    // If background is absent (due to an error decoding the bitmap) then don't try to load
                    // a texture.
                    if (mEgl != null && mBackground != null) {
                        mTexture = loadTexture(mBackground);
                    }
                    if (mNeedsDrawAfterLoadingWallpaper) {
                        drawFrame(true /* forceRedraw */);
                    }

                    mLoader = null;
                    mNeedsDrawAfterLoadingWallpaper = false;
                }
            }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
        }

        private Drawable getFallbackDrawable() {
            Drawable drawable;
            try {
                drawable = mWallpaperManager.getDrawable();
            } catch (java.lang.Exception e) {
                // Work around Samsung bug where SecurityException is thrown if device is still using its
                // default wallpaper, and around Android 7.0 bug where SELinux issues can cause a perfectly
                // valid access of the current wallpaper to cause a failed Binder transaction manifest here
                // as a RuntimeException.
                drawable = mWallpaperManager.getBuiltInDrawable();
            }
            return drawable;
        }

        @Override
        protected void dump(String prefix, FileDescriptor fd, PrintWriter out, String[] args) {
            super.dump(prefix, fd, out, args);

            out.print(prefix);
            out.println("ImageWallpaper.DrawableEngine:");
            out.print(prefix);
            out.print(" mBackground=");
            out.print(mBackground);
            out.print(" mBackgroundWidth=");
            out.print(mBackgroundWidth);
            out.print(" mBackgroundHeight=");
            out.println(mBackgroundHeight);

            out.print(prefix);
            out.print(" mLastRotation=");
            out.print(mLastRotation);
            out.print(" mLastSurfaceWidth=");
            out.print(mLastSurfaceWidth);
            out.print(" mLastSurfaceHeight=");
            out.println(mLastSurfaceHeight);

            out.print(prefix);
            out.print(" mXOffset=");
            out.print(mXOffset);
            out.print(" mYOffset=");
            out.println(mYOffset);

            out.print(prefix);
            out.print(" mVisible=");
            out.print(mVisible);
            out.print(" mOffsetsChanged=");
            out.println(mOffsetsChanged);

            out.print(prefix);
            out.print(" mLastXTranslation=");
            out.print(mLastXTranslation);
            out.print(" mLastYTranslation=");
            out.print(mLastYTranslation);
            out.print(" mScale=");
            out.println(mScale);

            out.print(prefix);
            out.print(" mLastRequestedWidth=");
            out.print(mLastRequestedWidth);
            out.print(" mLastRequestedHeight=");
            out.println(mLastRequestedHeight);

            out.print(prefix);
            out.println(" DisplayInfo at last updateSurfaceSize:");
            out.print(prefix);
            out.print("  rotation=");
            out.print(mRotationAtLastSurfaceSizeUpdate);
            out.print("  width=");
            out.print(mDisplayWidthAtLastSurfaceSizeUpdate);
            out.print("  height=");
            out.println(mDisplayHeightAtLastSurfaceSizeUpdate);
        }

        private void drawWallpaperWithCanvas(SurfaceHolder sh, int w, int h, int left, int top) {
            Canvas c = sh.lockCanvas();
            if (c != null) {
                try {
                    if (DEBUG) {
                        Log.d(TAG, "Redrawing: left=" + left + ", top=" + top);
                    }

                    final float right = left + mBackgroundWidth * mScale;
                    final float bottom = top + mBackgroundHeight * mScale;
                    if (w < 0 || h < 0) {
                        c.save();
                        c.clipOutRect(left, top, right, bottom);
                        c.drawColor(0xff000000);
                        c.restore();
                    }
                    if (mBackground != null) {
                        RectF dest = new RectF(left, top, right, bottom);
                        // add a filter bitmap?
                        c.drawBitmap(mBackground, null, dest, null);
                    }
                } finally {
                    sh.unlockCanvasAndPost(c);
                }
            }
        }

        private boolean drawWallpaperWithOpenGL(SurfaceHolder sh, int w, int h, int left, int top) {

            mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);

            final float right = left + mBackgroundWidth * mScale;
            final float bottom = top + mBackgroundHeight * mScale;

            final Rect frame = sh.getSurfaceFrame();
            final Matrix4f ortho = new Matrix4f();
            ortho.loadOrtho(0.0f, frame.width(), frame.height(), 0.0f, -1.0f, 1.0f);

            final FloatBuffer triangleVertices = createMesh(left, top, right, bottom);

            final int attribPosition = GLES20.glGetAttribLocation(mProgram, "position");
            final int attribTexCoords = GLES20.glGetAttribLocation(mProgram, "texCoords");
            final int uniformTexture = GLES20.glGetUniformLocation(mProgram, "texture");
            final int uniformProjection = GLES20.glGetUniformLocation(mProgram, "projection");

            checkGlError();

            GLES20.glViewport(0, 0, frame.width(), frame.height());
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTexture);

            GLES20.glUseProgram(mProgram);
            GLES20.glEnableVertexAttribArray(attribPosition);
            GLES20.glEnableVertexAttribArray(attribTexCoords);
            GLES20.glUniform1i(uniformTexture, 0);
            GLES20.glUniformMatrix4fv(uniformProjection, 1, false, ortho.getArray(), 0);

            checkGlError();

            if (w > 0 || h > 0) {
                GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
                GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
            }

            // drawQuad
            triangleVertices.position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
            GLES20.glVertexAttribPointer(attribPosition, 3, GLES20.GL_FLOAT, false,
                    TRIANGLE_VERTICES_DATA_STRIDE_BYTES, triangleVertices);

            triangleVertices.position(TRIANGLE_VERTICES_DATA_UV_OFFSET);
            GLES20.glVertexAttribPointer(attribTexCoords, 3, GLES20.GL_FLOAT, false,
                    TRIANGLE_VERTICES_DATA_STRIDE_BYTES, triangleVertices);

            GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);

            boolean status = mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);
            checkEglError();

            return status;
        }

        private FloatBuffer createMesh(int left, int top, float right, float bottom) {
            final float[] verticesData = {
                    // X, Y, Z, U, V
                    left, bottom, 0.0f, 0.0f, 1.0f,
                    right, bottom, 0.0f, 1.0f, 1.0f,
                    left, top, 0.0f, 0.0f, 0.0f,
                    right, top, 0.0f, 1.0f, 0.0f,
            };

            final int bytes = verticesData.length * FLOAT_SIZE_BYTES;
            final FloatBuffer triangleVertices = ByteBuffer.allocateDirect(bytes).order(
                    ByteOrder.nativeOrder()).asFloatBuffer();
            triangleVertices.put(verticesData).position(0);
            return triangleVertices;
        }

        private int loadTexture(Bitmap bitmap) {
            mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);

            int[] textures = new int[1];

            GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
            GLES20.glGenTextures(1, textures, 0);
            checkGlError();

            int texture = textures[0];
            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texture);
            checkGlError();

            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR);
            GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);

            GLES20.glTexParameteri(
                    GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
            GLES20.glTexParameteri(
                    GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);

            GLUtils.texImage2D(
                    GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA, bitmap, GLES20.GL_UNSIGNED_BYTE, 0);
            checkGlError();

            mIsOpenGlTextureLoaded = true;

            return texture;
        }

        private int buildProgram(String vertex, String fragment) {
            int vertexShader = buildShader(vertex, GLES20.GL_VERTEX_SHADER);
            if (vertexShader == 0) {
                return 0;
            }

            int fragmentShader = buildShader(fragment, GLES20.GL_FRAGMENT_SHADER);
            if (fragmentShader == 0) {
                return 0;
            }

            int program = GLES20.glCreateProgram();
            GLES20.glAttachShader(program, vertexShader);
            GLES20.glAttachShader(program, fragmentShader);
            GLES20.glLinkProgram(program);
            checkGlError();

            GLES20.glDeleteShader(vertexShader);
            GLES20.glDeleteShader(fragmentShader);

            int[] status = new int[1];
            GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, status, 0);
            if (status[0] != GLES20.GL_TRUE) {
                String error = GLES20.glGetProgramInfoLog(program);
                Log.d(GL_LOG_TAG, "Error while linking program:\n" + error);
                GLES20.glDeleteProgram(program);
                return 0;
            }

            return program;
        }

        private int buildShader(String source, int type) {
            int shader = GLES20.glCreateShader(type);

            GLES20.glShaderSource(shader, source);
            checkGlError();

            GLES20.glCompileShader(shader);
            checkGlError();

            int[] status = new int[1];
            GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, status, 0);
            if (status[0] != GLES20.GL_TRUE) {
                String error = GLES20.glGetShaderInfoLog(shader);
                Log.d(GL_LOG_TAG, "Error while compiling shader:\n" + error);
                GLES20.glDeleteShader(shader);
                return 0;
            }

            return shader;
        }

        private void checkEglError() {
            int error = mEgl.eglGetError();
            if (error != EGL10.EGL_SUCCESS) {
                Log.w(GL_LOG_TAG, "EGL error = " + GLUtils.getEGLErrorString(error));
            }
        }

        private void checkGlError() {
            int error = GLES20.glGetError();
            if (error != GLES20.GL_NO_ERROR) {
                Log.w(GL_LOG_TAG, "GL error = 0x" + Integer.toHexString(error), new Throwable());
            }
        }

        private void deleteTexture(int texture) {
            int[] textures = new int[1];
            textures[0] = texture;

            mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
            GLES20.glDeleteTextures(1, textures, 0);
            mTexture = 0;
        }

        private void finishGL(int texture, int program) {
            if (mEgl == null) {
                return;
            }

            mOpenGlContextCounter--;

            mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
            deleteTexture(mTexture);
            GLES20.glDeleteProgram(program);
            mEgl.eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
            mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
            mEgl.eglDestroyContext(mEglDisplay, mEglContext);
            if (mOpenGlContextCounter == 0) {
                mEgl.eglTerminate(mEglDisplay);
            }

            mEgl = null;
        }

        private boolean initGL(SurfaceHolder surfaceHolder) {
            mEgl = (EGL10) EGLContext.getEGL();

            mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
            if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
                throw new RuntimeException("eglGetDisplay failed "
                        + GLUtils.getEGLErrorString(mEgl.eglGetError()));
            }

            int[] version = new int[2];
            if (!mEgl.eglInitialize(mEglDisplay, version)) {
                throw new RuntimeException("eglInitialize failed "
                        + GLUtils.getEGLErrorString(mEgl.eglGetError()));
            }

            mOpenGlContextCounter++;

            mEglConfig = chooseEglConfig();
            if (mEglConfig == null) {
                throw new RuntimeException("eglConfig not initialized");
            }

            mEglContext = createContext(mEgl, mEglDisplay, mEglConfig);
            if (mEglContext == EGL_NO_CONTEXT) {
                throw new RuntimeException("createContext failed "
                        + GLUtils.getEGLErrorString(mEgl.eglGetError()));
            }

            int attribs[] = {
                    EGL10.EGL_WIDTH, 1,
                    EGL10.EGL_HEIGHT, 1,
                    EGL10.EGL_NONE
            };
            EGLSurface tmpSurface = mEgl.eglCreatePbufferSurface(mEglDisplay, mEglConfig, attribs);
            mEgl.eglMakeCurrent(mEglDisplay, tmpSurface, tmpSurface, mEglContext);

            int[] maxSize = new int[1];
            Rect frame = surfaceHolder.getSurfaceFrame();
            GLES20.glGetIntegerv(GLES20.GL_MAX_TEXTURE_SIZE, maxSize, 0);

            mEgl.eglMakeCurrent(
                    mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
            mEgl.eglDestroySurface(mEglDisplay, tmpSurface);

            if (frame.width() > maxSize[0] || frame.height() > maxSize[0]) {
                mEgl.eglDestroyContext(mEglDisplay, mEglContext);
                mEgl.eglTerminate(mEglDisplay);
                Log.e(GL_LOG_TAG, "requested  texture size " + frame.width() + "x" + frame.height()
                        + " exceeds the support maximum of " + maxSize[0] + "x" + maxSize[0]);
                return false;
            }

            mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig, surfaceHolder, null);
            if (mEglSurface == null || mEglSurface == EGL_NO_SURFACE) {
                int error = mEgl.eglGetError();
                if (error == EGL10.EGL_BAD_NATIVE_WINDOW || error == EGL10.EGL_BAD_ALLOC) {
                    Log.e(GL_LOG_TAG, "createWindowSurface returned " + GLUtils.getEGLErrorString(error)
                            + ".");
                    return false;
                }
                throw new RuntimeException("createWindowSurface failed "
                        + GLUtils.getEGLErrorString(error));
            }

            if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
                throw new RuntimeException("eglMakeCurrent failed "
                        + GLUtils.getEGLErrorString(mEgl.eglGetError()));
            }

            mProgram = buildProgram(S_SIMPLE_VS, S_SIMPLE_FS);
            if (mBackground != null) {
                mTexture = loadTexture(mBackground);
            }

            return true;
        }


        EGLContext createContext(EGL10 egl, EGLDisplay eglDisplay, EGLConfig eglConfig) {
            int[] attribList = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE};
            return egl.eglCreateContext(eglDisplay, eglConfig, EGL_NO_CONTEXT, attribList);
        }

        private EGLConfig chooseEglConfig() {
            int[] configsCount = new int[1];
            EGLConfig[] configs = new EGLConfig[1];
            int[] configSpec = getConfig();
            if (!mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1, configsCount)) {
                throw new IllegalArgumentException("eglChooseConfig failed "
                        + GLUtils.getEGLErrorString(mEgl.eglGetError()));
            } else if (configsCount[0] > 0) {
                return configs[0];
            }
            return null;
        }

        private int[] getConfig() {
            return new int[]{
                    EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
                    EGL10.EGL_RED_SIZE, 8,
                    EGL10.EGL_GREEN_SIZE, 8,
                    EGL10.EGL_BLUE_SIZE, 8,
                    EGL10.EGL_ALPHA_SIZE, 0,
                    EGL10.EGL_DEPTH_SIZE, 0,
                    EGL10.EGL_STENCIL_SIZE, 0,
                    EGL10.EGL_CONFIG_CAVEAT, EGL10.EGL_NONE,
                    EGL10.EGL_NONE
            };
        }
    }
}