/*
* Copyright (C) 2014 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 GLES
.
*/
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
* GLES
.
*/
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() {
// Notify initialization
if (mListener != null) {
mListener.onDestroyEGLView(getGlSurfaceView(), mRenderer);
}
mRenderer = null;
super.onDestroy();
}
/**
* 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);
}