blob: dc180188100b115ef4ce54183d68cab1e2d6217e [file] [log] [blame]
/*
* 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 */