Back to project page abstract-art.
The source code is released under:
GNU General Public License
If you think the Android project abstract-art listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/* * Copyright (c) 2011 Ben Gruver//from www .j a va 2s. co m * All rights reserved. * * You may use this code at your option under the following BSD license * or Apache 2.0 license terms * * [The "BSD license"] * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products * derived from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * [The "Apache 2.0 license"] * 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.jf.GLWallpaper; import android.opengl.GLSurfaceView; import android.service.wallpaper.WallpaperService; import android.view.SurfaceHolder; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.List; public abstract class GLWallpaperService extends WallpaperService { public interface Renderer extends GLSurfaceView.Renderer { } public class GLEngine extends WallpaperService.Engine { public final static int RENDERMODE_WHEN_DIRTY = 0; public final static int RENDERMODE_CONTINUOUSLY = 1; private Object lock = new Object(); private GLSurfaceView mGLSurfaceView = null; private int debugFlags; private int renderMode; /** * If we don't have a GLSurfaceView yet, then we queue up any operations that are requested, until the * GLSurfaceView is created. * * Initially, we created the glSurfaceView in the GLEngine constructor, and things seemed to work. However, * it turns out a few devices aren't set up to handle the surface related events at this point, and crash. * * This is a work around so that we can delay the creation of the GLSurfaceView until the surface is actually * created, so that the underlying code should be in a state to be able to handle the surface related events * that get fired when GLSurfaceView is created. */ private List<Runnable> pendingOperations = new ArrayList<Runnable>(); public GLEngine() { } public void setGLWrapper(final GLSurfaceView.GLWrapper glWrapper) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.setGLWrapper(glWrapper); } else { pendingOperations.add(new Runnable() { public void run() { setGLWrapper(glWrapper); } }); } } } public void setDebugFlags(final int debugFlags) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.setDebugFlags(debugFlags); } else { this.debugFlags = debugFlags; pendingOperations.add(new Runnable() { public void run() { setDebugFlags(debugFlags); } }); } } } public int getDebugFlags() { synchronized (lock) { if (mGLSurfaceView != null) { return mGLSurfaceView.getDebugFlags(); } else { return debugFlags; } } } public void setRenderer(final GLSurfaceView.Renderer renderer) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.setRenderer(renderer); if (!isVisible()) { mGLSurfaceView.onPause(); } } else { pendingOperations.add(new Runnable() { public void run() { setRenderer(renderer); } }); } } } public void queueEvent(final Runnable r) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.queueEvent(r); } else { pendingOperations.add(new Runnable() { public void run() { queueEvent(r); } }); } } } public void setEGLContextFactory(final GLSurfaceView.EGLContextFactory factory) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.setEGLContextFactory(factory); } else { pendingOperations.add(new Runnable() { public void run() { setEGLContextFactory(factory); } }); } } } public void setEGLWindowSurfaceFactory(final GLSurfaceView.EGLWindowSurfaceFactory factory) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.setEGLWindowSurfaceFactory(factory); } else { pendingOperations.add(new Runnable() { public void run() { setEGLWindowSurfaceFactory(factory); } }); } } } public void setEGLConfigChooser(final GLSurfaceView.EGLConfigChooser configChooser) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.setEGLConfigChooser(configChooser); } else { pendingOperations.add(new Runnable() { public void run() { setEGLConfigChooser(configChooser); } }); } } } public void setEGLConfigChooser(final boolean needDepth) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.setEGLConfigChooser(needDepth); } else { pendingOperations.add(new Runnable() { public void run() { setEGLConfigChooser(needDepth); } }); } } } public void setEGLConfigChooser(final int redSize, final int greenSize, final int blueSize, final int alphaSize, final int depthSize, final int stencilSize) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.setEGLConfigChooser(redSize, greenSize, blueSize, alphaSize, depthSize, stencilSize); } else { pendingOperations.add(new Runnable() { public void run() { setEGLConfigChooser(redSize, greenSize, blueSize, alphaSize, depthSize, stencilSize); } }); } } } public void setEGLContextClientVersion(final int version) { synchronized (lock) { Method method = null; try { //the setEGLContextClientVersion method is first available in api level 8, but we would //like to support compiling against api level 7 method = GLSurfaceView.class.getMethod("setEGLContextClientVersion", int.class); } catch (NoSuchMethodException ex) { return; } if (mGLSurfaceView != null) { try { method.invoke(mGLSurfaceView, version); } catch (IllegalAccessException ex) { return; } catch (InvocationTargetException ex) { return; } } else { pendingOperations.add(new Runnable() { public void run() { setEGLContextClientVersion(version); } }); } } } public void setRenderMode(final int renderMode) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.setRenderMode(renderMode); } else { this.renderMode = renderMode; pendingOperations.add(new Runnable() { public void run() { setRenderMode(renderMode); } }); } } } public int getRenderMode() { synchronized (lock) { if (mGLSurfaceView != null) { return mGLSurfaceView.getRenderMode(); } else { return renderMode; } } } public void requestRender() { if (mGLSurfaceView != null) { mGLSurfaceView.requestRender(); } } @Override public void onVisibilityChanged(final boolean visible) { super.onVisibilityChanged(visible); synchronized (lock) { if (mGLSurfaceView != null) { if (visible) { mGLSurfaceView.onResume(); } else { mGLSurfaceView.onPause(); } } else { pendingOperations.add(new Runnable() { public void run() { if (visible) { mGLSurfaceView.onResume(); } else { mGLSurfaceView.onPause(); } } }); } } } @Override public void onSurfaceChanged(final SurfaceHolder holder, final int format, final int width, final int height) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.surfaceChanged(holder, format, width, height); } else { pendingOperations.add(new Runnable() { public void run() { onSurfaceChanged(holder, format, width, height); } }); } } } @Override public void onSurfaceCreated(SurfaceHolder holder) { synchronized (lock) { if (mGLSurfaceView == null) { mGLSurfaceView = new GLSurfaceView(GLWallpaperService.this) { @Override public SurfaceHolder getHolder() { return GLEngine.this.getSurfaceHolder(); } }; for (Runnable pendingOperation: pendingOperations) { pendingOperation.run(); } pendingOperations.clear(); } mGLSurfaceView.surfaceCreated(holder); } } @Override public void onSurfaceDestroyed(SurfaceHolder holder) { synchronized (lock) { if (mGLSurfaceView != null) { mGLSurfaceView.surfaceDestroyed(holder); } } } @Override public void onCreate(SurfaceHolder surfaceHolder) { super.onCreate(surfaceHolder); } } }