diff --git a/mobile/android/base/Makefile.in b/mobile/android/base/Makefile.in index b60b7620201e..15278ffeb380 100644 --- a/mobile/android/base/Makefile.in +++ b/mobile/android/base/Makefile.in @@ -204,6 +204,7 @@ FENNEC_JAVA_FILES = \ gfx/PointUtils.java \ gfx/ProgressiveUpdateData.java \ gfx/RectUtils.java \ + gfx/RenderTask.java \ gfx/ScrollbarLayer.java \ gfx/SimpleScaleGestureDetector.java \ gfx/SingleTileLayer.java \ diff --git a/mobile/android/base/gfx/LayerRenderer.java b/mobile/android/base/gfx/LayerRenderer.java index fc8256fb977e..b1882fe3ce71 100644 --- a/mobile/android/base/gfx/LayerRenderer.java +++ b/mobile/android/base/gfx/LayerRenderer.java @@ -10,6 +10,7 @@ import org.mozilla.gecko.R; import org.mozilla.gecko.Tab; import org.mozilla.gecko.Tabs; import org.mozilla.gecko.gfx.Layer.RenderContext; +import org.mozilla.gecko.gfx.RenderTask; import org.mozilla.gecko.mozglue.DirectBufferAllocator; import android.content.Context; @@ -50,6 +51,9 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener { private static final int FRAME_RATE_METER_WIDTH = 128; private static final int FRAME_RATE_METER_HEIGHT = 32; + private static final long NANOS_PER_MS = 1000000; + private static final int NANOS_PER_SECOND = 1000000000; + private final LayerView mView; private final NinePatchTileLayer mShadowLayer; private TextLayer mFrameRateLayer; @@ -63,6 +67,9 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener { private int mBackgroundColor; private int mOverscrollColor; + private long mLastFrameTime; + private final CopyOnWriteArrayList mTasks; + private CopyOnWriteArrayList mExtraLayers = new CopyOnWriteArrayList(); // Dropped frames display @@ -138,6 +145,10 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener { Bitmap scrollbarImage = view.getScrollbarImage(); IntSize size = new IntSize(scrollbarImage.getWidth(), scrollbarImage.getHeight()); scrollbarImage = expandCanvasToPowerOfTwo(scrollbarImage, size); + + mTasks = new CopyOnWriteArrayList(); + mLastFrameTime = System.nanoTime(); + mVertScrollLayer = new ScrollbarLayer(this, scrollbarImage, size, true); mHorizScrollLayer = new ScrollbarLayer(this, diagonalFlip(scrollbarImage), new IntSize(size.height, size.width), false); mFadeRunnable = new FadeRunnable(); @@ -241,6 +252,30 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener { return mMaxTextureSize; } + public void postRenderTask(RenderTask aTask) { + mTasks.add(aTask); + mView.requestRender(); + } + + public void removeRenderTask(RenderTask aTask) { + mTasks.remove(aTask); + } + + private void runRenderTasks(CopyOnWriteArrayList tasks, boolean after, long frameStartTime) { + for (RenderTask task : tasks) { + if (task.runAfter != after) { + continue; + } + + boolean stillRunning = task.run(frameStartTime - mLastFrameTime, frameStartTime); + + // Remove the task from the list if its finished + if (!stillRunning) { + tasks.remove(task); + } + } + } + public void addLayer(Layer layer) { synchronized (mExtraLayers) { if (mExtraLayers.contains(layer)) { @@ -299,7 +334,7 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener { } private void updateDroppedFrames(long frameStartTime) { - int frameElapsedTime = (int)(SystemClock.uptimeMillis() - frameStartTime); + int frameElapsedTime = (int)((System.nanoTime() - frameStartTime) / NANOS_PER_MS); /* Update the running statistics. */ mFrameTimingsSum -= mFrameTimings[mCurrentFrame]; @@ -456,7 +491,7 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener { /** This function is invoked via JNI; be careful when modifying signature. */ public void beginDrawing() { - mFrameStartTime = SystemClock.uptimeMillis(); + mFrameStartTime = System.nanoTime(); TextureReaper.get().reap(); TextureGenerator.get().fill(); @@ -465,6 +500,9 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener { Layer rootLayer = mView.getLayerClient().getRoot(); + // Run through pre-render tasks + runRenderTasks(mTasks, false, mFrameStartTime); + if (!mPageContext.fuzzyEquals(mLastPageContext) && !mView.isFullScreen()) { // The viewport or page changed, so show the scrollbars again // as per UX decision. Don't do this if we're in full-screen mode though. @@ -604,12 +642,14 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener { mCompleteFramesRendered += 1.0f - checkerboard; mFramesRendered ++; - if (mFrameStartTime - mProfileOutputTime > 1000) { + if (mFrameStartTime - mProfileOutputTime > NANOS_PER_SECOND) { mProfileOutputTime = mFrameStartTime; printCheckerboardStats(); } } + runRenderTasks(mTasks, true, mFrameStartTime); + /* Draw the FPS. */ if (mFrameRateLayer != null) { updateDroppedFrames(mFrameStartTime); @@ -652,6 +692,7 @@ public class LayerRenderer implements Tabs.OnTabsChangedListener { }); mView.setPaintState(LayerView.PAINT_AFTER_FIRST); } + mLastFrameTime = mFrameStartTime; } } diff --git a/mobile/android/base/gfx/LayerView.java b/mobile/android/base/gfx/LayerView.java index 3c1e705e0696..842395a2bcf9 100644 --- a/mobile/android/base/gfx/LayerView.java +++ b/mobile/android/base/gfx/LayerView.java @@ -401,6 +401,14 @@ public class LayerView extends FrameLayout { mRenderer.removeLayer(layer); } + public void postRenderTask(RenderTask task) { + mRenderer.postRenderTask(task); + } + + public void removeRenderTask(RenderTask task) { + mRenderer.removeRenderTask(task); + } + public int getMaxTextureSize() { return mRenderer.getMaxTextureSize(); } diff --git a/mobile/android/base/gfx/RenderTask.java b/mobile/android/base/gfx/RenderTask.java new file mode 100644 index 000000000000..80cbf77f0a94 --- /dev/null +++ b/mobile/android/base/gfx/RenderTask.java @@ -0,0 +1,80 @@ +/* -*- Mode: Java; c-basic-offset: 4; tab-width: 20; indent-tabs-mode: nil; -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +package org.mozilla.gecko.gfx; + +/** + * A class used to schedule a callback to occur when the next frame is drawn. + * Subclasses must redefine the internalRun method, not the run method. + */ +public abstract class RenderTask { + /** + * Whether to run the task after the render, or before. + */ + public final boolean runAfter; + + /** + * Time when this task has first run, in ns. Useful for tasks which run for a specific duration. + */ + private long mStartTime; + + /** + * Whether we should initialise mStartTime on the next frame run. + */ + private boolean mResetStartTime = true; + + /** + * The callback to run on each frame. timeDelta is the time elapsed since + * the last call, in nanoseconds. Returns true if it should continue + * running, or false if it should be removed from the task queue. Returning + * true implicitly schedules a redraw. + * + * This method first initializes the start time if resetStartTime has been invoked, + * then calls internalRun. + * + * Note : subclasses should override internalRun. + * + * @param timeDelta the time between the beginning of last frame and the beginning of this frame, in ns. + * @param currentFrameStartTime the startTime of the current frame, in ns. + * @return true if animation should be run at the next frame, false otherwise + * @see RenderTask#internalRun(long, long) + */ + public final boolean run(long timeDelta, long currentFrameStartTime) { + if (mResetStartTime) { + mStartTime = currentFrameStartTime; + mResetStartTime = false; + } + return internalRun(timeDelta, currentFrameStartTime); + } + + /** + * Abstract method to be overridden by subclasses. + * @param timeDelta the time between the beginning of last frame and the beginning of this frame, in ns + * @param currentFrameStartTime the startTime of the current frame, in ns. + * @return true if animation should be run at the next frame, false otherwise + */ + protected abstract boolean internalRun(long timeDelta, long currentFrameStartTime); + + public RenderTask(boolean aRunAfter) { + runAfter = aRunAfter; + } + + /** + * Get the start time of this task. + * It is the start time of the first frame this task was run on. + * @return the start time in ns + */ + public long getStartTime() { + return mStartTime; + } + + /** + * Schedule a reset of the recorded start time next time {@link RenderTask#run(long, long)} is run. + * @see RenderTask#getStartTime() + */ + public void resetStartTime() { + mResetStartTime = true; + } +}