1 files changed, 184 insertions, 0 deletions
diff --git a/src/com/android/dreams/basic/ColorsLockScreen.java b/src/com/android/dreams/basic/ColorsLockScreen.java
new file mode 100644
index 0000000..baee696
--- /dev/null
+++ b/src/com/android/dreams/basic/ColorsLockScreen.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2012 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.dreams.basic;
+
+import android.graphics.SurfaceTexture;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Log;
+import android.view.TextureView;
+import android.view.View;
+import cyanogenmod.externalviews.KeyguardExternalViewProviderService;
+
+/**
+ * Plays a delightful show of colors.
+ * <p>
+ * This dream performs its rendering using OpenGL on a separate rendering thread.
+ * </p>
+ */
+public class ColorsLockScreen extends KeyguardExternalViewProviderService {
+    static final String TAG = ColorsLockScreen.class.getSimpleName();
+    static final boolean DEBUG = false;
+
+    public static void LOG(String fmt, Object... args) {
+        if (!DEBUG) return;
+        Log.v(TAG, String.format(fmt, args));
+    }
+
+    @Override
+    protected Provider createExternalView(Bundle options) {
+        return new ProviderImpl(options);
+    }
+
+    private class ProviderImpl extends Provider implements TextureView.SurfaceTextureListener {
+        private TextureView mTextureView;
+
+        // The handler thread and handler on which the GL renderer is running.
+        private HandlerThread mRendererHandlerThread;
+        private Handler mRendererHandler;
+
+        // The current GL renderer, or null if the dream is not running.
+        private ColorsGLRenderer mRenderer;
+
+        protected ProviderImpl(Bundle options) {
+            super(options);
+        }
+
+        @Override
+        protected View onCreateView() {
+            mTextureView = new TextureView(ColorsLockScreen.this);
+            mTextureView.setSurfaceTextureListener(this);
+
+            return mTextureView;
+        }
+
+        @Override
+        protected void onKeyguardShowing(boolean screenOn) {
+            resumeRendering();
+        }
+
+        @Override
+        protected void onKeyguardDismissed() {
+            pauseRendering();
+        }
+
+        @Override
+        protected void onBouncerShowing(boolean showing) {
+        }
+
+        @Override
+        protected void onScreenTurnedOn() {
+            resumeRendering();
+        }
+
+        @Override
+        protected void onScreenTurnedOff() {
+            pauseRendering();
+        }
+
+        @Override
+        public void onSurfaceTextureAvailable(final SurfaceTexture surface,
+                final int width, final int height) {
+            LOG("onSurfaceTextureAvailable(%s, %d, %d)", surface, width, height);
+
+            if (mRendererHandlerThread == null) {
+                mRendererHandlerThread = new HandlerThread(TAG);
+                mRendererHandlerThread.start();
+                mRendererHandler = new Handler(mRendererHandlerThread.getLooper());
+            }
+
+            mRendererHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    if (mRenderer != null) {
+                        mRenderer.stop();
+                    }
+                    mRenderer = new ColorsGLRenderer(surface, width, height, 1 / 3000f);
+                    mRenderer.start();
+                }
+            });
+        }
+
+        @Override
+        public void onSurfaceTextureSizeChanged(SurfaceTexture surface,
+                final int width, final int height) {
+            LOG("onSurfaceTextureSizeChanged(%s, %d, %d)", surface, width, height);
+
+            mRendererHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    if (mRenderer != null) {
+                        mRenderer.setSize(width, height);
+                    }
+                }
+            });
+        }
+
+        @Override
+        public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
+            LOG("onSurfaceTextureDestroyed(%s)", surface);
+
+            mRendererHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    if (mRenderer != null) {
+                        mRenderer.stop();
+                        mRenderer = null;
+                    }
+                    mRendererHandlerThread.quit();
+                    mRendererHandlerThread = null;
+                }
+            });
+
+            try {
+                mRendererHandlerThread.join();
+            } catch (InterruptedException e) {
+                LOG("Error while waiting for renderer", e);
+            }
+
+            return true;
+        }
+
+        @Override
+        public void onSurfaceTextureUpdated(SurfaceTexture surface) {
+            LOG("onSurfaceTextureUpdated(%s)", surface);
+        }
+
+        private void pauseRendering() {
+            if (mRenderer != null) {
+                mRendererHandler.post(new Runnable() {
+                    @Override
+                    public void run() {
+                        mRenderer.pause();
+                    }
+                });
+            }
+        }
+
+        private void resumeRendering() {
+            if (mRenderer != null) {
+                mRendererHandler.post(new Runnable() {
+                    @Override
+                    public void run() {
+                        mRenderer.resume();
+                    }
+                });
+            }
+        }
+    }
+}