+++ /dev/null
-/*
- * Copyright (c) 2011 Ben Gruver
- * 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 net.rbgrn.android.glwallpaperservice;
-
-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);
- }
- }
- }
- }
-}
projects / xscreensaver / blobdiff