718cd3eb70
This CL changes the target of VD specific animators to VectorDrawable, instead of RenderNode. The benefit of doing so is that animators can now detect whether the animation is meaningful by checking whether their VD target is in the display list. If not, that means the VD is not drawing for the current frame, in which case we can be smarter and more power efficient by removing the animator from the list and posting a delayed onFinished listener callback. By setting VD as the animation target, when an ImageView decides to update its drawable from one AVD to something else, we'll be able to detect that the previous AVD is no longer in the display list, and stop providing animation pulse to the stale AVD, which is something we couldn't do previously. This change also handles the case where one AVD instance could be drawn in two different views. Bug: 27441375 Change-Id: Iaad1ed09cfd526276b95db0dd695275c28e074e8
460 lines
16 KiB
C++
460 lines
16 KiB
C++
/*
|
|
* Copyright (C) 2014 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.
|
|
*/
|
|
|
|
#include "Animator.h"
|
|
|
|
#include <inttypes.h>
|
|
#include <set>
|
|
|
|
#include "AnimationContext.h"
|
|
#include "Interpolator.h"
|
|
#include "RenderNode.h"
|
|
#include "RenderProperties.h"
|
|
|
|
namespace android {
|
|
namespace uirenderer {
|
|
|
|
/************************************************************
|
|
* BaseRenderNodeAnimator
|
|
************************************************************/
|
|
|
|
BaseRenderNodeAnimator::BaseRenderNodeAnimator(float finalValue)
|
|
: mTarget(nullptr)
|
|
, mStagingTarget(nullptr)
|
|
, mFinalValue(finalValue)
|
|
, mDeltaValue(0)
|
|
, mFromValue(0)
|
|
, mStagingPlayState(PlayState::NotStarted)
|
|
, mPlayState(PlayState::NotStarted)
|
|
, mHasStartValue(false)
|
|
, mStartTime(0)
|
|
, mDuration(300)
|
|
, mStartDelay(0)
|
|
, mMayRunAsync(true)
|
|
, mPlayTime(0) {
|
|
}
|
|
|
|
BaseRenderNodeAnimator::~BaseRenderNodeAnimator() {
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::checkMutable() {
|
|
// Should be impossible to hit as the Java-side also has guards for this
|
|
LOG_ALWAYS_FATAL_IF(mStagingPlayState != PlayState::NotStarted,
|
|
"Animator has already been started!");
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::setInterpolator(Interpolator* interpolator) {
|
|
checkMutable();
|
|
mInterpolator.reset(interpolator);
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::setStartValue(float value) {
|
|
checkMutable();
|
|
doSetStartValue(value);
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::doSetStartValue(float value) {
|
|
mFromValue = value;
|
|
mDeltaValue = (mFinalValue - mFromValue);
|
|
mHasStartValue = true;
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::setDuration(nsecs_t duration) {
|
|
checkMutable();
|
|
mDuration = duration;
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::setStartDelay(nsecs_t startDelay) {
|
|
checkMutable();
|
|
mStartDelay = startDelay;
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::attach(RenderNode* target) {
|
|
mStagingTarget = target;
|
|
onAttached();
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::start() {
|
|
mStagingPlayState = PlayState::Running;
|
|
mStagingRequests.push_back(Request::Start);
|
|
onStagingPlayStateChanged();
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::cancel() {
|
|
mStagingPlayState = PlayState::Finished;
|
|
mStagingRequests.push_back(Request::Cancel);
|
|
onStagingPlayStateChanged();
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::reset() {
|
|
mStagingPlayState = PlayState::Finished;
|
|
mStagingRequests.push_back(Request::Reset);
|
|
onStagingPlayStateChanged();
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::reverse() {
|
|
mStagingPlayState = PlayState::Reversing;
|
|
mStagingRequests.push_back(Request::Reverse);
|
|
onStagingPlayStateChanged();
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::end() {
|
|
mStagingPlayState = PlayState::Finished;
|
|
mStagingRequests.push_back(Request::End);
|
|
onStagingPlayStateChanged();
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::resolveStagingRequest(Request request) {
|
|
switch (request) {
|
|
case Request::Start:
|
|
mPlayTime = (mPlayState == PlayState::Running || mPlayState == PlayState::Reversing) ?
|
|
mPlayTime : 0;
|
|
mPlayState = PlayState::Running;
|
|
break;
|
|
case Request::Reverse:
|
|
mPlayTime = (mPlayState == PlayState::Running || mPlayState == PlayState::Reversing) ?
|
|
mPlayTime : mDuration;
|
|
mPlayState = PlayState::Reversing;
|
|
break;
|
|
case Request::Reset:
|
|
mPlayTime = 0;
|
|
mPlayState = PlayState::Finished;
|
|
break;
|
|
case Request::Cancel:
|
|
mPlayState = PlayState::Finished;
|
|
break;
|
|
case Request::End:
|
|
mPlayTime = mPlayState == PlayState::Reversing ? 0 : mDuration;
|
|
mPlayState = PlayState::Finished;
|
|
break;
|
|
default:
|
|
LOG_ALWAYS_FATAL("Invalid staging request: %d", static_cast<int>(request));
|
|
};
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::pushStaging(AnimationContext& context) {
|
|
if (mStagingTarget) {
|
|
RenderNode* oldTarget = mTarget;
|
|
mTarget = mStagingTarget;
|
|
mStagingTarget = nullptr;
|
|
if (oldTarget && oldTarget != mTarget) {
|
|
oldTarget->onAnimatorTargetChanged(this);
|
|
}
|
|
}
|
|
|
|
if (!mHasStartValue) {
|
|
doSetStartValue(getValue(mTarget));
|
|
}
|
|
|
|
if (!mStagingRequests.empty()) {
|
|
// No interpolator was set, use the default
|
|
if (mPlayState == PlayState::NotStarted && !mInterpolator) {
|
|
mInterpolator.reset(Interpolator::createDefaultInterpolator());
|
|
}
|
|
// Keep track of the play state and play time before they are changed when
|
|
// staging requests are resolved.
|
|
nsecs_t currentPlayTime = mPlayTime;
|
|
PlayState prevFramePlayState = mPlayState;
|
|
|
|
// Resolve staging requests one by one.
|
|
for (Request request : mStagingRequests) {
|
|
resolveStagingRequest(request);
|
|
}
|
|
mStagingRequests.clear();
|
|
|
|
if (mStagingPlayState == PlayState::Finished) {
|
|
// Set the staging play time and end the animation
|
|
updatePlayTime(mPlayTime);
|
|
callOnFinishedListener(context);
|
|
} else if (mStagingPlayState == PlayState::Running
|
|
|| mStagingPlayState == PlayState::Reversing) {
|
|
bool changed = currentPlayTime != mPlayTime || prevFramePlayState != mStagingPlayState;
|
|
if (prevFramePlayState != mStagingPlayState) {
|
|
transitionToRunning(context);
|
|
}
|
|
if (changed) {
|
|
// Now we need to seek to the stagingPlayTime (i.e. the animation progress that was
|
|
// requested from UI thread). It is achieved by modifying mStartTime, such that
|
|
// current time - mStartTime = stagingPlayTime (or mDuration -stagingPlayTime in the
|
|
// case of reversing)
|
|
nsecs_t currentFrameTime = context.frameTimeMs();
|
|
if (mPlayState == PlayState::Reversing) {
|
|
// Reverse is not supported for animations with a start delay, so here we
|
|
// assume no start delay.
|
|
mStartTime = currentFrameTime - (mDuration - mPlayTime);
|
|
} else {
|
|
// Animation should play forward
|
|
if (mPlayTime == 0) {
|
|
// If the request is to start from the beginning, include start delay.
|
|
mStartTime = currentFrameTime + mStartDelay;
|
|
} else {
|
|
// If the request is to seek to a non-zero play time, then we skip start
|
|
// delay.
|
|
mStartTime = currentFrameTime - mPlayTime;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
onPushStaging();
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::transitionToRunning(AnimationContext& context) {
|
|
nsecs_t frameTimeMs = context.frameTimeMs();
|
|
LOG_ALWAYS_FATAL_IF(frameTimeMs <= 0, "%" PRId64 " isn't a real frame time!", frameTimeMs);
|
|
if (mStartDelay < 0 || mStartDelay > 50000) {
|
|
ALOGW("Your start delay is strange and confusing: %" PRId64, mStartDelay);
|
|
}
|
|
mStartTime = frameTimeMs + mStartDelay;
|
|
if (mStartTime < 0) {
|
|
ALOGW("Ended up with a really weird start time of %" PRId64
|
|
" with frame time %" PRId64 " and start delay %" PRId64,
|
|
mStartTime, frameTimeMs, mStartDelay);
|
|
// Set to 0 so that the animate() basically instantly finishes
|
|
mStartTime = 0;
|
|
}
|
|
if (mDuration < 0) {
|
|
ALOGW("Your duration is strange and confusing: %" PRId64, mDuration);
|
|
}
|
|
}
|
|
|
|
bool BaseRenderNodeAnimator::animate(AnimationContext& context) {
|
|
if (mPlayState < PlayState::Running) {
|
|
return false;
|
|
}
|
|
if (mPlayState == PlayState::Finished) {
|
|
return true;
|
|
}
|
|
|
|
// This should be set before setValue() so animators can query this time when setValue
|
|
// is called.
|
|
nsecs_t currentPlayTime = context.frameTimeMs() - mStartTime;
|
|
bool finished = updatePlayTime(currentPlayTime);
|
|
if (finished && mPlayState != PlayState::Finished) {
|
|
mPlayState = PlayState::Finished;
|
|
callOnFinishedListener(context);
|
|
}
|
|
return finished;
|
|
}
|
|
|
|
bool BaseRenderNodeAnimator::updatePlayTime(nsecs_t playTime) {
|
|
mPlayTime = mPlayState == PlayState::Reversing ? mDuration - playTime : playTime;
|
|
onPlayTimeChanged(mPlayTime);
|
|
// If BaseRenderNodeAnimator is handling the delay (not typical), then
|
|
// because the staging properties reflect the final value, we always need
|
|
// to call setValue even if the animation isn't yet running or is still
|
|
// being delayed as we need to override the staging value
|
|
if (playTime < 0) {
|
|
setValue(mTarget, mFromValue);
|
|
return false;
|
|
}
|
|
|
|
float fraction = 1.0f;
|
|
if ((mPlayState == PlayState::Running || mPlayState == PlayState::Reversing) && mDuration > 0) {
|
|
fraction = mPlayTime / (float) mDuration;
|
|
}
|
|
fraction = MathUtils::clamp(fraction, 0.0f, 1.0f);
|
|
|
|
fraction = mInterpolator->interpolate(fraction);
|
|
setValue(mTarget, mFromValue + (mDeltaValue * fraction));
|
|
|
|
return playTime >= mDuration;
|
|
}
|
|
|
|
nsecs_t BaseRenderNodeAnimator::getRemainingPlayTime() {
|
|
return mPlayState == PlayState::Reversing ? mPlayTime : mDuration - mPlayTime;
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::forceEndNow(AnimationContext& context) {
|
|
if (mPlayState < PlayState::Finished) {
|
|
mPlayState = PlayState::Finished;
|
|
callOnFinishedListener(context);
|
|
}
|
|
}
|
|
|
|
void BaseRenderNodeAnimator::callOnFinishedListener(AnimationContext& context) {
|
|
if (mListener.get()) {
|
|
context.callOnFinished(this, mListener.get());
|
|
}
|
|
}
|
|
|
|
/************************************************************
|
|
* RenderPropertyAnimator
|
|
************************************************************/
|
|
|
|
struct RenderPropertyAnimator::PropertyAccessors {
|
|
RenderNode::DirtyPropertyMask dirtyMask;
|
|
GetFloatProperty getter;
|
|
SetFloatProperty setter;
|
|
};
|
|
|
|
// Maps RenderProperty enum to accessors
|
|
const RenderPropertyAnimator::PropertyAccessors RenderPropertyAnimator::PROPERTY_ACCESSOR_LUT[] = {
|
|
{RenderNode::TRANSLATION_X, &RenderProperties::getTranslationX, &RenderProperties::setTranslationX },
|
|
{RenderNode::TRANSLATION_Y, &RenderProperties::getTranslationY, &RenderProperties::setTranslationY },
|
|
{RenderNode::TRANSLATION_X, &RenderProperties::getTranslationZ, &RenderProperties::setTranslationZ },
|
|
{RenderNode::SCALE_X, &RenderProperties::getScaleX, &RenderProperties::setScaleX },
|
|
{RenderNode::SCALE_Y, &RenderProperties::getScaleY, &RenderProperties::setScaleY },
|
|
{RenderNode::ROTATION, &RenderProperties::getRotation, &RenderProperties::setRotation },
|
|
{RenderNode::ROTATION_X, &RenderProperties::getRotationX, &RenderProperties::setRotationX },
|
|
{RenderNode::ROTATION_Y, &RenderProperties::getRotationY, &RenderProperties::setRotationY },
|
|
{RenderNode::X, &RenderProperties::getX, &RenderProperties::setX },
|
|
{RenderNode::Y, &RenderProperties::getY, &RenderProperties::setY },
|
|
{RenderNode::Z, &RenderProperties::getZ, &RenderProperties::setZ },
|
|
{RenderNode::ALPHA, &RenderProperties::getAlpha, &RenderProperties::setAlpha },
|
|
};
|
|
|
|
RenderPropertyAnimator::RenderPropertyAnimator(RenderProperty property, float finalValue)
|
|
: BaseRenderNodeAnimator(finalValue)
|
|
, mPropertyAccess(&(PROPERTY_ACCESSOR_LUT[property])) {
|
|
}
|
|
|
|
void RenderPropertyAnimator::onAttached() {
|
|
if (!mHasStartValue
|
|
&& mStagingTarget->isPropertyFieldDirty(mPropertyAccess->dirtyMask)) {
|
|
setStartValue((mStagingTarget->stagingProperties().*mPropertyAccess->getter)());
|
|
}
|
|
}
|
|
|
|
void RenderPropertyAnimator::onStagingPlayStateChanged() {
|
|
if (mStagingPlayState == PlayState::Running) {
|
|
if (mStagingTarget) {
|
|
(mStagingTarget->mutateStagingProperties().*mPropertyAccess->setter)(finalValue());
|
|
} else {
|
|
// In the case of start delay where stagingTarget has been sync'ed over and null'ed
|
|
// we delay the properties update to push staging.
|
|
mShouldUpdateStagingProperties = true;
|
|
}
|
|
} else if (mStagingPlayState == PlayState::Finished) {
|
|
// We're being canceled, so make sure that whatever values the UI thread
|
|
// is observing for us is pushed over
|
|
mShouldSyncPropertyFields = true;
|
|
}
|
|
}
|
|
|
|
void RenderPropertyAnimator::onPushStaging() {
|
|
if (mShouldUpdateStagingProperties) {
|
|
(mTarget->mutateStagingProperties().*mPropertyAccess->setter)(finalValue());
|
|
mShouldUpdateStagingProperties = false;
|
|
}
|
|
|
|
if (mShouldSyncPropertyFields) {
|
|
mTarget->setPropertyFieldsDirty(dirtyMask());
|
|
mShouldSyncPropertyFields = false;
|
|
}
|
|
}
|
|
|
|
uint32_t RenderPropertyAnimator::dirtyMask() {
|
|
return mPropertyAccess->dirtyMask;
|
|
}
|
|
|
|
float RenderPropertyAnimator::getValue(RenderNode* target) const {
|
|
return (target->properties().*mPropertyAccess->getter)();
|
|
}
|
|
|
|
void RenderPropertyAnimator::setValue(RenderNode* target, float value) {
|
|
(target->animatorProperties().*mPropertyAccess->setter)(value);
|
|
}
|
|
|
|
/************************************************************
|
|
* CanvasPropertyPrimitiveAnimator
|
|
************************************************************/
|
|
|
|
CanvasPropertyPrimitiveAnimator::CanvasPropertyPrimitiveAnimator(
|
|
CanvasPropertyPrimitive* property, float finalValue)
|
|
: BaseRenderNodeAnimator(finalValue)
|
|
, mProperty(property) {
|
|
}
|
|
|
|
float CanvasPropertyPrimitiveAnimator::getValue(RenderNode* target) const {
|
|
return mProperty->value;
|
|
}
|
|
|
|
void CanvasPropertyPrimitiveAnimator::setValue(RenderNode* target, float value) {
|
|
mProperty->value = value;
|
|
}
|
|
|
|
uint32_t CanvasPropertyPrimitiveAnimator::dirtyMask() {
|
|
return RenderNode::DISPLAY_LIST;
|
|
}
|
|
|
|
/************************************************************
|
|
* CanvasPropertySkPaintAnimator
|
|
************************************************************/
|
|
|
|
CanvasPropertyPaintAnimator::CanvasPropertyPaintAnimator(
|
|
CanvasPropertyPaint* property, PaintField field, float finalValue)
|
|
: BaseRenderNodeAnimator(finalValue)
|
|
, mProperty(property)
|
|
, mField(field) {
|
|
}
|
|
|
|
float CanvasPropertyPaintAnimator::getValue(RenderNode* target) const {
|
|
switch (mField) {
|
|
case STROKE_WIDTH:
|
|
return mProperty->value.getStrokeWidth();
|
|
case ALPHA:
|
|
return mProperty->value.getAlpha();
|
|
}
|
|
LOG_ALWAYS_FATAL("Unknown field %d", (int) mField);
|
|
return -1;
|
|
}
|
|
|
|
static uint8_t to_uint8(float value) {
|
|
int c = (int) (value + .5f);
|
|
return static_cast<uint8_t>( c < 0 ? 0 : c > 255 ? 255 : c );
|
|
}
|
|
|
|
void CanvasPropertyPaintAnimator::setValue(RenderNode* target, float value) {
|
|
switch (mField) {
|
|
case STROKE_WIDTH:
|
|
mProperty->value.setStrokeWidth(value);
|
|
return;
|
|
case ALPHA:
|
|
mProperty->value.setAlpha(to_uint8(value));
|
|
return;
|
|
}
|
|
LOG_ALWAYS_FATAL("Unknown field %d", (int) mField);
|
|
}
|
|
|
|
uint32_t CanvasPropertyPaintAnimator::dirtyMask() {
|
|
return RenderNode::DISPLAY_LIST;
|
|
}
|
|
|
|
RevealAnimator::RevealAnimator(int centerX, int centerY,
|
|
float startValue, float finalValue)
|
|
: BaseRenderNodeAnimator(finalValue)
|
|
, mCenterX(centerX)
|
|
, mCenterY(centerY) {
|
|
setStartValue(startValue);
|
|
}
|
|
|
|
float RevealAnimator::getValue(RenderNode* target) const {
|
|
return target->properties().getRevealClip().getRadius();
|
|
}
|
|
|
|
void RevealAnimator::setValue(RenderNode* target, float value) {
|
|
target->animatorProperties().mutableRevealClip().set(true,
|
|
mCenterX, mCenterY, value);
|
|
}
|
|
|
|
uint32_t RevealAnimator::dirtyMask() {
|
|
return RenderNode::GENERIC;
|
|
}
|
|
|
|
} /* namespace uirenderer */
|
|
} /* namespace android */
|