skottie::Animation::Builder Class Reference

#include <Skottie.h>

Classes
struct	Stats

Public Types
enum	Flags : uint32_t { kDeferImageLoading = 0x01 , kPreferEmbeddedFonts = 0x02 }

Public Member Functions
	Builder (uint32_t flags=0)
	Builder (const Builder &)
	Builder (Builder &&)
	~Builder ()
const Stats &	getStats () const
Builder &	setResourceProvider (sk_sp< ResourceProvider >)
Builder &	setFontManager (sk_sp< SkFontMgr >)
Builder &	setPropertyObserver (sk_sp< PropertyObserver >)
Builder &	setLogger (sk_sp< Logger >)
Builder &	setMarkerObserver (sk_sp< MarkerObserver >)
Builder &	setPrecompInterceptor (sk_sp< PrecompInterceptor >)
Builder &	setExpressionManager (sk_sp< ExpressionManager >)
Builder &	setTextShapingFactory (sk_sp< SkShapers::Factory >)
sk_sp< Animation >	make (SkStream *)
sk_sp< Animation >	make (const char *data, size_t length)
sk_sp< Animation >	makeFromFile (const char path[])
const sk_sp< SlotManager > &	getSlotManager () const

Detailed Description

Definition at line 95 of file Skottie.h.

Member Enumeration Documentation

Flags

enum skottie::Animation::Builder::Flags : uint32_t

Enumerator
kDeferImageLoading
kPreferEmbeddedFonts

Definition at line 97 of file Skottie.h.

                   : uint32_t {
            kDeferImageLoading   = 0x01, // Normally, all static image frames are resolved at
                                         // load time via ImageAsset::getFrame(0).  With this flag,
                                         // frames are only resolved when needed, at seek() time.
            kPreferEmbeddedFonts = 0x02, // Attempt to use the embedded fonts (glyph paths,
                                         // normally used as fallback) over native Skia typefaces.
        };

Constructor & Destructor Documentation

Builder() [1/3]

skottie::Animation::Builder::Builder ( uint32_t  flags = 0 )

explicit

Definition at line 304 of file Skottie.cpp.

: fFlags(flags) {}

Builder() [2/3]

skottie::Animation::Builder::Builder ( const Builder &  )

default

Builder() [3/3]

skottie::Animation::Builder::Builder ( Builder &&  )

default

~Builder()

skottie::Animation::Builder::~Builder ( )

default

Member Function Documentation

getSlotManager()

const sk_sp< SlotManager > & skottie::Animation::Builder::getSlotManager ( ) const

inline

Get handle for SlotManager after animation is built.

Definition at line 182 of file Skottie.h.

{return fSlotManager;}

getStats()

const Stats & skottie::Animation::Builder::getStats ( ) const

inline

Returns various animation build stats.

Returns

Stats (see above).

Definition at line 123 of file Skottie.h.

{ return fStats; }

make() [1/2]

sk_sp< Animation > skottie::Animation::Builder::make	(	const char *	data,
		size_t	length
	)

Definition at line 369 of file Skottie.cpp.

                                                                         {
    TRACE_EVENT0("skottie", TRACE_FUNC);
 
    // Sanitize factory args.
    class NullResourceProvider final : public ResourceProvider {
        sk_sp<SkData> load(const char[], const char[]) const override { return nullptr; }
    };
    auto resolvedProvider = fResourceProvider
            ? fResourceProvider : sk_make_sp<NullResourceProvider>();
 
    fStats = Stats{};
 
    fStats.fJsonSize = data_len;
    const auto t0 = std::chrono::steady_clock::now();
 
    const skjson::DOM dom(data, data_len);
    if (!dom.root().is<skjson::ObjectValue>()) {
        // TODO: more error info.
        if (fLogger) {
            fLogger->log(Logger::Level::kError, "Failed to parse JSON input.\n");
        }
        return nullptr;
    }
    const auto& json = dom.root().as<skjson::ObjectValue>();
 
    const auto t1 = std::chrono::steady_clock::now();
    fStats.fJsonParseTimeMS = std::chrono::duration<float, std::milli>{t1-t0}.count();
 
    const auto version  = ParseDefault<SkString>(json["v"], SkString());
    const auto size     = SkSize::Make(ParseDefault<float>(json["w"], 0.0f),
                                       ParseDefault<float>(json["h"], 0.0f));
    const auto fps      = ParseDefault<float>(json["fr"], -1.0f),
               inPoint  = ParseDefault<float>(json["ip"], 0.0f),
               outPoint = std::max(ParseDefault<float>(json["op"], SK_ScalarMax), inPoint),
               duration = sk_ieee_float_divide(outPoint - inPoint, fps);
 
    if (size.isEmpty() || version.isEmpty() || fps <= 0 ||
        !SkIsFinite(inPoint, outPoint, duration)) {
        if (fLogger) {
            const auto msg = SkStringPrintf(
                         "Invalid animation params (version: %s, size: [%f %f], frame rate: %f, "
                         "in-point: %f, out-point: %f)\n",
                         version.c_str(), size.width(), size.height(), fps, inPoint, outPoint);
            fLogger->log(Logger::Level::kError, msg.c_str());
        }
        return nullptr;
    }
 
#if defined(SK_DISABLE_LEGACY_SHAPER_FACTORY)
    auto factory = fShapingFactory ? fShapingFactory : ::SkShapers::Primitive::Factory();
#else
    auto factory = fShapingFactory ? fShapingFactory : ::SkShapers::BestAvailable();
#endif
    SkASSERT(resolvedProvider);
    internal::AnimationBuilder builder(std::move(resolvedProvider), fFontMgr,
                                       std::move(fPropertyObserver),
                                       std::move(fLogger),
                                       std::move(fMarkerObserver),
                                       std::move(fPrecompInterceptor),
                                       std::move(fExpressionManager),
                                       std::move(factory),
                                       &fStats, size, duration, fps, fFlags);
    auto ainfo = builder.parse(json);
 
    fSlotManager = ainfo.fSlotManager;
 
    const auto t2 = std::chrono::steady_clock::now();
    fStats.fSceneParseTimeMS = std::chrono::duration<float, std::milli>{t2-t1}.count();
    fStats.fTotalLoadTimeMS  = std::chrono::duration<float, std::milli>{t2-t0}.count();
 
    if (!ainfo.fSceneRoot && fLogger) {
        fLogger->log(Logger::Level::kError, "Could not parse animation.\n");
    }
 
    uint32_t flags = 0;
    if (builder.hasNontrivialBlending()) {
        flags |= Animation::Flags::kRequiresTopLevelIsolation;
    }
 
    return sk_sp<Animation>(new Animation(std::move(ainfo.fSceneRoot),
                                          std::move(ainfo.fAnimators),
                                          std::move(version),
                                          size,
                                          inPoint,
                                          outPoint,
                                          duration,
                                          fps,
                                          flags));
}

make() [2/2]

sk_sp< Animation > skottie::Animation::Builder::make

(

SkStream *

stream

)

Animation factories.

Definition at line 349 of file Skottie.cpp.

                                                        {
    if (!stream->hasLength()) {
        // TODO: handle explicit buffering?
        if (fLogger) {
            fLogger->log(Logger::Level::kError, "Cannot parse streaming content.\n");
        }
        return nullptr;
    }
 
    auto data = SkData::MakeFromStream(stream, stream->getLength());
    if (!data) {
        if (fLogger) {
            fLogger->log(Logger::Level::kError, "Failed to read the input stream.\n");
        }
        return nullptr;
    }
 
    return this->make(static_cast<const char*>(data->data()), data->size());
}

makeFromFile()

sk_sp< Animation > skottie::Animation::Builder::makeFromFile

(

const char

path[]

)

Definition at line 459 of file Skottie.cpp.

                                                                 {
    const auto data = SkData::MakeFromFileName(path);
 
    return data ? this->make(static_cast<const char*>(data->data()), data->size())
                : nullptr;
}

setExpressionManager()

Animation::Builder & skottie::Animation::Builder::setExpressionManager

(

sk_sp< ExpressionManager >

em

)

Registers an ExpressionManager to evaluate AE expressions. If unspecified, expressions in the animation JSON will be ignored.

Definition at line 339 of file Skottie.cpp.

                                                                                    {
    fExpressionManager = std::move(em);
    return *this;
}

setFontManager()

Animation::Builder & skottie::Animation::Builder::setFontManager

(

sk_sp< SkFontMgr >

fmgr

)

Specify a font manager for loading animation fonts.

Definition at line 314 of file Skottie.cpp.

                                                                        {
    fFontMgr = std::move(fmgr);
    return *this;
}

setLogger()

Animation::Builder & skottie::Animation::Builder::setLogger

(

sk_sp< Logger >

logger

)

Register a Logger with this builder.

Definition at line 324 of file Skottie.cpp.

                                                                  {
    fLogger = std::move(logger);
    return *this;
}

setMarkerObserver()

Animation::Builder & skottie::Animation::Builder::setMarkerObserver

(

sk_sp< MarkerObserver >

mobserver

)

Register a MarkerObserver with this builder.

Definition at line 329 of file Skottie.cpp.

                                                                                     {
    fMarkerObserver = std::move(mobserver);
    return *this;
}

setPrecompInterceptor()

Animation::Builder & skottie::Animation::Builder::setPrecompInterceptor

(

sk_sp< PrecompInterceptor >

pi

)

Register a precomp layer interceptor. This allows substituting precomp layers with custom/externally managed content.

Definition at line 334 of file Skottie.cpp.

                                                                                      {
    fPrecompInterceptor = std::move(pi);
    return *this;
}

setPropertyObserver()

Animation::Builder & skottie::Animation::Builder::setPropertyObserver

(

sk_sp< PropertyObserver >

pobserver

)

Specify a PropertyObserver to receive callbacks during parsing.

See SkottieProperty.h for more details.

Definition at line 319 of file Skottie.cpp.

                                                                                         {
    fPropertyObserver = std::move(pobserver);
    return *this;
}

setResourceProvider()

Animation::Builder & skottie::Animation::Builder::setResourceProvider

(

sk_sp< ResourceProvider >

rp

)

Specify a loader for external resources (images, etc.).

Definition at line 309 of file Skottie.cpp.

                                                                                  {
    fResourceProvider = std::move(rp);
    return *this;
}

setTextShapingFactory()

Animation::Builder & skottie::Animation::Builder::setTextShapingFactory

(

sk_sp< SkShapers::Factory >

factory

)

Registers a factory to be used when shaping text. If unspecified, text will be shaped with primitive shaping. See //modules/skshaper/utils/FactoryHelpers.h

Definition at line 344 of file Skottie.cpp.

                                                                                         {
    fShapingFactory = std::move(factory);
    return *this;
}

---

The documentation for this class was generated from the following files:

• third_party/skia/modules/skottie/include/Skottie.h
• third_party/skia/modules/skottie/src/Skottie.cpp