| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| package org.chromium.chrome.browser.compositor; |
| |
| import android.app.Activity; |
| import android.content.Context; |
| import android.graphics.Color; |
| import android.graphics.PixelFormat; |
| import android.graphics.Rect; |
| import android.view.MotionEvent; |
| import android.view.Surface; |
| import android.view.SurfaceHolder; |
| import android.view.SurfaceView; |
| import android.view.View; |
| |
| import org.chromium.base.ApiCompatibilityUtils; |
| import org.chromium.base.CommandLine; |
| import org.chromium.base.Log; |
| import org.chromium.base.TraceEvent; |
| import org.chromium.base.VisibleForTesting; |
| import org.chromium.base.annotations.CalledByNative; |
| import org.chromium.base.annotations.JNINamespace; |
| import org.chromium.chrome.R; |
| import org.chromium.chrome.browser.ChromeSwitches; |
| import org.chromium.chrome.browser.compositor.layouts.Layout; |
| import org.chromium.chrome.browser.compositor.layouts.Layout.SizingFlags; |
| import org.chromium.chrome.browser.compositor.layouts.LayoutProvider; |
| import org.chromium.chrome.browser.compositor.layouts.LayoutRenderHost; |
| import org.chromium.chrome.browser.compositor.layouts.components.LayoutTab; |
| import org.chromium.chrome.browser.compositor.layouts.content.ContentOffsetProvider; |
| import org.chromium.chrome.browser.compositor.layouts.content.TabContentManager; |
| import org.chromium.chrome.browser.compositor.resources.StaticResourcePreloads; |
| import org.chromium.chrome.browser.compositor.scene_layer.SceneLayer; |
| import org.chromium.chrome.browser.device.DeviceClassManager; |
| import org.chromium.chrome.browser.externalnav.IntentWithGesturesHandler; |
| import org.chromium.chrome.browser.fullscreen.ChromeFullscreenManager; |
| import org.chromium.chrome.browser.multiwindow.MultiWindowUtils; |
| import org.chromium.chrome.browser.tabmodel.TabModelImpl; |
| import org.chromium.chrome.browser.widget.ClipDrawableProgressBar.DrawingInfo; |
| import org.chromium.ui.base.DeviceFormFactor; |
| import org.chromium.ui.base.WindowAndroid; |
| import org.chromium.ui.resources.AndroidResourceType; |
| import org.chromium.ui.resources.ResourceManager; |
| |
| /** |
| * The is the {@link View} displaying the ui compositor results; including webpages and tabswitcher. |
| */ |
| @JNINamespace("chrome::android") |
| public class CompositorView |
| extends SurfaceView implements ContentOffsetProvider, SurfaceHolder.Callback2 { |
| private static final String TAG = "CompositorView"; |
| |
| // Cache objects that should not be created every frame |
| private final Rect mCacheViewport = new Rect(); |
| private final Rect mCacheAppRect = new Rect(); |
| private final Rect mCacheVisibleViewport = new Rect(); |
| private final int[] mCacheViewPosition = new int[2]; |
| |
| private long mNativeCompositorView; |
| private final LayoutRenderHost mRenderHost; |
| private boolean mEnableTabletTabStack; |
| private int mPreviousWindowTop = -1; |
| |
| private int mLastLayerCount; |
| |
| // Resource Management |
| private ResourceManager mResourceManager; |
| |
| // Lazily populated as it is needed. |
| private View mRootActivityView; |
| private WindowAndroid mWindowAndroid; |
| private LayerTitleCache mLayerTitleCache; |
| private TabContentManager mTabContentManager; |
| |
| private View mRootView; |
| private int mSurfaceWidth; |
| private int mSurfaceHeight; |
| private boolean mPreloadedResources; |
| |
| // The current SurfaceView pixel format. Defaults to OPAQUE. |
| private int mCurrentPixelFormat = PixelFormat.OPAQUE; |
| |
| /** |
| * Creates a {@link CompositorView}. This can be called only after the native library is |
| * properly loaded. |
| * @param c The Context to create this {@link CompositorView} in. |
| * @param host The renderer host owning this view. |
| */ |
| public CompositorView(Context c, LayoutRenderHost host) { |
| super(c); |
| mRenderHost = host; |
| resetFlags(); |
| setVisibility(View.INVISIBLE); |
| setZOrderMediaOverlay(true); |
| } |
| |
| /** |
| * @param view The root view of the hierarchy. |
| */ |
| public void setRootView(View view) { |
| mRootView = view; |
| } |
| |
| /** |
| * Reset the commandline flags. This gets called after we switch over to the |
| * native command line. |
| */ |
| public void resetFlags() { |
| CommandLine commandLine = CommandLine.getInstance(); |
| mEnableTabletTabStack = commandLine.hasSwitch(ChromeSwitches.ENABLE_TABLET_TAB_STACK) |
| && DeviceFormFactor.isTablet(getContext()); |
| } |
| |
| @Override |
| protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { |
| if (mRootView != null) { |
| mRootView.getWindowVisibleDisplayFrame(mCacheAppRect); |
| |
| // Check whether the top position of the window has changed as we always must |
| // resize in that case to the specified height spec. On certain versions of |
| // Android when you change the top position (i.e. by leaving fullscreen) and |
| // do not shrink the SurfaceView, it will appear to be pinned to the top of |
| // the screen under the notification bar and all touch offsets will be wrong |
| // as well as a gap will appear at the bottom of the screen. |
| int windowTop = mCacheAppRect.top; |
| boolean topChanged = windowTop != mPreviousWindowTop; |
| mPreviousWindowTop = windowTop; |
| |
| Activity activity = mWindowAndroid != null ? mWindowAndroid.getActivity().get() : null; |
| boolean isMultiWindow = MultiWindowUtils.getInstance().isMultiWindow(activity); |
| |
| // If the measured width is the same as the allowed width (i.e. the orientation has |
| // not changed) and multi-window mode is off, use the largest measured height seen thus |
| // far. This will prevent surface resizes as a result of showing the keyboard. |
| if (!topChanged && !isMultiWindow |
| && getMeasuredWidth() == MeasureSpec.getSize(widthMeasureSpec) |
| && getMeasuredHeight() > MeasureSpec.getSize(heightMeasureSpec)) { |
| heightMeasureSpec = |
| MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY); |
| } |
| } |
| super.onMeasure(widthMeasureSpec, heightMeasureSpec); |
| } |
| |
| @Override |
| protected void onLayout(boolean changed, int left, int top, int right, int bottom) { |
| super.onLayout(changed, left, top, right, bottom); |
| } |
| |
| @Override |
| protected void onDetachedFromWindow() { |
| super.onDetachedFromWindow(); |
| mPreviousWindowTop = -1; |
| } |
| |
| /** |
| * @return The ResourceManager. |
| */ |
| public ResourceManager getResourceManager() { |
| return mResourceManager; |
| } |
| |
| /** |
| * Should be called for cleanup when the CompositorView instance is no longer used. |
| */ |
| public void shutDown() { |
| getHolder().removeCallback(this); |
| if (mNativeCompositorView != 0) nativeDestroy(mNativeCompositorView); |
| mNativeCompositorView = 0; |
| } |
| |
| /** |
| * Initializes the {@link CompositorView}'s native parts (e.g. the rendering parts). |
| * @param lowMemDevice If this is a low memory device. |
| * @param windowAndroid A {@link WindowAndroid} instance. |
| * @param layerTitleCache A {@link LayerTitleCache} instance. |
| * @param tabContentManager A {@link TabContentManager} instance. |
| */ |
| public void initNativeCompositor(boolean lowMemDevice, WindowAndroid windowAndroid, |
| LayerTitleCache layerTitleCache, TabContentManager tabContentManager) { |
| mWindowAndroid = windowAndroid; |
| mLayerTitleCache = layerTitleCache; |
| mTabContentManager = tabContentManager; |
| |
| mNativeCompositorView = nativeInit(lowMemDevice, |
| ApiCompatibilityUtils.getColor(getResources(), R.color.tab_switcher_background), |
| windowAndroid.getNativePointer(), layerTitleCache, tabContentManager); |
| |
| assert !getHolder().getSurface().isValid() |
| : "Surface created before native library loaded."; |
| getHolder().addCallback(this); |
| |
| // Cover the black surface before it has valid content. |
| setBackgroundColor(Color.WHITE); |
| setVisibility(View.VISIBLE); |
| |
| // Grab the Resource Manager |
| mResourceManager = nativeGetResourceManager(mNativeCompositorView); |
| } |
| |
| @Override |
| public boolean onTouchEvent(MotionEvent e) { |
| return super.onTouchEvent(e); |
| } |
| |
| /** |
| * Enables/disables overlay video mode. Affects alpha blending on this view. |
| * @param enabled Whether to enter or leave overlay video mode. |
| */ |
| public void setOverlayVideoMode(boolean enabled) { |
| mCurrentPixelFormat = enabled ? PixelFormat.TRANSLUCENT : PixelFormat.OPAQUE; |
| getHolder().setFormat(mCurrentPixelFormat); |
| nativeSetOverlayVideoMode(mNativeCompositorView, enabled); |
| } |
| |
| @Override |
| public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) { |
| if (mNativeCompositorView == 0) return; |
| nativeSurfaceChanged(mNativeCompositorView, format, width, height, holder.getSurface()); |
| mRenderHost.onPhysicalBackingSizeChanged(width, height); |
| mSurfaceWidth = width; |
| mSurfaceHeight = height; |
| } |
| |
| @Override |
| public void surfaceCreated(SurfaceHolder holder) { |
| if (mNativeCompositorView == 0) return; |
| nativeSurfaceCreated(mNativeCompositorView); |
| mRenderHost.onSurfaceCreated(); |
| } |
| |
| @Override |
| public void surfaceDestroyed(SurfaceHolder holder) { |
| if (mNativeCompositorView == 0) return; |
| nativeSurfaceDestroyed(mNativeCompositorView); |
| } |
| |
| @Override |
| public void surfaceRedrawNeeded(SurfaceHolder holder) {} |
| |
| @Override |
| public void onWindowVisibilityChanged(int visibility) { |
| super.onWindowVisibilityChanged(visibility); |
| if (mWindowAndroid == null) return; |
| if (visibility == View.GONE) { |
| mWindowAndroid.onVisibilityChanged(false); |
| } else if (visibility == View.VISIBLE) { |
| mWindowAndroid.onVisibilityChanged(true); |
| } |
| IntentWithGesturesHandler.getInstance().clear(); |
| } |
| |
| @CalledByNative |
| private void onCompositorLayout() { |
| mRenderHost.onCompositorLayout(); |
| } |
| |
| /* |
| * On JellyBean there is a known bug where a crashed producer process |
| * (i.e. GPU process) does not properly disconnect from the BufferQueue, |
| * which means we won't be able to reconnect to it ever again. |
| * This workaround forces the creation of a new Surface. |
| */ |
| @CalledByNative |
| private void onJellyBeanSurfaceDisconnectWorkaround(boolean inOverlayMode) { |
| // There is a bug in JellyBean because of which we will not be able to |
| // reconnect to the existing Surface after we launch a new GPU process. |
| // We simply trick the JB Android code to allocate a new Surface. |
| // It does a strict comparison between the current format and the requested |
| // one, even if they are the same in practice. Furthermore, the format |
| // does not matter here since the producer-side EGL config overwrites it |
| // (but transparency might matter). |
| switch (mCurrentPixelFormat) { |
| case PixelFormat.OPAQUE: |
| mCurrentPixelFormat = PixelFormat.RGBA_8888; |
| break; |
| case PixelFormat.RGBA_8888: |
| mCurrentPixelFormat = inOverlayMode |
| ? PixelFormat.TRANSLUCENT : PixelFormat.OPAQUE; |
| break; |
| case PixelFormat.TRANSLUCENT: |
| mCurrentPixelFormat = PixelFormat.RGBA_8888; |
| break; |
| default: |
| assert false; |
| Log.e(TAG, "Unknown current pixel format."); |
| } |
| getHolder().setFormat(mCurrentPixelFormat); |
| } |
| |
| /** |
| * Request compositor view to render a frame. |
| */ |
| public void requestRender() { |
| if (mNativeCompositorView != 0) nativeSetNeedsComposite(mNativeCompositorView); |
| } |
| |
| @CalledByNative |
| private void onSwapBuffersCompleted(int pendingSwapBuffersCount) { |
| // Clear the color used to cover the uninitialized surface. |
| if (getBackground() != null) { |
| post(new Runnable() { |
| @Override |
| public void run() { |
| setBackgroundResource(0); |
| } |
| }); |
| } |
| |
| mRenderHost.onSwapBuffersCompleted(pendingSwapBuffersCount); |
| } |
| |
| private void updateToolbarLayer(LayoutProvider provider, boolean forRotation, |
| final DrawingInfo progressBarDrawingInfo) { |
| if (forRotation || !DeviceClassManager.enableFullscreen()) return; |
| |
| ChromeFullscreenManager fullscreenManager = provider.getFullscreenManager(); |
| if (fullscreenManager == null) return; |
| |
| float offset = fullscreenManager.getControlOffset(); |
| boolean forceHideTopControlsAndroidView = |
| provider.getActiveLayout().forceHideTopControlsAndroidView(); |
| boolean useTexture = fullscreenManager.drawControlsAsTexture() || offset == 0 |
| || forceHideTopControlsAndroidView; |
| |
| float dpToPx = getContext().getResources().getDisplayMetrics().density; |
| float layoutOffsetDp = provider.getActiveLayout().getTopControlsOffset(offset / dpToPx); |
| boolean validLayoutOffset = !Float.isNaN(layoutOffsetDp); |
| |
| if (validLayoutOffset) { |
| offset = layoutOffsetDp * dpToPx; |
| useTexture = true; |
| } |
| |
| fullscreenManager.setHideTopControlsAndroidView(forceHideTopControlsAndroidView |
| || (validLayoutOffset && layoutOffsetDp != 0.f)); |
| |
| int flags = provider.getActiveLayout().getSizingFlags(); |
| if ((flags & SizingFlags.REQUIRE_FULLSCREEN_SIZE) != 0 |
| && (flags & SizingFlags.ALLOW_TOOLBAR_HIDE) == 0 |
| && (flags & SizingFlags.ALLOW_TOOLBAR_ANIMATE) == 0) { |
| useTexture = false; |
| } |
| |
| nativeUpdateToolbarLayer(mNativeCompositorView, R.id.control_container, |
| mRenderHost.getTopControlsBackgroundColor(), R.drawable.textbox, |
| mRenderHost.getTopControlsUrlBarAlpha(), offset, |
| provider.getActiveLayout().getToolbarBrightness(), |
| useTexture, forceHideTopControlsAndroidView); |
| |
| if (progressBarDrawingInfo == null) return; |
| nativeUpdateProgressBar(mNativeCompositorView, |
| progressBarDrawingInfo.progressBarRect.left, |
| progressBarDrawingInfo.progressBarRect.top, |
| progressBarDrawingInfo.progressBarRect.width(), |
| progressBarDrawingInfo.progressBarRect.height(), |
| progressBarDrawingInfo.progressBarColor, |
| progressBarDrawingInfo.progressBarBackgroundRect.left, |
| progressBarDrawingInfo.progressBarBackgroundRect.top, |
| progressBarDrawingInfo.progressBarBackgroundRect.width(), |
| progressBarDrawingInfo.progressBarBackgroundRect.height(), |
| progressBarDrawingInfo.progressBarBackgroundColor); |
| } |
| |
| /** |
| * Converts the layout into compositor layers. This is to be called on every frame the layout |
| * is changing. |
| * @param provider Provides the layout to be rendered. |
| * @param forRotation Whether or not this is a special draw during a rotation. |
| */ |
| public void finalizeLayers(final LayoutProvider provider, boolean forRotation, |
| final DrawingInfo progressBarDrawingInfo) { |
| TraceEvent.begin("CompositorView:finalizeLayers"); |
| Layout layout = provider.getActiveLayout(); |
| if (layout == null || mNativeCompositorView == 0) { |
| TraceEvent.end("CompositorView:finalizeLayers"); |
| return; |
| } |
| |
| if (!mPreloadedResources) { |
| // Attempt to prefetch any necessary resources |
| mResourceManager.preloadResources(AndroidResourceType.STATIC, |
| StaticResourcePreloads.getSynchronousResources(getContext()), |
| StaticResourcePreloads.getAsynchronousResources(getContext())); |
| mPreloadedResources = true; |
| } |
| |
| // IMPORTANT: Do not do anything that impacts the compositor layer tree before this line. |
| // If you do, you could inadvertently trigger follow up renders. For further information |
| // see dtrainor@, tedchoc@, or klobag@. |
| |
| // TODO(jscholler): change 1.0f to dpToPx once the native part is fully supporting dp. |
| mRenderHost.getVisibleViewport(mCacheVisibleViewport); |
| provider.getViewportPixel(mCacheViewport); |
| nativeSetLayoutViewport(mNativeCompositorView, mCacheViewport.left, mCacheViewport.top, |
| mCacheViewport.width(), mCacheViewport.height(), mCacheVisibleViewport.left, |
| mCacheVisibleViewport.top, 1.0f); |
| |
| // TODO(changwan): move to treeprovider. |
| updateToolbarLayer(provider, forRotation, progressBarDrawingInfo); |
| |
| SceneLayer sceneLayer = |
| provider.getUpdatedActiveSceneLayer(mCacheViewport, mCacheVisibleViewport, |
| mLayerTitleCache, mTabContentManager, mResourceManager, |
| provider.getFullscreenManager()); |
| |
| nativeSetSceneLayer(mNativeCompositorView, sceneLayer); |
| |
| final LayoutTab[] tabs = layout.getLayoutTabsToRender(); |
| final int tabsCount = tabs != null ? tabs.length : 0; |
| mLastLayerCount = tabsCount; |
| TabModelImpl.flushActualTabSwitchLatencyMetric(); |
| nativeFinalizeLayers(mNativeCompositorView); |
| TraceEvent.end("CompositorView:finalizeLayers"); |
| } |
| |
| /** |
| * @return The number of layer put the last frame. |
| */ |
| @VisibleForTesting |
| public int getLastLayerCount() { |
| return mLastLayerCount; |
| } |
| |
| @Override |
| public int getOverlayTranslateY() { |
| return mRenderHost.areTopControlsPermanentlyHidden() |
| ? mRenderHost.getTopControlsHeightPixels() |
| : mRenderHost.getVisibleViewport(mCacheVisibleViewport).top; |
| } |
| |
| // Implemented in native |
| private native long nativeInit(boolean lowMemDevice, int emptyColor, long nativeWindowAndroid, |
| LayerTitleCache layerTitleCache, TabContentManager tabContentManager); |
| private native void nativeDestroy(long nativeCompositorView); |
| private native ResourceManager nativeGetResourceManager(long nativeCompositorView); |
| private native void nativeSurfaceCreated(long nativeCompositorView); |
| private native void nativeSurfaceDestroyed(long nativeCompositorView); |
| private native void nativeSurfaceChanged( |
| long nativeCompositorView, int format, int width, int height, Surface surface); |
| private native void nativeFinalizeLayers(long nativeCompositorView); |
| private native void nativeSetNeedsComposite(long nativeCompositorView); |
| private native void nativeSetLayoutViewport(long nativeCompositorView, float x, float y, |
| float width, float height, float visibleXOffset, float visibleYOffset, |
| float dpToPixel); |
| private native void nativeUpdateToolbarLayer(long nativeCompositorView, int resourceId, |
| int toolbarBackgroundColor, int urlBarResourceId, float urlBarAlpha, float topOffset, |
| float brightness, boolean visible, boolean showShadow); |
| private native void nativeUpdateProgressBar( |
| long nativeCompositorView, |
| int progressBarX, |
| int progressBarY, |
| int progressBarWidth, |
| int progressBarHeight, |
| int progressBarColor, |
| int progressBarBackgroundX, |
| int progressBarBackgroundY, |
| int progressBarBackgroundWidth, |
| int progressBarBackgroundHeight, |
| int progressBarBackgroundColor); |
| private native void nativeSetOverlayVideoMode(long nativeCompositorView, boolean enabled); |
| private native void nativeSetSceneLayer(long nativeCompositorView, SceneLayer sceneLayer); |
| } |
