| /* |
| * Copyright (C) 2015 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.android.tv.ui; |
| |
| import android.animation.Animator; |
| import android.animation.AnimatorListenerAdapter; |
| import android.animation.ArgbEvaluator; |
| import android.animation.ObjectAnimator; |
| import android.animation.TimeInterpolator; |
| import android.animation.TypeEvaluator; |
| import android.animation.ValueAnimator; |
| import android.animation.ValueAnimator.AnimatorUpdateListener; |
| import android.app.Activity; |
| import android.content.Context; |
| import android.content.SharedPreferences; |
| import android.content.res.Resources; |
| import android.graphics.Point; |
| import android.hardware.display.DisplayManager; |
| import android.os.Build; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.preference.PreferenceManager; |
| import android.util.Log; |
| import android.util.Property; |
| import android.view.Display; |
| import android.view.ViewGroup; |
| import android.view.ViewGroup.LayoutParams; |
| import android.view.ViewGroup.MarginLayoutParams; |
| import android.view.animation.AnimationUtils; |
| import android.widget.FrameLayout; |
| |
| import com.android.tv.Features; |
| import com.android.tv.R; |
| import com.android.tv.TvOptionsManager; |
| import com.android.tv.data.DisplayMode; |
| import com.android.tv.util.TvSettings; |
| |
| /** |
| * The TvViewUiManager is responsible for handling UI layouting and animation of main TvView. |
| * It also control the settings regarding TvView UI such as display mode. |
| */ |
| public class TvViewUiManager { |
| private static final String TAG = "TvViewManager"; |
| private static final boolean DEBUG = false; |
| |
| private static final float DISPLAY_MODE_EPSILON = 0.001f; |
| private static final float DISPLAY_ASPECT_RATIO_EPSILON = 0.01f; |
| |
| private static final int MSG_SET_LAYOUT_PARAMS = 1000; |
| |
| private final Context mContext; |
| private final Resources mResources; |
| private final FrameLayout mContentView; |
| private final TunableTvView mTvView; |
| private final TvOptionsManager mTvOptionsManager; |
| private final int mTvViewShrunkenStartMargin; |
| private final int mTvViewShrunkenEndMargin; |
| private int mWindowWidth; |
| private int mWindowHeight; |
| private final SharedPreferences mSharedPreferences; |
| private final TimeInterpolator mLinearOutSlowIn; |
| private final TimeInterpolator mFastOutLinearIn; |
| private final Handler mHandler = |
| new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_SET_LAYOUT_PARAMS: |
| FrameLayout.LayoutParams layoutParams = |
| (FrameLayout.LayoutParams) msg.obj; |
| if (DEBUG) { |
| Log.d( |
| TAG, |
| "setFixedSize: w=" |
| + layoutParams.width |
| + " h=" |
| + layoutParams.height); |
| } |
| mTvView.setTvViewLayoutParams(layoutParams); |
| mTvView.setLayoutParams(mTvViewFrame); |
| // Smooth PIP size change, we don't change surface size when |
| // isInPictureInPictureMode is true. |
| if (!Features.PICTURE_IN_PICTURE.isEnabled(mContext) |
| || (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N |
| && !((Activity) mContext).isInPictureInPictureMode())) { |
| mTvView.setFixedSurfaceSize( |
| layoutParams.width, layoutParams.height); |
| } |
| break; |
| } |
| } |
| }; |
| private int mDisplayMode; |
| // Used to restore the previous state from ShrunkenTvView state. |
| private int mTvViewStartMarginBeforeShrunken; |
| private int mTvViewEndMarginBeforeShrunken; |
| private int mDisplayModeBeforeShrunken; |
| private boolean mIsUnderShrunkenTvView; |
| private int mTvViewStartMargin; |
| private int mTvViewEndMargin; |
| private ObjectAnimator mTvViewAnimator; |
| private FrameLayout.LayoutParams mTvViewLayoutParams; |
| // TV view's position when the display mode is FULL. It is used to compute PIP location relative |
| // to TV view's position. |
| private FrameLayout.LayoutParams mTvViewFrame; |
| private FrameLayout.LayoutParams mLastAnimatedTvViewFrame; |
| private FrameLayout.LayoutParams mOldTvViewFrame; |
| private ObjectAnimator mBackgroundAnimator; |
| private int mBackgroundColor; |
| private int mAppliedDisplayedMode = DisplayMode.MODE_NOT_DEFINED; |
| private int mAppliedTvViewStartMargin; |
| private int mAppliedTvViewEndMargin; |
| private float mAppliedVideoDisplayAspectRatio; |
| |
| public TvViewUiManager(Context context, TunableTvView tvView, |
| FrameLayout contentView, TvOptionsManager tvOptionManager) { |
| mContext = context; |
| mResources = mContext.getResources(); |
| mTvView = tvView; |
| mContentView = contentView; |
| mTvOptionsManager = tvOptionManager; |
| |
| DisplayManager displayManager = (DisplayManager) mContext |
| .getSystemService(Context.DISPLAY_SERVICE); |
| Display display = displayManager.getDisplay(Display.DEFAULT_DISPLAY); |
| Point size = new Point(); |
| display.getSize(size); |
| mWindowWidth = size.x; |
| mWindowHeight = size.y; |
| |
| // Have an assumption that TvView Shrinking happens only in full screen. |
| mTvViewShrunkenStartMargin = mResources |
| .getDimensionPixelOffset(R.dimen.shrunken_tvview_margin_start); |
| mTvViewShrunkenEndMargin = |
| mResources.getDimensionPixelOffset(R.dimen.shrunken_tvview_margin_end) |
| + mResources.getDimensionPixelSize(R.dimen.side_panel_width); |
| mTvViewFrame = createMarginLayoutParams(0, 0, 0, 0); |
| |
| mSharedPreferences = PreferenceManager.getDefaultSharedPreferences(mContext); |
| |
| mLinearOutSlowIn = AnimationUtils |
| .loadInterpolator(mContext, android.R.interpolator.linear_out_slow_in); |
| mFastOutLinearIn = AnimationUtils |
| .loadInterpolator(mContext, android.R.interpolator.fast_out_linear_in); |
| } |
| |
| public void onConfigurationChanged(final int windowWidth, final int windowHeight) { |
| if (windowWidth > 0 && windowHeight > 0) { |
| if (mWindowWidth != windowWidth || mWindowHeight != windowHeight) { |
| mWindowWidth = windowWidth; |
| mWindowHeight = windowHeight; |
| applyDisplayMode(mTvView.getVideoDisplayAspectRatio(), false, true); |
| } |
| } |
| } |
| |
| /** |
| * Initializes animator in advance of using the animator to improve animation performance. |
| * For fast first tune, it is not expected to be called in Activity.onCreate, but called |
| * a few seconds later after onCreate. |
| */ |
| public void initAnimatorIfNeeded() { |
| initTvAnimatorIfNeeded(); |
| initBackgroundAnimatorIfNeeded(); |
| } |
| |
| /** |
| * It is called when shrunken TvView is desired, such as EditChannelFragment and |
| * ChannelsLockedFragment. |
| */ |
| public void startShrunkenTvView() { |
| mIsUnderShrunkenTvView = true; |
| mTvView.setIsUnderShrunken(true); |
| |
| mTvViewStartMarginBeforeShrunken = mTvViewStartMargin; |
| mTvViewEndMarginBeforeShrunken = mTvViewEndMargin; |
| setTvViewMargin(mTvViewShrunkenStartMargin, mTvViewShrunkenEndMargin); |
| mDisplayModeBeforeShrunken = setDisplayMode(DisplayMode.MODE_NORMAL, false, true); |
| } |
| |
| /** |
| * It is called when shrunken TvView is no longer desired, such as EditChannelFragment and |
| * ChannelsLockedFragment. |
| */ |
| public void endShrunkenTvView() { |
| mIsUnderShrunkenTvView = false; |
| mTvView.setIsUnderShrunken(false); |
| setTvViewMargin(mTvViewStartMarginBeforeShrunken, mTvViewEndMarginBeforeShrunken); |
| setDisplayMode(mDisplayModeBeforeShrunken, false, true); |
| } |
| |
| /** |
| * Returns true, if TvView is shrunken. |
| */ |
| public boolean isUnderShrunkenTvView() { |
| return mIsUnderShrunkenTvView; |
| } |
| |
| /** |
| * Returns true, if {@code displayMode} is available now. If screen ratio is matched to |
| * video ratio, other display modes than {@link DisplayMode#MODE_NORMAL} are not available. |
| */ |
| public boolean isDisplayModeAvailable(int displayMode) { |
| if (displayMode == DisplayMode.MODE_NORMAL) { |
| return true; |
| } |
| |
| int viewWidth = mContentView.getWidth(); |
| int viewHeight = mContentView.getHeight(); |
| |
| float videoDisplayAspectRatio = mTvView.getVideoDisplayAspectRatio(); |
| if (viewWidth <= 0 || viewHeight <= 0 || videoDisplayAspectRatio <= 0f) { |
| Log.w(TAG, "Video size is currently unavailable"); |
| if (DEBUG) { |
| Log.d(TAG, "isDisplayModeAvailable: " |
| + "viewWidth=" + viewWidth |
| + ", viewHeight=" + viewHeight |
| + ", videoDisplayAspectRatio=" + videoDisplayAspectRatio |
| ); |
| } |
| return false; |
| } |
| |
| float viewRatio = viewWidth / (float) viewHeight; |
| return Math.abs(viewRatio - videoDisplayAspectRatio) >= DISPLAY_MODE_EPSILON; |
| } |
| |
| /** |
| * Returns a constant defined in DisplayMode. |
| */ |
| public int getDisplayMode() { |
| if (isDisplayModeAvailable(mDisplayMode)) { |
| return mDisplayMode; |
| } |
| return DisplayMode.MODE_NORMAL; |
| } |
| |
| /** |
| * Sets the display mode to the given value. |
| * |
| * @return the previous display mode. |
| */ |
| public int setDisplayMode(int displayMode, boolean storeInPreference, boolean animate) { |
| int prev = mDisplayMode; |
| mDisplayMode = displayMode; |
| if (storeInPreference) { |
| mSharedPreferences.edit().putInt(TvSettings.PREF_DISPLAY_MODE, displayMode).apply(); |
| } |
| applyDisplayMode(mTvView.getVideoDisplayAspectRatio(), animate, false); |
| return prev; |
| } |
| |
| /** |
| * Restores the display mode to the display mode stored in preference. |
| */ |
| public void restoreDisplayMode(boolean animate) { |
| int displayMode = mSharedPreferences |
| .getInt(TvSettings.PREF_DISPLAY_MODE, DisplayMode.MODE_NORMAL); |
| setDisplayMode(displayMode, false, animate); |
| } |
| |
| /** |
| * Updates TvView's aspect ratio. It should be called when video resolution is changed. |
| */ |
| public void updateTvAspectRatio() { |
| applyDisplayMode(mTvView.getVideoDisplayAspectRatio(), false, false); |
| if (mTvView.isVideoAvailable() && mTvView.isFadedOut()) { |
| mTvView.fadeIn(mResources.getInteger(R.integer.tvview_fade_in_duration), |
| mFastOutLinearIn, null); |
| } |
| } |
| |
| /** |
| * Fades in TvView. |
| */ |
| public void fadeInTvView() { |
| if (mTvView.isFadedOut()) { |
| mTvView.fadeIn(mResources.getInteger(R.integer.tvview_fade_in_duration), |
| mFastOutLinearIn, null); |
| } |
| } |
| |
| /** |
| * Fades out TvView. |
| */ |
| public void fadeOutTvView(Runnable postAction) { |
| if (!mTvView.isFadedOut()) { |
| mTvView.fadeOut(mResources.getInteger(R.integer.tvview_fade_out_duration), |
| mLinearOutSlowIn, postAction); |
| } |
| } |
| |
| /** |
| * This margins will be applied when applyDisplayMode is called. |
| */ |
| private void setTvViewMargin(int tvViewStartMargin, int tvViewEndMargin) { |
| mTvViewStartMargin = tvViewStartMargin; |
| mTvViewEndMargin = tvViewEndMargin; |
| } |
| |
| private boolean isTvViewFullScreen() { |
| return mTvViewStartMargin == 0 && mTvViewEndMargin == 0; |
| } |
| |
| private void setBackgroundColor(int color, FrameLayout.LayoutParams targetLayoutParams, |
| boolean animate) { |
| if (animate) { |
| initBackgroundAnimatorIfNeeded(); |
| if (mBackgroundAnimator.isStarted()) { |
| // Cancel the current animation and start new one. |
| mBackgroundAnimator.cancel(); |
| } |
| |
| int decorViewWidth = mContentView.getWidth(); |
| int decorViewHeight = mContentView.getHeight(); |
| boolean hasPillarBox = mTvView.getWidth() != decorViewWidth |
| || mTvView.getHeight() != decorViewHeight; |
| boolean willHavePillarBox = ((targetLayoutParams.width != LayoutParams.MATCH_PARENT) |
| && targetLayoutParams.width != decorViewWidth) || ( |
| (targetLayoutParams.height != LayoutParams.MATCH_PARENT) |
| && targetLayoutParams.height != decorViewHeight); |
| |
| if (!isTvViewFullScreen() && !hasPillarBox) { |
| // If there is no pillar box, no animation is needed. |
| mContentView.setBackgroundColor(color); |
| } else if (!isTvViewFullScreen() || willHavePillarBox) { |
| mBackgroundAnimator.setIntValues(mBackgroundColor, color); |
| mBackgroundAnimator.setEvaluator(new ArgbEvaluator()); |
| mBackgroundAnimator.setInterpolator(mFastOutLinearIn); |
| mBackgroundAnimator.start(); |
| } |
| // In the 'else' case (TV activity is getting out of the shrunken tv view mode and will |
| // have a pillar box), we keep the background color and don't show the animation. |
| } else { |
| mContentView.setBackgroundColor(color); |
| } |
| mBackgroundColor = color; |
| } |
| |
| private void setTvViewPosition(final FrameLayout.LayoutParams layoutParams, |
| FrameLayout.LayoutParams tvViewFrame, boolean animate) { |
| if (DEBUG) { |
| Log.d(TAG, "setTvViewPosition: w=" + layoutParams.width + " h=" + layoutParams.height |
| + " s=" + layoutParams.getMarginStart() + " t=" + layoutParams.topMargin |
| + " e=" + layoutParams.getMarginEnd() + " b=" + layoutParams.bottomMargin |
| + " animate=" + animate); |
| } |
| FrameLayout.LayoutParams oldTvViewFrame = mTvViewFrame; |
| mTvViewLayoutParams = layoutParams; |
| mTvViewFrame = tvViewFrame; |
| if (animate) { |
| initTvAnimatorIfNeeded(); |
| if (mTvViewAnimator.isStarted()) { |
| // Cancel the current animation and start new one. |
| mTvViewAnimator.cancel(); |
| mOldTvViewFrame = new FrameLayout.LayoutParams(mLastAnimatedTvViewFrame); |
| } else { |
| mOldTvViewFrame = new FrameLayout.LayoutParams(oldTvViewFrame); |
| } |
| mTvViewAnimator.setObjectValues(mTvView.getTvViewLayoutParams(), layoutParams); |
| mTvViewAnimator.setEvaluator(new TypeEvaluator<FrameLayout.LayoutParams>() { |
| FrameLayout.LayoutParams lp; |
| @Override |
| public FrameLayout.LayoutParams evaluate(float fraction, |
| FrameLayout.LayoutParams startValue, FrameLayout.LayoutParams endValue) { |
| if (lp == null) { |
| lp = new FrameLayout.LayoutParams(0, 0); |
| lp.gravity = startValue.gravity; |
| } |
| interpolateMargins(lp, startValue, endValue, fraction); |
| return lp; |
| } |
| }); |
| mTvViewAnimator |
| .setInterpolator(isTvViewFullScreen() ? mFastOutLinearIn : mLinearOutSlowIn); |
| mTvViewAnimator.start(); |
| } else { |
| if (mTvViewAnimator != null && mTvViewAnimator.isStarted()) { |
| // Continue the current animation. |
| // layoutParams will be applied when animation ends. |
| return; |
| } |
| // This block is also called when animation ends. |
| if (isTvViewFullScreen()) { |
| // When this layout is for full screen, fix the surface size after layout to make |
| // resize animation smooth. During PIP size change, the multiple messages can be |
| // queued, if we don't remove MSG_SET_LAYOUT_PARAMS. |
| mHandler.removeMessages(MSG_SET_LAYOUT_PARAMS); |
| mHandler.obtainMessage(MSG_SET_LAYOUT_PARAMS, layoutParams).sendToTarget(); |
| } else { |
| mTvView.setTvViewLayoutParams(layoutParams); |
| mTvView.setLayoutParams(mTvViewFrame); |
| } |
| } |
| } |
| |
| private void initTvAnimatorIfNeeded() { |
| if (mTvViewAnimator != null) { |
| return; |
| } |
| |
| // TvViewAnimator animates TvView by repeatedly re-layouting TvView. |
| // TvView includes a SurfaceView on which scale/translation effects do not work. Normally, |
| // SurfaceView can be animated by changing left/top/right/bottom directly using |
| // ObjectAnimator, although it would require calling getChildAt(0) against TvView (which is |
| // supposed to be opaque). More importantly, this method does not work in case of TvView, |
| // because TvView may request layout itself during animation and layout SurfaceView with |
| // its own parameters when TvInputService requests to do so. |
| mTvViewAnimator = new ObjectAnimator(); |
| mTvViewAnimator.setTarget(mTvView.getTvView()); |
| mTvViewAnimator.setProperty( |
| Property.of(FrameLayout.class, ViewGroup.LayoutParams.class, "layoutParams")); |
| mTvViewAnimator.setDuration(mResources.getInteger(R.integer.tvview_anim_duration)); |
| mTvViewAnimator.addListener(new AnimatorListenerAdapter() { |
| private boolean mCanceled = false; |
| |
| @Override |
| public void onAnimationCancel(Animator animation) { |
| mCanceled = true; |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| if (mCanceled) { |
| mCanceled = false; |
| return; |
| } |
| mHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| setTvViewPosition(mTvViewLayoutParams, mTvViewFrame, false); |
| } |
| }); |
| } |
| }); |
| mTvViewAnimator.addUpdateListener(new AnimatorUpdateListener() { |
| @Override |
| public void onAnimationUpdate(ValueAnimator animator) { |
| float fraction = animator.getAnimatedFraction(); |
| mLastAnimatedTvViewFrame = (FrameLayout.LayoutParams) mTvView.getLayoutParams(); |
| interpolateMargins(mLastAnimatedTvViewFrame, |
| mOldTvViewFrame, mTvViewFrame, fraction); |
| mTvView.setLayoutParams(mLastAnimatedTvViewFrame); |
| } |
| }); |
| } |
| |
| private void initBackgroundAnimatorIfNeeded() { |
| if (mBackgroundAnimator != null) { |
| return; |
| } |
| |
| mBackgroundAnimator = new ObjectAnimator(); |
| mBackgroundAnimator.setTarget(mContentView); |
| mBackgroundAnimator.setPropertyName("backgroundColor"); |
| mBackgroundAnimator |
| .setDuration(mResources.getInteger(R.integer.tvactivity_background_anim_duration)); |
| mBackgroundAnimator.addListener(new AnimatorListenerAdapter() { |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mHandler.post(new Runnable() { |
| @Override |
| public void run() { |
| mContentView.setBackgroundColor(mBackgroundColor); |
| } |
| }); |
| } |
| }); |
| } |
| |
| private void applyDisplayMode(float videoDisplayAspectRatio, boolean animate, |
| boolean forceUpdate) { |
| if (videoDisplayAspectRatio <= 0f) { |
| videoDisplayAspectRatio = (float) mWindowWidth / mWindowHeight; |
| } |
| if (mAppliedDisplayedMode == mDisplayMode |
| && mAppliedTvViewStartMargin == mTvViewStartMargin |
| && mAppliedTvViewEndMargin == mTvViewEndMargin |
| && Math.abs(mAppliedVideoDisplayAspectRatio - videoDisplayAspectRatio) < |
| DISPLAY_ASPECT_RATIO_EPSILON) { |
| if (!forceUpdate) { |
| return; |
| } |
| } else { |
| mAppliedDisplayedMode = mDisplayMode; |
| mAppliedTvViewStartMargin = mTvViewStartMargin; |
| mAppliedTvViewEndMargin = mTvViewEndMargin; |
| mAppliedVideoDisplayAspectRatio = videoDisplayAspectRatio; |
| } |
| int availableAreaWidth = mWindowWidth - mTvViewStartMargin - mTvViewEndMargin; |
| int availableAreaHeight = availableAreaWidth * mWindowHeight / mWindowWidth; |
| int displayMode = mDisplayMode; |
| float availableAreaRatio = 0; |
| if (availableAreaWidth <= 0 || availableAreaHeight <= 0) { |
| displayMode = DisplayMode.MODE_FULL; |
| Log.w(TAG, "Some resolution info is missing during applyDisplayMode. (" |
| + "availableAreaWidth=" + availableAreaWidth + ", availableAreaHeight=" |
| + availableAreaHeight + ")"); |
| } else { |
| availableAreaRatio = (float) availableAreaWidth / availableAreaHeight; |
| } |
| FrameLayout.LayoutParams layoutParams = new FrameLayout.LayoutParams(0, 0, |
| ((FrameLayout.LayoutParams) mTvView.getTvViewLayoutParams()).gravity); |
| switch (displayMode) { |
| case DisplayMode.MODE_ZOOM: |
| if (videoDisplayAspectRatio < availableAreaRatio) { |
| // Y axis will be clipped. |
| layoutParams.width = availableAreaWidth; |
| layoutParams.height = Math.round(availableAreaWidth / videoDisplayAspectRatio); |
| } else { |
| // X axis will be clipped. |
| layoutParams.width = Math.round(availableAreaHeight * videoDisplayAspectRatio); |
| layoutParams.height = availableAreaHeight; |
| } |
| break; |
| case DisplayMode.MODE_NORMAL: |
| if (videoDisplayAspectRatio < availableAreaRatio) { |
| // X axis has black area. |
| layoutParams.width = Math.round(availableAreaHeight * videoDisplayAspectRatio); |
| layoutParams.height = availableAreaHeight; |
| } else { |
| // Y axis has black area. |
| layoutParams.width = availableAreaWidth; |
| layoutParams.height = Math.round(availableAreaWidth / videoDisplayAspectRatio); |
| } |
| break; |
| case DisplayMode.MODE_FULL: |
| default: |
| layoutParams.width = availableAreaWidth; |
| layoutParams.height = availableAreaHeight; |
| break; |
| } |
| // FrameLayout has an issue with centering when left and right margins differ. |
| // So stick to Gravity.START | Gravity.CENTER_VERTICAL. |
| int marginStart = (availableAreaWidth - layoutParams.width) / 2; |
| layoutParams.setMarginStart(marginStart); |
| int tvViewFrameTop = (mWindowHeight - availableAreaHeight) / 2; |
| FrameLayout.LayoutParams tvViewFrame = createMarginLayoutParams( |
| mTvViewStartMargin, mTvViewEndMargin, tvViewFrameTop, tvViewFrameTop); |
| setTvViewPosition(layoutParams, tvViewFrame, animate); |
| setBackgroundColor(mResources.getColor(isTvViewFullScreen() |
| ? R.color.tvactivity_background : R.color.tvactivity_background_on_shrunken_tvview, |
| null), layoutParams, animate); |
| |
| // Update the current display mode. |
| mTvOptionsManager.onDisplayModeChanged(displayMode); |
| } |
| |
| private static int interpolate(int start, int end, float fraction) { |
| return (int) (start + (end - start) * fraction); |
| } |
| |
| private static void interpolateMargins(MarginLayoutParams out, |
| MarginLayoutParams startValue, MarginLayoutParams endValue, float fraction) { |
| out.topMargin = interpolate(startValue.topMargin, endValue.topMargin, fraction); |
| out.bottomMargin = interpolate(startValue.bottomMargin, endValue.bottomMargin, fraction); |
| out.setMarginStart(interpolate(startValue.getMarginStart(), endValue.getMarginStart(), |
| fraction)); |
| out.setMarginEnd(interpolate(startValue.getMarginEnd(), endValue.getMarginEnd(), fraction)); |
| out.width = interpolate(startValue.width, endValue.width, fraction); |
| out.height = interpolate(startValue.height, endValue.height, fraction); |
| } |
| |
| private FrameLayout.LayoutParams createMarginLayoutParams( |
| int startMargin, int endMargin, int topMargin, int bottomMargin) { |
| FrameLayout.LayoutParams lp = new FrameLayout.LayoutParams(0, 0); |
| lp.setMarginStart(startMargin); |
| lp.setMarginEnd(endMargin); |
| lp.topMargin = topMargin; |
| lp.bottomMargin = bottomMargin; |
| lp.width = mWindowWidth - startMargin - endMargin; |
| lp.height = mWindowHeight - topMargin - bottomMargin; |
| return lp; |
| } |
| } |
