Home | History | Annotate | Download | only in hwui 
      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;
     34     virtual ~PropertyValuesHolder() {}
     35 };
     36 
     37 template <typename T>
     38 class Evaluator {
     39 public:
     40     virtual void evaluate(T* out, const T& from, const T& to, float fraction) const {};
     41     virtual ~Evaluator() {}
     42 };
     43 
     44 class FloatEvaluator : public Evaluator<float> {
     45 public:
     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:
     66     PropertyValuesHolderImpl(const T& startValue, const T& endValue)
     67             : mStartValue(startValue), mEndValue(endValue) {}
     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:
     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:
    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:
    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:
    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:
    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