1 files changed, 230 insertions, 0 deletions
diff --git a/src/org/cyanogenmod/wallpapers/photophase/GLESWallpaperService.java b/src/org/cyanogenmod/wallpapers/photophase/GLESWallpaperService.java
new file mode 100644
index 0000000..8ddb443
--- /dev/null
+++ b/src/org/cyanogenmod/wallpapers/photophase/GLESWallpaperService.java
@@ -0,0 +1,230 @@
+/*
+ * Copyright (C) 2013 The CyanogenMod 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 org.cyanogenmod.wallpapers.photophase;
+
+import android.opengl.GLSurfaceView;
+import android.opengl.GLSurfaceView.Renderer;
+import android.view.SurfaceHolder;
+
+
+/**
+ * An abstract implementation of {@link EGLWallpaperService} based on <code>GLES</code>.
+ */
+public abstract class GLESWallpaperService extends EGLWallpaperService {
+
+    /**
+     * A listener interface for the {@link GLESWallpaperService.GLESEngine} engine class.
+     */
+    public interface GLESEngineListener extends EGLEngineListener {
+        /**
+         * Method invoked when the EGL surface is starting to initialize.
+         *
+         * @param view GLSurfaceView The EGL view
+         */
+        void onInitializeEGLView(GLSurfaceView view);
+
+        /**
+         * Method invoked when the EGL surface is recycled.
+         *
+         * @param view GLSurfaceView The EGL view
+         * @param renderer The renderer associated
+         */
+        void onDestroyEGLView(GLSurfaceView view, Renderer renderer);
+
+        /**
+         * Method invoked when the EGL surface was initialized.
+         *
+         * @param view GLSurfaceView The EGL view
+         */
+        void onEGLViewInitialized(GLSurfaceView view);
+
+        /**
+         * Method invoked when the EGL context is paused
+         *
+         * @param renderer The renderer associated
+         */
+        void onPause(Renderer renderer);
+
+        /**
+         * Method invoked when the EGL context is resumed
+         *
+         * @param renderer The renderer associated
+         */
+        void onResume(Renderer renderer);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Engine onCreateEngine() {
+        return new GLESEngine();
+    }
+
+    /**
+     * A class that extends the {@link EGLWallpaperService.EGLEngine} to add support for
+     * <code>GLES</code>.
+     */
+    class GLESEngine extends EGLWallpaperService.EGLEngine {
+
+        private GLESEngineListener mListener = null;
+        private WallpaperGLSurfaceView mWallpaperGLSurfaceView = null;
+        private Renderer mRenderer = null;
+
+        private boolean mRendererHasBeenSet;
+        private boolean mPauseOnPreview;
+
+        /**
+         * Method that sets the EGL engine listener
+         *
+         * @param listener The EGL engine listener
+         */
+        public void setGLESEngineListener(GLESEngineListener listener) {
+            mListener = listener;
+            setEGLEngineListener(listener);
+        }
+
+        /**
+         * Method that sets the {@link GLSurfaceView} to use.
+         *
+         * @param wallpaperGLSurfaceView A {@link GLSurfaceView}
+         */
+        public void setWallpaperGLSurfaceView(WallpaperGLSurfaceView wallpaperGLSurfaceView) {
+            mWallpaperGLSurfaceView = wallpaperGLSurfaceView;
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void onCreate(SurfaceHolder surfaceHolder) {
+            super.onCreate(surfaceHolder);
+
+            // Notify initialization
+            if (mListener != null) {
+                mListener.onInitializeEGLView(getGlSurfaceView());
+            }
+
+            // Initialize the GLES context
+            initialize();
+
+            // Set the renderer to our user-defined renderer.
+            mRenderer = getNewRenderer(getGlSurfaceView());
+            getGlSurfaceView().setRenderer(mRenderer);
+            mRendererHasBeenSet = true;
+
+            // Notify that the EGL is initialized
+            if (mListener != null) {
+                mListener.onEGLViewInitialized(getGlSurfaceView());
+            }
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void onDestroy() {
+            super.onDestroy();
+
+            // Notify initialization
+            if (mListener != null) {
+                mListener.onDestroyEGLView(getGlSurfaceView(), mRenderer);
+            }
+            mRenderer = null;
+        }
+
+        /**
+         * Method that initializes
+         */
+        void initialize() {
+            // Request an OpenGL ES 1.x compatible context.
+            getGlSurfaceView().setEGLContextClientVersion(1);
+        }
+
+        /**
+         * Returns the renderer used by the engine
+         *
+         * @return Renderer The renderer
+         */
+        protected Renderer getRenderer() {
+            return mRenderer;
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public WallpaperGLSurfaceView createWallpaperGLSurfaceView() {
+            // Check whether to use a proprietary GLSurfaceView reference or an internal one
+            if (mWallpaperGLSurfaceView != null) {
+                return mWallpaperGLSurfaceView;
+            }
+            return super.createWallpaperGLSurfaceView();
+        }
+
+        /**
+         * {@inheritDoc}
+         */
+        @Override
+        public void onVisibilityChanged(boolean visible) {
+            super.onVisibilityChanged(visible);
+            if (mRendererHasBeenSet) {
+                if (visible) {
+                    getGlSurfaceView().onResume();
+                    getGlSurfaceView().setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
+                    mListener.onResume(mRenderer);
+                } else {
+                    // Check that the user is not previewing the live wallpaper; if they are, then
+                    // if they open up a settings dialog that appears over the preview, we don’t
+                    // want to pause rendering
+                    boolean preview = isPreview();
+                    if (!preview || (preview && mPauseOnPreview)) {
+                        getGlSurfaceView().setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
+                        getGlSurfaceView().onPause();
+                        mListener.onPause(mRenderer);
+                    }
+                }
+            }
+        }
+
+        /**
+         * Method that determines if the surface view should be paused on preview mode
+         *
+         * @return boolean whether the surface view should be paused on preview mode
+         */
+        public boolean isPauseOnPreview() {
+            return mPauseOnPreview;
+        }
+
+        /**
+         * Method that sets if the surface view should be paused on preview mode
+         *
+         * @param pauseOnPreview whether the surface view should be paused on preview mode
+         */
+        public void setPauseOnPreview(boolean pauseOnPreview) {
+            this.mPauseOnPreview = pauseOnPreview;
+        }
+    }
+
+    /**
+     * Method that return a new EGL renderer.
+     *
+     * @param view The view that will be associated to the renderer
+     * @return Renderer The new EGL renderer.
+     */
+    public abstract Renderer getNewRenderer(GLSurfaceView view);
+}