blob: e3c26d53d75d9215529f5fe7f4a1369a695b8fee (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
/*
* 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 <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() {
// 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);
}
|
