/*
* Copyright (C) 2009 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.cooliris.media;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.opengl.GLSurfaceView;
import android.opengl.GLU;
import android.opengl.GLUtils;
import android.os.Process;
import android.os.SystemClock;
import android.util.Log;
import android.util.SparseArray;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import javax.microedition.khronos.opengles.GL11;
import javax.microedition.khronos.opengles.GL11Ext;
public final class RenderView extends GLSurfaceView implements GLSurfaceView.Renderer, SensorEventListener {
private static final String TAG = "RenderView";
private static final int NUM_TEXTURE_LOAD_THREADS = 4;
private static final int MAX_LOADING_COUNT = 8;
private static final int EVENT_NONE = 0;
// private static final int EVENT_TOUCH = 1;
private static final int EVENT_KEY = 2;
private static final int EVENT_FOCUS = 3;
private final SensorManager mSensorManager;
private GL11 mGL = null;
private int mViewWidth = 0;
private int mViewHeight = 0;
private RootLayer mRootLayer = null;
private boolean mListsDirty = false;
private static final Lists sLists = new Lists();
private Layer mTouchEventTarget = null;
private int mCurrentEventType = EVENT_NONE;
private KeyEvent mCurrentKeyEvent = null;
private boolean mCurrentKeyEventResult = false;
private volatile boolean mPendingSensorEvent = false;
private int mLoadingCount = 0;
private static final Deque<Texture> sLoadInputQueue = new Deque<Texture>();
private static final Deque<Texture> sLoadInputQueueCached = new Deque<Texture>();
private static final Deque<Texture> sLoadInputQueueVideo = new Deque<Texture>();
private static final Deque<Texture> sLoadOutputQueue = new Deque<Texture>();
private static TextureLoadThread sCachedTextureLoadThread = null;
private static TextureLoadThread sVideoTextureLoadThread = null;
private static final TextureLoadThread[] sTextureLoadThreads = new TextureLoadThread[NUM_TEXTURE_LOAD_THREADS];
private final Deque<MotionEvent> mTouchEventQueue = new Deque<MotionEvent>();
private final DirectLinkedList<TextureReference> mActiveTextureList = new DirectLinkedList<TextureReference>();
@SuppressWarnings("unchecked")
private final ReferenceQueue mUnreferencedTextureQueue = new ReferenceQueue();
// Frame time in milliseconds and delta since last frame in seconds. Uses
// SystemClock.getUptimeMillis().
private long mFrameTime = 0;
private float mFrameInterval = 0.0f;
private float mAlpha;
private long mLoadingExpensiveTexturesStartTime = 0;
private final SparseArray<ResourceTexture> sCacheScaled = new SparseArray<ResourceTexture>();
private final SparseArray<ResourceTexture> sCacheUnscaled = new SparseArray<ResourceTexture>();
private boolean mFirstDraw;
// The cached texture that is bound to Texture Unit 0.
// We need to reset this to null whenever the active texture unit changes.
private Texture mBoundTexture;
// Weak reference to a texture that stores the associated texture ID.
private static final class TextureReference extends WeakReference<Texture> {
@SuppressWarnings("unchecked")
public TextureReference(Texture texture, GL11 gl, ReferenceQueue referenceQueue, int textureId) {
super(texture, referenceQueue);
this.textureId = textureId;
this.gl = gl;
}
public final int textureId;
public final GL11 gl;
public final DirectLinkedList.Entry<TextureReference> activeListEntry = new DirectLinkedList.Entry<TextureReference>(this);
}
public static final class Lists {
public final ArrayList<Layer> updateList = new ArrayList<Layer>();
public final ArrayList<Layer> opaqueList = new ArrayList<Layer>();
public final ArrayList<Layer> blendedList = new ArrayList<Layer>();
public final ArrayList<Layer> hitTestList = new ArrayList<Layer>();
public final ArrayList<Layer> systemList = new ArrayList<Layer>();
void clear() {
updateList.clear();
opaqueList.clear();
blendedList.clear();
hitTestList.clear();
systemList.clear();
}
}
public RenderView(final Context context) {
super(context);
setBackgroundDrawable(null);
setFocusable(true);
setRenderer(this);
mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
if (sCachedTextureLoadThread == null) {
for (int i = 0; i != NUM_TEXTURE_LOAD_THREADS; ++i) {
TextureLoadThread thread = new TextureLoadThread();
if (i == 0) {
sCachedTextureLoadThread = thread;
}
if (i == 1) {
sVideoTextureLoadThread = thread;
}
sTextureLoadThreads[i] = thread;
thread.start();
}
}
}
public void setRootLayer(RootLayer layer) {
if (mRootLayer != layer) {
mRootLayer = layer;
mListsDirty = true;
if (layer != null) {
mRootLayer.setSize(mViewWidth, mViewHeight);
}
}
}
public ResourceTexture getResource(int resourceId) {
return getResourceInternal(resourceId, true);
}
public ResourceTexture getResource(int resourceId, boolean scaled) {
return getResourceInternal(resourceId, scaled);
}
private ResourceTexture getResourceInternal(int resourceId, boolean scaled) {
final SparseArray<ResourceTexture> cache = (scaled) ? sCacheScaled : sCacheUnscaled;
ResourceTexture texture = cache.get(resourceId);
if (texture == null && resourceId != 0) {
texture = new ResourceTexture(resourceId, scaled);
cache.put(resourceId, texture);
}
return texture;
}
public void clearCache() {
clearTextureArray(sCacheScaled);
clearTextureArray(sCacheUnscaled);
}
private void clearTextureArray(SparseArray<ResourceTexture> array) {
/*
* final int size = array.size(); for (int i = 0; i < size; ++i) {
* ResourceTexture texture = array.get(array.keyAt(i)); if (texture !=
* null) { texture.clear(); } }
*/
array.clear();
}
/** Render API */
public long getFrameTime() {
return mFrameTime;
}
public float getFrameInterval() {
return mFrameInterval;
}
public void prime(Texture texture, boolean highPriority) {
if (texture != null && texture.mState == Texture.STATE_UNLOADED && (highPriority || mLoadingCount < MAX_LOADING_COUNT)) {
queueLoad(texture, highPriority);
}
}
public void loadTexture(Texture texture) {
if (texture != null) {
switch (texture.mState) {
case Texture.STATE_UNLOADED:
case Texture.STATE_QUEUED:
int[] textureId = new int[1];
texture.mState = Texture.STATE_LOADING;
loadTextureAsync(texture);
uploadTexture(texture, textureId);
break;
}
}
}
private void loadTextureAsync(Texture texture) {
try {
Bitmap bitmap = texture.load(this);
if (bitmap != null) {
bitmap = Utils.resizeBitmap(bitmap, 1024);
int width = bitmap.getWidth();
int height = bitmap.getHeight();
texture.mWidth = width;
texture.mHeight = height;
// Create a padded bitmap if the natural size is not a power of
// 2.
if (!Shared.isPowerOf2(width) || !Shared.isPowerOf2(height)) {
int paddedWidth = Shared.nextPowerOf2(width);
int paddedHeight = Shared.nextPowerOf2(height);
Bitmap.Config config = bitmap.getConfig();
if (config == null)
config = Bitmap.Config.RGB_565;
if (width * height >= 512 * 512)
config = Bitmap.Config.RGB_565;
Bitmap padded = Bitmap.createBitmap(paddedWidth, paddedHeight, config);
Canvas canvas = new Canvas(padded);
canvas.drawBitmap(bitmap, 0, 0, null);
bitmap.recycle();
bitmap = padded;
// Store normalized width and height for use in texture
// coordinates.
texture.mNormalizedWidth = (float) width / (float) paddedWidth;
texture.mNormalizedHeight = (float) height / (float) paddedHeight;
} else {
texture.mNormalizedWidth = 1.0f;
texture.mNormalizedHeight = 1.0f;
}
}
texture.mBitmap = bitmap;
} catch (Exception e) {
texture.mBitmap = null;
} catch (OutOfMemoryError eMem) {
Log.i(TAG, "Bitmap power of 2 creation fail, outofmemory");
handleLowMemory();
}
}
public boolean bind(Texture texture) {
if (texture != null) {
if (texture == mBoundTexture)
return true;
switch (texture.mState) {
case Texture.STATE_UNLOADED:
if (texture.getClass().equals(ResourceTexture.class)) {
loadTexture(texture);
return false;
}
if (mLoadingCount < MAX_LOADING_COUNT) {
queueLoad(texture, false);
}
break;
case Texture.STATE_LOADED:
mGL.glBindTexture(GL11.GL_TEXTURE_2D, texture.mId);
mBoundTexture = texture;
return true;
default:
break;
}
}
return false;
}
public void setAlpha(float alpha) {
GL11 gl = mGL;
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_MODULATE);
gl.glColor4f(alpha, alpha, alpha, alpha);
mAlpha = alpha;
}
public float getAlpha() {
return mAlpha;
}
public void setColor(float red, float green, float blue, float alpha) {
GL11 gl = mGL;
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_MODULATE);
gl.glColor4f(red, green, blue, alpha);
mAlpha = alpha;
}
public void resetColor() {
GL11 gl = mGL;
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_REPLACE);
gl.glColor4f(1, 1, 1, 1);
}
public boolean isLoadingExpensiveTextures() {
return mLoadingExpensiveTexturesStartTime != 0;
}
public long elapsedLoadingExpensiveTextures() {
long startTime = mLoadingExpensiveTexturesStartTime;
if (startTime != 0) {
return SystemClock.uptimeMillis() - startTime;
} else {
return -1;
}
}
private void queueLoad(final Texture texture, boolean highPriority) {
// Allow the texture to defer queuing.
if (!texture.shouldQueue()) {
return;
}
// Change the texture state to loading.
texture.mState = Texture.STATE_LOADING;
// Push the texture onto the load input queue.
Deque<Texture> inputQueue = (texture.isUncachedVideo()) ? sLoadInputQueueVideo
: (texture.isCached()) ? sLoadInputQueueCached : sLoadInputQueue;
;
synchronized (inputQueue) {
if (highPriority) {
inputQueue.addFirst(texture);
// Enforce the maximum loading count by removing something from the end of
// the loading queue, if necessary.
if (mLoadingCount >= MAX_LOADING_COUNT) {
Texture unloadTexture = inputQueue.pollLast();
unloadTexture.mState = Texture.STATE_UNLOADED;
--mLoadingCount;
}
} else {
inputQueue.addLast(texture);
}
inputQueue.notify();
}
++mLoadingCount;
}
public void draw2D(Texture texture, float x, float y) {
if (bind(texture)) {
final float width = texture.getWidth();
final float height = texture.getHeight();
((GL11Ext) mGL).glDrawTexfOES(x, mViewHeight - y - height, 0f, width, height);
}
}
public void draw2D(Texture texture, float x, float y, float width, float height) {
if (bind(texture)) {
((GL11Ext) mGL).glDrawTexfOES(x, mViewHeight - y - height, 0f, width, height);
}
}
public void draw2D(Texture texture, int x, int y, int width, int height) {
if (bind(texture)) {
((GL11Ext) mGL).glDrawTexiOES(x, (mViewHeight - y - height), 0, width, height);
}
}
public void draw2D(float x, float y, float z, float width, float height) {
((GL11Ext) mGL).glDrawTexfOES(x, mViewHeight - y - height, z, width, height);
}
public boolean bindMixed(Texture from, Texture to, float ratio) {
// Bind "from" and "to" to TEXTURE0 and TEXTURE1, respectively.
final GL11 gl = mGL;
boolean bind = true;
bind &= bind(from);
gl.glActiveTexture(GL11.GL_TEXTURE1);
mBoundTexture = null;
bind &= bind(to);
if (!bind) {
return false;
}
// Enable TEXTURE1.
gl.glEnable(GL11.GL_TEXTURE_2D);
// Interpolate the RGB and alpha values between both textures.
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_COMBINE);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_COMBINE_RGB, GL11.GL_INTERPOLATE);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_COMBINE_ALPHA, GL11.GL_INTERPOLATE);
// Specify the interpolation factor via the alpha component of
// GL_TEXTURE_ENV_COLORes.
final float[] color = { 1f, 1f, 1f, ratio };
gl.glTexEnvfv(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_COLOR, color, 0);
// Wire up the interpolation factor for RGB.
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_SRC2_RGB, GL11.GL_CONSTANT);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_OPERAND2_RGB, GL11.GL_SRC_ALPHA);
// Wire up the interpolation factor for alpha.
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_SRC2_ALPHA, GL11.GL_CONSTANT);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_OPERAND2_ALPHA, GL11.GL_SRC_ALPHA);
return true;
}
public void unbindMixed() {
// Disable TEXTURE1.
final GL11 gl = mGL;
gl.glDisable(GL11.GL_TEXTURE_2D);
// Switch back to the default texture unit.
gl.glActiveTexture(GL11.GL_TEXTURE0);
mBoundTexture = null;
}
public void drawMixed2D(Texture from, Texture to, float ratio, float x, float y, float z, float width, float height) {
final GL11 gl = mGL;
// Bind "from" and "to" to TEXTURE0 and TEXTURE1, respectively.
if (bind(from)) {
gl.glActiveTexture(GL11.GL_TEXTURE1);
mBoundTexture = null;
if (bind(to)) {
// Enable TEXTURE1.
gl.glEnable(GL11.GL_TEXTURE_2D);
// Interpolate the RGB and alpha values between both textures.
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_COMBINE);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_COMBINE_RGB, GL11.GL_INTERPOLATE);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_COMBINE_ALPHA, GL11.GL_INTERPOLATE);
// Specify the interpolation factor via the alpha component of
// GL_TEXTURE_ENV_COLORes.
final float[] color = { 1f, 1f, 1f, ratio };
gl.glTexEnvfv(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_COLOR, color, 0);
// Wire up the interpolation factor for RGB.
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_SRC2_RGB, GL11.GL_CONSTANT);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_OPERAND2_RGB, GL11.GL_SRC_ALPHA);
// Wire up the interpolation factor for alpha.
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_SRC2_ALPHA, GL11.GL_CONSTANT);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_OPERAND2_ALPHA, GL11.GL_SRC_ALPHA);
// Draw the combined texture.
((GL11Ext) gl).glDrawTexfOES(x, mViewHeight - y - height, z, width, height);
// Disable TEXTURE1.
gl.glDisable(GL11.GL_TEXTURE_2D);
}
// Switch back to the default texture unit.
gl.glActiveTexture(GL11.GL_TEXTURE0);
mBoundTexture = null;
}
}
public void processAllTextures() {
processTextures(true);
}
final static int[] textureId = new int[1];
/** Uploads at most one texture to GL. */
private void processTextures(boolean processAll) {
// Destroy any textures that are no longer referenced.
GL11 gl = mGL;
TextureReference textureReference;
while ((textureReference = (TextureReference) mUnreferencedTextureQueue.poll()) != null) {
textureId[0] = textureReference.textureId;
GL11 glOld = textureReference.gl;
if (glOld == gl) {
gl.glDeleteTextures(1, textureId, 0);
}
mActiveTextureList.remove(textureReference.activeListEntry);
}
Deque<Texture> outputQueue = sLoadOutputQueue;
Texture texture;
do {
// Upload loaded textures to the GPU one frame at a time.
synchronized (outputQueue) {
texture = outputQueue.pollFirst();
}
if (texture != null) {
// Extract the bitmap from the texture.
uploadTexture(texture, textureId);
// Decrement the loading count.
--mLoadingCount;
} else {
break;
}
} while (processAll);
}
private void uploadTexture(Texture texture, int[] textureId) {
Bitmap bitmap = texture.mBitmap;
GL11 gl = mGL;
int glError = GL11.GL_NO_ERROR;
if (bitmap != null) {
final int width = texture.mWidth;
final int height = texture.mHeight;
// Define a vertically flipped crop rectangle for OES_draw_texture.
int[] cropRect = { 0, height, width, -height };
// Upload the bitmap to a new texture.
gl.glGenTextures(1, textureId, 0);
gl.glBindTexture(GL11.GL_TEXTURE_2D, textureId[0]);
gl.glTexParameteriv(GL11.GL_TEXTURE_2D, GL11Ext.GL_TEXTURE_CROP_RECT_OES, cropRect, 0);
gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_S, GL11.GL_CLAMP_TO_EDGE);
gl.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_WRAP_T, GL11.GL_CLAMP_TO_EDGE);
gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR);
gl.glTexParameterf(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
GLUtils.texImage2D(GL11.GL_TEXTURE_2D, 0, bitmap, 0);
glError = gl.glGetError();
bitmap.recycle();
if (glError == GL11.GL_OUT_OF_MEMORY) {
handleLowMemory();
}
if (glError != GL11.GL_NO_ERROR) {
// There was an error, we need to retry this texture at some
// later time
Log.i(TAG, "Texture creation fail, glError " + glError);
texture.mId = 0;
texture.mBitmap = null;
texture.mState = Texture.STATE_UNLOADED;
} else {
// Update texture state.
texture.mBitmap = null;
texture.mId = textureId[0];
texture.mState = Texture.STATE_LOADED;
// Add to the active list.
final TextureReference textureRef = new TextureReference(texture, gl, mUnreferencedTextureQueue, textureId[0]);
mActiveTextureList.add(textureRef.activeListEntry);
requestRender();
}
} else {
texture.mState = Texture.STATE_ERROR;
}
}
@Override
public void onResume() {
super.onResume();
Sensor sensorAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
if (sensorAccelerometer != null) {
mSensorManager.registerListener(this, sensorAccelerometer, SensorManager.SENSOR_DELAY_UI);
}
if (mRootLayer != null) {
mRootLayer.onResume();
}
}
@Override
public void onPause() {
super.onPause();
Log.i(TAG, "OnPause RenderView " + this);
mSensorManager.unregisterListener(this);
if (mRootLayer != null) {
mRootLayer.onPause();
}
}
private final boolean ENABLE_FPS_TEST = false;
private int mFrameCount = 0;
private long mFrameCountingStart = 0;
/** Renders a frame of the UI. */
// @Override
public void onDrawFrame(GL10 gl1) {
if (ENABLE_FPS_TEST) {
long now = System.nanoTime();
if (mFrameCountingStart == 0) {
mFrameCountingStart = now;
} else if ((now - mFrameCountingStart) > 1000000000) {
Log.v(TAG, "fps: " + (double) mFrameCount
* 1000000000 / (now - mFrameCountingStart));
mFrameCountingStart = now;
mFrameCount = 0;
}
++mFrameCount;
}
GL11 gl = (GL11) gl1;
if (!mFirstDraw) {
Log.i(TAG, "First Draw");
}
mFirstDraw = true;
//setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
// Rebuild the display lists if the render tree has changed.
if (mListsDirty) {
updateLists();
}
boolean wasLoadingExpensiveTextures = isLoadingExpensiveTextures();
boolean loadingExpensiveTextures = false;
int numTextureThreads = sTextureLoadThreads.length;
for (int i = 2; i < numTextureThreads; ++i) {
if (sTextureLoadThreads[i].mIsLoading) {
loadingExpensiveTextures = true;
break;
}
}
if (loadingExpensiveTextures != wasLoadingExpensiveTextures) {
mLoadingExpensiveTexturesStartTime = loadingExpensiveTextures ? SystemClock.uptimeMillis() : 0;
}
// Upload new textures.
processTextures(false);
// Update the current time and frame time interval.
long now = SystemClock.uptimeMillis();
final float dt = 0.001f * Math.min(50, now - mFrameTime);
mFrameInterval = dt;
mFrameTime = now;
// Dispatch the current touch event.
processCurrentEvent();
processTouchEvent();
// Run the update pass.
final Lists lists = sLists;
synchronized (lists) {
final ArrayList<Layer> updateList = lists.updateList;
boolean isDirty = false;
for (int i = 0, size = updateList.size(); i != size; ++i) {
boolean retVal = updateList.get(i).update(this, mFrameInterval);
isDirty |= retVal;
}
if (isDirty) {
requestRender();
}
// Clear the depth buffer.
gl.glClear(GL11.GL_DEPTH_BUFFER_BIT);
gl.glEnable(GL11.GL_SCISSOR_TEST);
gl.glScissor(0, 0, getWidth(), getHeight());
// Run the opaque pass.
gl.glDisable(GL11.GL_BLEND);
final ArrayList<Layer> opaqueList = lists.opaqueList;
for (int i = opaqueList.size() - 1; i >= 0; --i) {
final Layer layer = opaqueList.get(i);
if (!layer.mHidden) {
layer.renderOpaque(this, gl);
}
}
// Run the blended pass.
gl.glEnable(GL11.GL_BLEND);
final ArrayList<Layer> blendedList = lists.blendedList;
for (int i = 0, size = blendedList.size(); i != size; ++i) {
final Layer layer = blendedList.get(i);
if (!layer.mHidden) {
layer.renderBlended(this, gl);
}
}
gl.glDisable(GL11.GL_BLEND);
}
}
private void processCurrentEvent() {
final int type = mCurrentEventType;
switch (type) {
case EVENT_KEY:
processKeyEvent();
break;
case EVENT_FOCUS:
processFocusEvent();
break;
default:
break;
}
synchronized (this) {
mCurrentEventType = EVENT_NONE;
this.notify();
}
}
private void processTouchEvent() {
MotionEvent event = null;
int numEvents = mTouchEventQueue.size();
int i = 0;
do {
// We look at the touch event queue and process one event at a time
synchronized (mTouchEventQueue) {
event = mTouchEventQueue.pollFirst();
}
if (event == null)
return;
// Detect the hit layer.
final int action = event.getAction();
Layer target;
if (action == MotionEvent.ACTION_DOWN) {
target = hitTest(event.getX(), event.getY());
mTouchEventTarget = target;
} else {
target = mTouchEventTarget;
}
// Dispatch event to the hit layer.
if (target != null) {
target.onTouchEvent(event);
}
// Clear the hit layer.
if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
mTouchEventTarget = null;
}
event.recycle();
++i;
} while (event != null && i < numEvents);
synchronized (this) {
this.notify();
}
}
private void processKeyEvent() {
// Get the event.
final KeyEvent event = mCurrentKeyEvent;
boolean result = false;
mCurrentKeyEvent = null;
// Dispatch the event to the root layer.
if (mRootLayer != null) {
if (event.getAction() == KeyEvent.ACTION_DOWN) {
result = mRootLayer.onKeyDown(event.getKeyCode(), event);
} else {
result = mRootLayer.onKeyUp(event.getKeyCode(), event);
}
}
mCurrentKeyEventResult = result;
}
private void processFocusEvent() {
// Get event information.
if (mRootLayer != null) {
}
}
private Layer hitTest(float x, float y) {
final ArrayList<Layer> hitTestList = sLists.hitTestList;
for (int i = hitTestList.size() - 1; i >= 0; --i) {
final Layer layer = hitTestList.get(i);
if (layer != null && !layer.mHidden) {
final float layerX = layer.mX;
final float layerY = layer.mY;
if (x >= layerX && y >= layerY && x < layerX + layer.mWidth && y < layerY + layer.mHeight
&& layer.containsPoint(x, y)) {
return layer;
}
}
}
return null;
}
private void updateLists() {
if (mRootLayer != null) {
synchronized (sLists) {
sLists.clear();
mRootLayer.generate(this, sLists);
}
}
}
/**
* Called when the OpenGL surface is recreated without destroying the
* context.
*/
public void onSurfaceChanged(GL10 gl1, int width, int height) {
GL11 gl = (GL11) gl1;
mFirstDraw = false;
mViewWidth = width;
mViewHeight = height;
if (mRootLayer != null) {
mRootLayer.setSize(width, height);
}
// Set the viewport and projection matrix.
final float zNear = 0.1f;
final float zFar = 100.0f;
gl.glViewport(0, 0, width, height);
gl.glMatrixMode(GL11.GL_PROJECTION);
gl.glLoadIdentity();
GLU.gluPerspective(gl, 45.0f, (float) width / height, zNear, zFar);
if (mRootLayer != null) {
mRootLayer.onSurfaceChanged(this, width, height);
}
gl.glMatrixMode(GL11.GL_MODELVIEW);
}
public void setFov(float fov) {
GL11 gl = mGL;
gl.glMatrixMode(GL11.GL_PROJECTION);
gl.glLoadIdentity();
final float zNear = 0.1f;
final float zFar = 100.0f;
GLU.gluPerspective(gl, fov, (float) getWidth() / getHeight(), zNear, zFar);
gl.glMatrixMode(GL11.GL_MODELVIEW);
}
/**
* Called when the context is created, possibly after automatic destruction.
*/
public void onSurfaceCreated(GL10 gl1, EGLConfig config) {
// Clear the resource texture cache.
clearCache();
GL11 gl = (GL11) gl1;
if (mGL == null) {
mGL = gl;
} else {
// The GL Object has changed.
Log.i(TAG, "GLObject has changed from " + mGL + " to " + gl);
mGL = gl;
}
if (ENABLE_FPS_TEST) {
setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
} else {
setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
}
// Increase the priority of the render thread.
// This is commented out to give other threads more CPU.
//Process.setThreadPriority(Process.THREAD_PRIORITY_DISPLAY);
// Disable unused state.
gl.glEnable(GL11.GL_DITHER);
gl.glDisable(GL11.GL_LIGHTING);
// Set global state.
// gl.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
// Enable textures.
gl.glEnable(GL11.GL_TEXTURE_2D);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_REPLACE);
// Set up state for multitexture operations. Since multitexture is
// currently used
// only for layered crossfades the needed state can be factored out into
// one-time
// initialization. This section may need to be folded into drawMixed2D()
// if multitexture
// is used for other effects.
// Enable Vertex Arrays
gl.glEnableClientState(GL11.GL_VERTEX_ARRAY);
gl.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
gl.glClientActiveTexture(GL11.GL_TEXTURE1);
gl.glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
gl.glClientActiveTexture(GL11.GL_TEXTURE0);
// Enable depth test.
gl.glEnable(GL11.GL_DEPTH_TEST);
gl.glDepthFunc(GL11.GL_LEQUAL);
// Set the blend function for premultiplied alpha.
gl.glBlendFunc(GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
// Set the background color.
gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
gl.glClear(GL11.GL_COLOR_BUFFER_BIT);
// Start reloading textures if the context was automatically destroyed.
if (!mActiveTextureList.isEmpty()) {
DirectLinkedList.Entry<TextureReference> iter = mActiveTextureList.getHead();
while (iter != null) {
final Texture texture = iter.value.get();
if (texture != null) {
texture.mState = Texture.STATE_UNLOADED;
}
iter = iter.next;
}
}
mActiveTextureList.clear();
if (mRootLayer != null) {
mRootLayer.onSurfaceCreated(this, gl);
}
synchronized (sLists) {
ArrayList<Layer> systemList = sLists.systemList;
for (int i = systemList.size() - 1; i >= 0; --i) {
systemList.get(i).onSurfaceCreated(this, gl);
}
}
}
/** Indicates that the accuracy of a sensor value has changed. */
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}
/** Indicates that a sensor value has changed. */
public void onSensorChanged(SensorEvent event) {
final int type = event.sensor.getType();
if (!mPendingSensorEvent && type == Sensor.TYPE_ACCELEROMETER) {
final SensorEvent e = event;
if (mRootLayer != null)
mRootLayer.onSensorChanged(RenderView.this, e);
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
// Ignore events received before the surface is created to avoid
// deadlocking with GLSurfaceView's needToWait().
if (mGL == null) {
return false;
}
// Wait for the render thread to process this event.
if (mTouchEventQueue.size() > 8 && event.getAction() == MotionEvent.ACTION_MOVE)
return true;
synchronized (mTouchEventQueue) {
MotionEvent eventCopy = MotionEvent.obtain(event);
mTouchEventQueue.addLast(eventCopy);
requestRender();
}
return true;
}
@Override
protected void onFocusChanged(boolean gainFocus, int direction, Rect previouslyFocusedRect) {
super.onFocusChanged(gainFocus, direction, previouslyFocusedRect);
// Ignore events received before the surface is created to avoid
// deadlocking with GLSurfaceView's needToWait().
/*
* if (mGL == null) { return; }
*
* // Wait for the render thread to process this event. try {
* synchronized (this) { mCurrentFocusEventGain = gainFocus;
* mCurrentFocusEventDirection = direction; mCurrentEventType =
* EVENT_FOCUS; do { wait(); } while (mCurrentEventType != EVENT_NONE);
* } } catch (InterruptedException e) { // Stop waiting for the render
* thread if interrupted. }
*/
requestRender();
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
// Ignore events received before the surface is created to avoid
// deadlocking with GLSurfaceView's needToWait().
if (mGL == null) {
return false;
}
// Wait for the render thread to process this event.
try {
synchronized (this) {
mCurrentKeyEvent = event;
mCurrentEventType = EVENT_KEY;
requestRender();
long timeout = SystemClock.uptimeMillis() + 50;
do {
wait(50);
} while (mCurrentEventType != EVENT_NONE && SystemClock.uptimeMillis() < timeout);
}
} catch (InterruptedException e) {
// Stop waiting for the render thread if interrupted.
}
// Key events are handled on the main thread.
boolean retVal = false;
if (!mCurrentKeyEventResult) {
retVal = super.onKeyDown(keyCode, event);
} else {
retVal = true;
}
requestRender();
return retVal;
}
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
super.surfaceDestroyed(holder);
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
}
private final class TextureLoadThread extends Thread {
public boolean mIsLoading;
public TextureLoadThread() {
super("TextureLoad");
}
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
Deque<Texture> inputQueue = (sVideoTextureLoadThread == this) ? sLoadInputQueueVideo
: ((sCachedTextureLoadThread == this) ? sLoadInputQueueCached : sLoadInputQueue);
Deque<Texture> outputQueue = sLoadOutputQueue;
try {
for (;;) {
// Pop the next texture from the input queue.
Texture texture = null;
synchronized (inputQueue) {
while ((texture = inputQueue.pollFirst()) == null) {
inputQueue.wait();
}
}
if (sCachedTextureLoadThread != this)
mIsLoading = true;
// Load the texture bitmap.
load(texture);
mIsLoading = false;
// Push the texture onto the output queue.
synchronized (outputQueue) {
outputQueue.addLast(texture);
}
}
} catch (InterruptedException e) {
// Terminate the thread.
}
}
private void load(Texture texture) {
// Generate the texture bitmap.
RenderView view = RenderView.this;
view.loadTextureAsync(texture);
view.requestRender();
}
}
public void shutdown() {
mRootLayer = null;
synchronized (sLists) {
sLists.clear();
}
}
public void handleLowMemory() {
Log.i(TAG, "Handling low memory condition");
if (mRootLayer != null) {
mRootLayer.handleLowMemory();
}
}
public Lists getLists() {
return sLists;
}
}