1 /*
2  * Copyright (C) 2016 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #pragma once
18 
19 #include "VectorDrawable.h"
20 
21 #include <SkColor.h>
22 
23 namespace android {
24 namespace uirenderer {
25 
26 /**
27  * PropertyValues holder contains data needed to change a property of a Vector Drawable object.
28  * When a fraction in [0f, 1f] is provided, the holder will calculate an interpolated value based
29  * on its start and end value, and set the new value on the VectorDrawble's corresponding property.
30  */
31 class ANDROID_API PropertyValuesHolder {
32 public:
33     virtual void setFraction(float fraction) = 0;
~PropertyValuesHolder()34     virtual ~PropertyValuesHolder() {}
35 };
36 
37 template <typename T>
38 class Evaluator {
39 public:
evaluate(T * out,const T & from,const T & to,float fraction)40     virtual void evaluate(T* out, const T& from, const T& to, float fraction) const {};
~Evaluator()41     virtual ~Evaluator() {}
42 };
43 
44 class FloatEvaluator : public Evaluator<float> {
45 public:
evaluate(float * out,const float & from,const float & to,float fraction)46     virtual void evaluate(float* out, const float& from, const float& to,
47                           float fraction) const override {
48         *out = from * (1 - fraction) + to * fraction;
49     }
50 };
51 
52 class ANDROID_API ColorEvaluator : public Evaluator<SkColor> {
53 public:
54     virtual void evaluate(SkColor* outColor, const SkColor& from, const SkColor& to,
55                           float fraction) const override;
56 };
57 
58 class ANDROID_API PathEvaluator : public Evaluator<PathData> {
59     virtual void evaluate(PathData* out, const PathData& from, const PathData& to,
60                           float fraction) const override;
61 };
62 
63 template <typename T>
64 class ANDROID_API PropertyValuesHolderImpl : public PropertyValuesHolder {
65 public:
PropertyValuesHolderImpl(const T & startValue,const T & endValue)66     PropertyValuesHolderImpl(const T& startValue, const T& endValue)
67             : mStartValue(startValue), mEndValue(endValue) {}
setPropertyDataSource(T * dataSource,int length)68     void setPropertyDataSource(T* dataSource, int length) {
69         mDataSource.insert(mDataSource.begin(), dataSource, dataSource + length);
70     }
71     // Calculate the animated value from the data source.
72     const T getValueFromData(float fraction) const;
73     // Convenient method to favor getting animated value from data source. If no data source is set
74     // fall back to linear interpolation.
75     const T calculateAnimatedValue(float fraction) const;
76 
77 protected:
78     std::unique_ptr<Evaluator<T>> mEvaluator = nullptr;
79     // This contains uniformly sampled data throughout the animation duration. The first element
80     // should be the start value and the last should be the end value of the animation. When the
81     // data source is set, we'll favor data source over the linear interpolation of start/end value
82     // for calculation of animated value.
83     std::vector<T> mDataSource;
84     T mStartValue;
85     T mEndValue;
86 };
87 
88 class ANDROID_API GroupPropertyValuesHolder : public PropertyValuesHolderImpl<float> {
89 public:
GroupPropertyValuesHolder(VectorDrawable::Group * ptr,int propertyId,float startValue,float endValue)90     GroupPropertyValuesHolder(VectorDrawable::Group* ptr, int propertyId, float startValue,
91                               float endValue)
92             : PropertyValuesHolderImpl(startValue, endValue), mGroup(ptr), mPropertyId(propertyId) {
93         mEvaluator.reset(new FloatEvaluator());
94     }
95     void setFraction(float fraction) override;
96 
97 private:
98     VectorDrawable::Group* mGroup;
99     int mPropertyId;
100 };
101 
102 class ANDROID_API FullPathColorPropertyValuesHolder : public PropertyValuesHolderImpl<SkColor> {
103 public:
FullPathColorPropertyValuesHolder(VectorDrawable::FullPath * ptr,int propertyId,SkColor startValue,SkColor endValue)104     FullPathColorPropertyValuesHolder(VectorDrawable::FullPath* ptr, int propertyId,
105                                       SkColor startValue, SkColor endValue)
106             : PropertyValuesHolderImpl(startValue, endValue)
107             , mFullPath(ptr)
108             , mPropertyId(propertyId) {
109         mEvaluator.reset(new ColorEvaluator());
110     }
111     void setFraction(float fraction) override;
112     static SkColor interpolateColors(SkColor fromColor, SkColor toColor, float fraction);
113 
114 private:
115     VectorDrawable::FullPath* mFullPath;
116     int mPropertyId;
117 };
118 
119 class ANDROID_API FullPathPropertyValuesHolder : public PropertyValuesHolderImpl<float> {
120 public:
FullPathPropertyValuesHolder(VectorDrawable::FullPath * ptr,int propertyId,float startValue,float endValue)121     FullPathPropertyValuesHolder(VectorDrawable::FullPath* ptr, int propertyId, float startValue,
122                                  float endValue)
123             : PropertyValuesHolderImpl(startValue, endValue)
124             , mFullPath(ptr)
125             , mPropertyId(propertyId) {
126         mEvaluator.reset(new FloatEvaluator());
127     };
128     void setFraction(float fraction) override;
129 
130 private:
131     VectorDrawable::FullPath* mFullPath;
132     int mPropertyId;
133 };
134 
135 class ANDROID_API PathDataPropertyValuesHolder : public PropertyValuesHolderImpl<PathData> {
136 public:
PathDataPropertyValuesHolder(VectorDrawable::Path * ptr,PathData * startValue,PathData * endValue)137     PathDataPropertyValuesHolder(VectorDrawable::Path* ptr, PathData* startValue,
138                                  PathData* endValue)
139             : PropertyValuesHolderImpl(*startValue, *endValue), mPath(ptr) {
140         mEvaluator.reset(new PathEvaluator());
141     };
142     void setFraction(float fraction) override;
143 
144 private:
145     VectorDrawable::Path* mPath;
146     PathData mPathData;
147 };
148 
149 class ANDROID_API RootAlphaPropertyValuesHolder : public PropertyValuesHolderImpl<float> {
150 public:
RootAlphaPropertyValuesHolder(VectorDrawable::Tree * tree,float startValue,float endValue)151     RootAlphaPropertyValuesHolder(VectorDrawable::Tree* tree, float startValue, float endValue)
152             : PropertyValuesHolderImpl(startValue, endValue), mTree(tree) {
153         mEvaluator.reset(new FloatEvaluator());
154     }
155     void setFraction(float fraction) override;
156 
157 private:
158     VectorDrawable::Tree* mTree;
159 };
160 }
161 }
162