drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
android_frameworks_base/libs/hwui/VectorDrawable.h
Stan Iliev 65e678fdb1 Cache VectorDrawable bounds at record time 
Cache VectorDrawable bounds at record time, because the same
drawable object may be used several times with different bounds.

Bug: 71737362
Test: Wrote a new unit test, tried sample app attached to the bug
Change-Id: If7be934acf0c16b328cb0f95d849e463dcd3b88b
2018-02-08 19:01:08 +00:00

725 lines
29 KiB
C++
Raw Blame History

/*
* 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.
*/
#ifndef ANDROID_HWUI_VPATH_H
#define ANDROID_HWUI_VPATH_H
#include "DisplayList.h"
#include "hwui/Bitmap.h"
#include "hwui/Canvas.h"
#include "renderthread/CacheManager.h"
#include <SkBitmap.h>
#include <SkCanvas.h>
#include <SkColor.h>
#include <SkColorFilter.h>
#include <SkMatrix.h>
#include <SkPaint.h>
#include <SkPath.h>
#include <SkPathMeasure.h>
#include <SkRect.h>
#include <SkShader.h>
#include <SkSurface.h>
#include <cutils/compiler.h>
#include <stddef.h>
#include <string>
#include <vector>
namespace android {
namespace uirenderer {
// Debug
#if DEBUG_VECTOR_DRAWABLE
#define VECTOR_DRAWABLE_LOGD(...) ALOGD(__VA_ARGS__)
#else
#define VECTOR_DRAWABLE_LOGD(...)
#endif
namespace VectorDrawable {
#define VD_SET_PRIMITIVE_FIELD_WITH_FLAG(field, value, flag) \
(VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(field, (value)) ? ((flag) = true, true) : false)
#define VD_SET_PROP(field, value) ((value) != (field) ? ((field) = (value), true) : false)
#define VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(field, value) \
({ \
bool retVal = VD_SET_PROP((mPrimitiveFields.field), (value)); \
onPropertyChanged(); \
retVal; \
})
#define UPDATE_SKPROP(field, value) \
({ \
bool retVal = ((field) != (value)); \
if ((field) != (value)) SkRefCnt_SafeAssign((field), (value)); \
retVal; \
})
/* A VectorDrawable is composed of a tree of nodes.
* Each node can be a group node, or a path.
* A group node can have groups or paths as children, but a path node has
* no children.
* One example can be:
* Root Group
* / | \
* Group Path Group
* / \ |
* Path Path Path
*
* VectorDrawables are drawn into bitmap caches first, then the caches are drawn to the given
* canvas with root alpha applied. Two caches are maintained for VD, one in UI thread, the other in
* Render Thread. A generation id is used to keep track of changes in the vector drawable tree.
* Each cache has their own generation id to track whether they are up to date with the latest
* change in the tree.
*
* Any property change to the vector drawable coming from UI thread (such as bulk setters to update
* all the properties, and viewport change, etc.) are only modifying the staging properties. The
* staging properties will then be marked dirty and will be pushed over to render thread properties
* at sync point. If staging properties are not dirty at sync point, we sync backwards by updating
* staging properties with render thread properties to reflect the latest animation value.
*
*/
class PropertyChangedListener {
public:
PropertyChangedListener(bool* dirty, bool* stagingDirty)
: mDirty(dirty), mStagingDirty(stagingDirty) {}
void onPropertyChanged() { *mDirty = true; }
void onStagingPropertyChanged() { *mStagingDirty = true; }
private:
bool* mDirty;
bool* mStagingDirty;
};
class ANDROID_API Node {
public:
class Properties {
public:
explicit Properties(Node* node) : mNode(node) {}
inline void onPropertyChanged() { mNode->onPropertyChanged(this); }
private:
Node* mNode;
};
Node(const Node& node) { mName = node.mName; }
Node() {}
virtual void draw(SkCanvas* outCanvas, bool useStagingData) = 0;
virtual void dump() = 0;
void setName(const char* name) { mName = name; }
virtual void setPropertyChangedListener(PropertyChangedListener* listener) {
mPropertyChangedListener = listener;
}
virtual void onPropertyChanged(Properties* properties) = 0;
virtual ~Node() {}
virtual void syncProperties() = 0;
virtual void setAntiAlias(bool aa) = 0;
protected:
std::string mName;
PropertyChangedListener* mPropertyChangedListener = nullptr;
};
class ANDROID_API Path : public Node {
public:
struct ANDROID_API Data {
std::vector<char> verbs;
std::vector<size_t> verbSizes;
std::vector<float> points;
bool operator==(const Data& data) const {
return verbs == data.verbs && verbSizes == data.verbSizes && points == data.points;
}
};
class PathProperties : public Properties {
public:
explicit PathProperties(Node* node) : Properties(node) {}
void syncProperties(const PathProperties& prop) {
mData = prop.mData;
onPropertyChanged();
}
void setData(const Data& data) {
// Updates the path data. Note that we don't generate a new Skia path right away
// because there are cases where the animation is changing the path data, but the view
// that hosts the VD has gone off screen, in which case we won't even draw. So we
// postpone the Skia path generation to the draw time.
if (data == mData) {
return;
}
mData = data;
onPropertyChanged();
}
const Data& getData() const { return mData; }
private:
Data mData;
};
Path(const Path& path);
Path(const char* path, size_t strLength);
Path() {}
void dump() override;
virtual void syncProperties() override;
virtual void onPropertyChanged(Properties* prop) override {
if (prop == &mStagingProperties) {
mStagingPropertiesDirty = true;
if (mPropertyChangedListener) {
mPropertyChangedListener->onStagingPropertyChanged();
}
} else if (prop == &mProperties) {
mSkPathDirty = true;
if (mPropertyChangedListener) {
mPropertyChangedListener->onPropertyChanged();
}
}
}
PathProperties* mutateStagingProperties() { return &mStagingProperties; }
const PathProperties* stagingProperties() { return &mStagingProperties; }
// This should only be called from animations on RT
PathProperties* mutateProperties() { return &mProperties; }
protected:
virtual const SkPath& getUpdatedPath(bool useStagingData, SkPath* tempStagingPath);
// Internal data, render thread only.
bool mSkPathDirty = true;
SkPath mSkPath;
private:
PathProperties mProperties = PathProperties(this);
PathProperties mStagingProperties = PathProperties(this);
bool mStagingPropertiesDirty = true;
};
class ANDROID_API FullPath : public Path {
public:
class FullPathProperties : public Properties {
public:
struct PrimitiveFields {
float strokeWidth = 0;
SkColor strokeColor = SK_ColorTRANSPARENT;
float strokeAlpha = 1;
SkColor fillColor = SK_ColorTRANSPARENT;
float fillAlpha = 1;
float trimPathStart = 0;
float trimPathEnd = 1;
float trimPathOffset = 0;
int32_t strokeLineCap = SkPaint::Cap::kButt_Cap;
int32_t strokeLineJoin = SkPaint::Join::kMiter_Join;
float strokeMiterLimit = 4;
int fillType = 0; /* non-zero or kWinding_FillType in Skia */
};
explicit FullPathProperties(Node* mNode) : Properties(mNode), mTrimDirty(false) {}
~FullPathProperties() {
SkSafeUnref(fillGradient);
SkSafeUnref(strokeGradient);
}
void syncProperties(const FullPathProperties& prop) {
mPrimitiveFields = prop.mPrimitiveFields;
mTrimDirty = true;
UPDATE_SKPROP(fillGradient, prop.fillGradient);
UPDATE_SKPROP(strokeGradient, prop.strokeGradient);
onPropertyChanged();
}
void setFillGradient(SkShader* gradient) {
if (UPDATE_SKPROP(fillGradient, gradient)) {
onPropertyChanged();
}
}
void setStrokeGradient(SkShader* gradient) {
if (UPDATE_SKPROP(strokeGradient, gradient)) {
onPropertyChanged();
}
}
SkShader* getFillGradient() const { return fillGradient; }
SkShader* getStrokeGradient() const { return strokeGradient; }
float getStrokeWidth() const { return mPrimitiveFields.strokeWidth; }
void setStrokeWidth(float strokeWidth) {
VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(strokeWidth, strokeWidth);
}
SkColor getStrokeColor() const { return mPrimitiveFields.strokeColor; }
void setStrokeColor(SkColor strokeColor) {
VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(strokeColor, strokeColor);
}
float getStrokeAlpha() const { return mPrimitiveFields.strokeAlpha; }
void setStrokeAlpha(float strokeAlpha) {
VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(strokeAlpha, strokeAlpha);
}
SkColor getFillColor() const { return mPrimitiveFields.fillColor; }
void setFillColor(SkColor fillColor) {
VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(fillColor, fillColor);
}
float getFillAlpha() const { return mPrimitiveFields.fillAlpha; }
void setFillAlpha(float fillAlpha) {
VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(fillAlpha, fillAlpha);
}
float getTrimPathStart() const { return mPrimitiveFields.trimPathStart; }
void setTrimPathStart(float trimPathStart) {
VD_SET_PRIMITIVE_FIELD_WITH_FLAG(trimPathStart, trimPathStart, mTrimDirty);
}
float getTrimPathEnd() const { return mPrimitiveFields.trimPathEnd; }
void setTrimPathEnd(float trimPathEnd) {
VD_SET_PRIMITIVE_FIELD_WITH_FLAG(trimPathEnd, trimPathEnd, mTrimDirty);
}
float getTrimPathOffset() const { return mPrimitiveFields.trimPathOffset; }
void setTrimPathOffset(float trimPathOffset) {
VD_SET_PRIMITIVE_FIELD_WITH_FLAG(trimPathOffset, trimPathOffset, mTrimDirty);
}
float getStrokeMiterLimit() const { return mPrimitiveFields.strokeMiterLimit; }
float getStrokeLineCap() const { return mPrimitiveFields.strokeLineCap; }
float getStrokeLineJoin() const { return mPrimitiveFields.strokeLineJoin; }
float getFillType() const { return mPrimitiveFields.fillType; }
bool copyProperties(int8_t* outProperties, int length) const;
void updateProperties(float strokeWidth, SkColor strokeColor, float strokeAlpha,
SkColor fillColor, float fillAlpha, float trimPathStart,
float trimPathEnd, float trimPathOffset, float strokeMiterLimit,
int strokeLineCap, int strokeLineJoin, int fillType) {
mPrimitiveFields.strokeWidth = strokeWidth;
mPrimitiveFields.strokeColor = strokeColor;
mPrimitiveFields.strokeAlpha = strokeAlpha;
mPrimitiveFields.fillColor = fillColor;
mPrimitiveFields.fillAlpha = fillAlpha;
mPrimitiveFields.trimPathStart = trimPathStart;
mPrimitiveFields.trimPathEnd = trimPathEnd;
mPrimitiveFields.trimPathOffset = trimPathOffset;
mPrimitiveFields.strokeMiterLimit = strokeMiterLimit;
mPrimitiveFields.strokeLineCap = strokeLineCap;
mPrimitiveFields.strokeLineJoin = strokeLineJoin;
mPrimitiveFields.fillType = fillType;
mTrimDirty = true;
onPropertyChanged();
}
// Set property values during animation
void setColorPropertyValue(int propertyId, int32_t value);
void setPropertyValue(int propertyId, float value);
bool mTrimDirty;
private:
enum class Property {
strokeWidth = 0,
strokeColor,
strokeAlpha,
fillColor,
fillAlpha,
trimPathStart,
trimPathEnd,
trimPathOffset,
strokeLineCap,
strokeLineJoin,
strokeMiterLimit,
fillType,
count,
};
PrimitiveFields mPrimitiveFields;
SkShader* fillGradient = nullptr;
SkShader* strokeGradient = nullptr;
};
// Called from UI thread
FullPath(const FullPath& path); // for cloning
FullPath(const char* path, size_t strLength) : Path(path, strLength) {}
FullPath() : Path() {}
void draw(SkCanvas* outCanvas, bool useStagingData) override;
void dump() override;
FullPathProperties* mutateStagingProperties() { return &mStagingProperties; }
const FullPathProperties* stagingProperties() { return &mStagingProperties; }
// This should only be called from animations on RT
FullPathProperties* mutateProperties() { return &mProperties; }
virtual void syncProperties() override;
virtual void onPropertyChanged(Properties* properties) override {
Path::onPropertyChanged(properties);
if (properties == &mStagingProperties) {
mStagingPropertiesDirty = true;
if (mPropertyChangedListener) {
mPropertyChangedListener->onStagingPropertyChanged();
}
} else if (properties == &mProperties) {
if (mPropertyChangedListener) {
mPropertyChangedListener->onPropertyChanged();
}
}
}
virtual void setAntiAlias(bool aa) { mAntiAlias = aa; }
protected:
const SkPath& getUpdatedPath(bool useStagingData, SkPath* tempStagingPath) override;
private:
FullPathProperties mProperties = FullPathProperties(this);
FullPathProperties mStagingProperties = FullPathProperties(this);
bool mStagingPropertiesDirty = true;
// Intermediate data for drawing, render thread only
SkPath mTrimmedSkPath;
// Default to use AntiAlias
bool mAntiAlias = true;
};
class ANDROID_API ClipPath : public Path {
public:
ClipPath(const ClipPath& path) : Path(path) {}
ClipPath(const char* path, size_t strLength) : Path(path, strLength) {}
ClipPath() : Path() {}
void draw(SkCanvas* outCanvas, bool useStagingData) override;
virtual void setAntiAlias(bool aa) {}
};
class ANDROID_API Group : public Node {
public:
class GroupProperties : public Properties {
public:
explicit GroupProperties(Node* mNode) : Properties(mNode) {}
struct PrimitiveFields {
float rotate = 0;
float pivotX = 0;
float pivotY = 0;
float scaleX = 1;
float scaleY = 1;
float translateX = 0;
float translateY = 0;
} mPrimitiveFields;
void syncProperties(const GroupProperties& prop) {
mPrimitiveFields = prop.mPrimitiveFields;
onPropertyChanged();
}
float getRotation() const { return mPrimitiveFields.rotate; }
void setRotation(float rotation) { VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(rotate, rotation); }
float getPivotX() const { return mPrimitiveFields.pivotX; }
void setPivotX(float pivotX) { VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(pivotX, pivotX); }
float getPivotY() const { return mPrimitiveFields.pivotY; }
void setPivotY(float pivotY) { VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(pivotY, pivotY); }
float getScaleX() const { return mPrimitiveFields.scaleX; }
void setScaleX(float scaleX) { VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(scaleX, scaleX); }
float getScaleY() const { return mPrimitiveFields.scaleY; }
void setScaleY(float scaleY) { VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(scaleY, scaleY); }
float getTranslateX() const { return mPrimitiveFields.translateX; }
void setTranslateX(float translateX) {
VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(translateX, translateX);
}
float getTranslateY() const { return mPrimitiveFields.translateY; }
void setTranslateY(float translateY) {
VD_SET_PRIMITIVE_FIELD_AND_NOTIFY(translateY, translateY);
}
void updateProperties(float rotate, float pivotX, float pivotY, float scaleX, float scaleY,
float translateX, float translateY) {
mPrimitiveFields.rotate = rotate;
mPrimitiveFields.pivotX = pivotX;
mPrimitiveFields.pivotY = pivotY;
mPrimitiveFields.scaleX = scaleX;
mPrimitiveFields.scaleY = scaleY;
mPrimitiveFields.translateX = translateX;
mPrimitiveFields.translateY = translateY;
onPropertyChanged();
}
void setPropertyValue(int propertyId, float value);
float getPropertyValue(int propertyId) const;
bool copyProperties(float* outProperties, int length) const;
static bool isValidProperty(int propertyId);
private:
enum class Property {
rotate = 0,
pivotX,
pivotY,
scaleX,
scaleY,
translateX,
translateY,
// Count of the properties, must be at the end.
count,
};
};
Group(const Group& group);
Group() {}
void addChild(Node* child);
virtual void setPropertyChangedListener(PropertyChangedListener* listener) override {
Node::setPropertyChangedListener(listener);
for (auto& child : mChildren) {
child->setPropertyChangedListener(listener);
}
}
virtual void syncProperties() override;
GroupProperties* mutateStagingProperties() { return &mStagingProperties; }
const GroupProperties* stagingProperties() { return &mStagingProperties; }
// This should only be called from animations on RT
GroupProperties* mutateProperties() { return &mProperties; }
// Methods below could be called from either UI thread or Render Thread.
virtual void draw(SkCanvas* outCanvas, bool useStagingData) override;
void getLocalMatrix(SkMatrix* outMatrix, const GroupProperties& properties);
void dump() override;
static bool isValidProperty(int propertyId);
virtual void onPropertyChanged(Properties* properties) override {
if (properties == &mStagingProperties) {
mStagingPropertiesDirty = true;
if (mPropertyChangedListener) {
mPropertyChangedListener->onStagingPropertyChanged();
}
} else {
if (mPropertyChangedListener) {
mPropertyChangedListener->onPropertyChanged();
}
}
}
virtual void setAntiAlias(bool aa) {
for (auto& child : mChildren) {
child->setAntiAlias(aa);
}
}
private:
GroupProperties mProperties = GroupProperties(this);
GroupProperties mStagingProperties = GroupProperties(this);
bool mStagingPropertiesDirty = true;
std::vector<std::unique_ptr<Node> > mChildren;
};
class ANDROID_API Tree : public VirtualLightRefBase {
public:
explicit Tree(Group* rootNode) : mRootNode(rootNode) {
mRootNode->setPropertyChangedListener(&mPropertyChangedListener);
}
// Copy properties from the tree and use the give node as the root node
Tree(const Tree* copy, Group* rootNode) : Tree(rootNode) {
mStagingProperties.syncAnimatableProperties(*copy->stagingProperties());
mStagingProperties.syncNonAnimatableProperties(*copy->stagingProperties());
}
// Draws the VD onto a bitmap cache, then the bitmap cache will be rendered onto the input
// canvas. Returns the number of pixels needed for the bitmap cache.
int draw(Canvas* outCanvas, SkColorFilter* colorFilter, const SkRect& bounds,
bool needsMirroring, bool canReuseCache);
void drawStaging(Canvas* canvas);
Bitmap& getBitmapUpdateIfDirty();
void setAllowCaching(bool allowCaching) { mAllowCaching = allowCaching; }
SkPaint* getPaint();
void syncProperties() {
if (mStagingProperties.mNonAnimatablePropertiesDirty) {
mCache.dirty |= (mProperties.mNonAnimatableProperties.viewportWidth !=
mStagingProperties.mNonAnimatableProperties.viewportWidth) ||
(mProperties.mNonAnimatableProperties.viewportHeight !=
mStagingProperties.mNonAnimatableProperties.viewportHeight) ||
(mProperties.mNonAnimatableProperties.scaledWidth !=
mStagingProperties.mNonAnimatableProperties.scaledWidth) ||
(mProperties.mNonAnimatableProperties.scaledHeight !=
mStagingProperties.mNonAnimatableProperties.scaledHeight) ||
(mProperties.mNonAnimatableProperties.bounds !=
mStagingProperties.mNonAnimatableProperties.bounds);
mProperties.syncNonAnimatableProperties(mStagingProperties);
mStagingProperties.mNonAnimatablePropertiesDirty = false;
}
if (mStagingProperties.mAnimatablePropertiesDirty) {
mProperties.syncAnimatableProperties(mStagingProperties);
} else {
mStagingProperties.syncAnimatableProperties(mProperties);
}
mStagingProperties.mAnimatablePropertiesDirty = false;
mRootNode->syncProperties();
}
class TreeProperties {
public:
explicit TreeProperties(Tree* tree) : mTree(tree) {}
// Properties that can only be modified by UI thread, therefore sync should
// only go from UI to RT
struct NonAnimatableProperties {
float viewportWidth = 0;
float viewportHeight = 0;
SkRect bounds;
int scaledWidth = 0;
int scaledHeight = 0;
SkColorFilter* colorFilter = nullptr;
~NonAnimatableProperties() { SkSafeUnref(colorFilter); }
} mNonAnimatableProperties;
bool mNonAnimatablePropertiesDirty = true;
float mRootAlpha = 1.0f;
bool mAnimatablePropertiesDirty = true;
void syncNonAnimatableProperties(const TreeProperties& prop) {
// Copy over the data that can only be changed in UI thread
if (mNonAnimatableProperties.colorFilter != prop.mNonAnimatableProperties.colorFilter) {
SkRefCnt_SafeAssign(mNonAnimatableProperties.colorFilter,
prop.mNonAnimatableProperties.colorFilter);
}
mNonAnimatableProperties = prop.mNonAnimatableProperties;
}
void setViewportSize(float width, float height) {
if (mNonAnimatableProperties.viewportWidth != width ||
mNonAnimatableProperties.viewportHeight != height) {
mNonAnimatablePropertiesDirty = true;
mNonAnimatableProperties.viewportWidth = width;
mNonAnimatableProperties.viewportHeight = height;
mTree->onPropertyChanged(this);
}
}
void setBounds(const SkRect& bounds) {
if (mNonAnimatableProperties.bounds != bounds) {
mNonAnimatableProperties.bounds = bounds;
mNonAnimatablePropertiesDirty = true;
mTree->onPropertyChanged(this);
}
}
void setScaledSize(int width, int height) {
// If the requested size is bigger than what the bitmap was, then
// we increase the bitmap size to match. The width and height
// are bound by MAX_CACHED_BITMAP_SIZE.
if (mNonAnimatableProperties.scaledWidth < width ||
mNonAnimatableProperties.scaledHeight < height) {
mNonAnimatableProperties.scaledWidth =
std::max(width, mNonAnimatableProperties.scaledWidth);
mNonAnimatableProperties.scaledHeight =
std::max(height, mNonAnimatableProperties.scaledHeight);
mNonAnimatablePropertiesDirty = true;
mTree->onPropertyChanged(this);
}
}
void setColorFilter(SkColorFilter* filter) {
if (UPDATE_SKPROP(mNonAnimatableProperties.colorFilter, filter)) {
mNonAnimatablePropertiesDirty = true;
mTree->onPropertyChanged(this);
}
}
SkColorFilter* getColorFilter() const { return mNonAnimatableProperties.colorFilter; }
float getViewportWidth() const { return mNonAnimatableProperties.viewportWidth; }
float getViewportHeight() const { return mNonAnimatableProperties.viewportHeight; }
float getScaledWidth() const { return mNonAnimatableProperties.scaledWidth; }
float getScaledHeight() const { return mNonAnimatableProperties.scaledHeight; }
void syncAnimatableProperties(const TreeProperties& prop) { mRootAlpha = prop.mRootAlpha; }
bool setRootAlpha(float rootAlpha) {
if (rootAlpha != mRootAlpha) {
mAnimatablePropertiesDirty = true;
mRootAlpha = rootAlpha;
mTree->onPropertyChanged(this);
return true;
}
return false;
}
float getRootAlpha() const { return mRootAlpha; }
const SkRect& getBounds() const { return mNonAnimatableProperties.bounds; }
Tree* mTree;
};
void onPropertyChanged(TreeProperties* prop);
TreeProperties* mutateStagingProperties() { return &mStagingProperties; }
const TreeProperties* stagingProperties() const { return &mStagingProperties; }
// This should only be called from animations on RT
TreeProperties* mutateProperties() { return &mProperties; }
// called from RT only
const TreeProperties& properties() const { return mProperties; }
// This should always be called from RT.
void markDirty() { mCache.dirty = true; }
bool isDirty() const { return mCache.dirty; }
bool getPropertyChangeWillBeConsumed() const { return mWillBeConsumed; }
void setPropertyChangeWillBeConsumed(bool willBeConsumed) { mWillBeConsumed = willBeConsumed; }
/**
* Draws VD cache into a canvas. This should always be called from RT and it works with Skia
* pipelines only.
*/
void draw(SkCanvas* canvas, const SkRect& bounds);
/**
* Draws VD into a GPU backed surface.
* This should always be called from RT and it works with Skia pipeline only.
*/
void updateCache(sp<skiapipeline::VectorDrawableAtlas>& atlas, GrContext* context);
void setAntiAlias(bool aa) { mRootNode->setAntiAlias(aa); }
private:
class Cache {
public:
sk_sp<Bitmap> bitmap; // used by HWUI pipeline and software
// TODO: use surface instead of bitmap when drawing in software canvas
bool dirty = true;
// the rest of the code in Cache is used by Skia pipelines only
~Cache() { clear(); }
/**
* Stores a weak pointer to the atlas and a key.
*/
void setAtlas(sp<skiapipeline::VectorDrawableAtlas> atlas,
skiapipeline::AtlasKey newAtlasKey);
/**
* Gets a surface and bounds from the atlas.
*
* @return nullptr if the altas has been deleted.
*/
sk_sp<SkSurface> getSurface(SkRect* bounds);
/**
* Releases atlas key from the atlas, which makes it available for reuse.
*/
void clear();
private:
wp<skiapipeline::VectorDrawableAtlas> mAtlas;
skiapipeline::AtlasKey mAtlasKey = INVALID_ATLAS_KEY;
};
SkPaint* updatePaint(SkPaint* outPaint, TreeProperties* prop);
bool allocateBitmapIfNeeded(Cache& cache, int width, int height);
bool canReuseBitmap(Bitmap*, int width, int height);
void updateBitmapCache(Bitmap& outCache, bool useStagingData);
// Cap the bitmap size, such that it won't hurt the performance too much
// and it won't crash due to a very large scale.
// The drawable will look blurry above this size.
const static int MAX_CACHED_BITMAP_SIZE;
bool mAllowCaching = true;
std::unique_ptr<Group> mRootNode;
TreeProperties mProperties = TreeProperties(this);
TreeProperties mStagingProperties = TreeProperties(this);
SkPaint mPaint;
Cache mStagingCache;
Cache mCache;
PropertyChangedListener mPropertyChangedListener =
PropertyChangedListener(&mCache.dirty, &mStagingCache.dirty);
mutable bool mWillBeConsumed = false;
};
} // namespace VectorDrawable
typedef VectorDrawable::Path::Data PathData;
} // namespace uirenderer
} // namespace android
#endif // ANDROID_HWUI_VPATH_H
Reference in New Issue View Git Blame Copy Permalink