More coverage

Author: kunitoki

examples/graphics/CMakeLists.txt

@@ -26,6 +26,7 @@ set (target_version "1.0.0")
 project (${target_name} VERSION ${target_version})
 
 set (rive_file "data/alien.riv")
+set (lottie_file "data/goal.lottie")
 
 # ==== Prepare Android build
 set (link_libraries "")
@@ -40,8 +41,10 @@ if (ANDROID)
         NAMESPACE yup
         RESOURCE_NAMES
             RiveFile
+            LottieFile
         RESOURCES
-            "${CMAKE_CURRENT_LIST_DIR}/${rive_file}")
+            "${CMAKE_CURRENT_LIST_DIR}/${rive_file}"
+            "${CMAKE_CURRENT_LIST_DIR}/${lottie_file}")
 
     set (link_libraries "${target_name}_binary_data")
 endif()
@@ -64,9 +67,11 @@ yup_standalone_app (
     STACK_SIZE 4194304
     DEFINITIONS
         YUP_EXAMPLE_GRAPHICS_RIVE_FILE="${rive_file}"
+        YUP_EXAMPLE_GRAPHICS_LOTTIE_FILE="${lottie_file}"
         ${additional_definitions}
     PRELOAD_FILES
         "${CMAKE_CURRENT_LIST_DIR}/${rive_file}@${rive_file}"
+        "${CMAKE_CURRENT_LIST_DIR}/${lottie_file}@${lottie_file}"
     MODULES
         yup::yup_core
         yup::yup_audio_basics

examples/graphics/source/examples/Artboard.h

@@ -41,19 +41,8 @@ class ArtboardDemo : public yup::Component
 #if YUP_ANDROID
         yup::MemoryInputStream is (yup::RiveFile_data, yup::RiveFile_size, false);
         auto artboardFile = yup::ArtboardFile::load (is, *factory);
-
-#else
-        yup::File riveBasePath;
-#if YUP_WASM
-        riveBasePath = yup::File ("/");
 #else
-        riveBasePath = yup::File (__FILE__)
-                           .getParentDirectory()
-                           .getParentDirectory()
-                           .getParentDirectory();
-#endif
-
-        auto artboardFile = yup::ArtboardFile::load (riveBasePath.getChildFile (YUP_EXAMPLE_GRAPHICS_RIVE_FILE), *factory);
+        auto artboardFile = yup::ArtboardFile::load (getAssetPath (YUP_EXAMPLE_GRAPHICS_RIVE_FILE), *factory);
 #endif
         if (! artboardFile)
             return false;

examples/graphics/source/examples/LottieDemo.h

@@ -161,12 +161,18 @@ class LottieDemo : public yup::Component
         {
             playPauseButton->setButtonText ("Play");
         };
-    }
 
-    ~LottieDemo() override
-    {
+#if YUP_ANDROID
+        yup::MemoryInputStream is (yup::LottieFile_data, yup::LottieFile_size, false);
+        loadStream (is);
+
+#else
+        loadFile (getAssetPath (YUP_EXAMPLE_GRAPHICS_LOTTIE_FILE));
+#endif
     }
 
+    ~LottieDemo() override = default;
+
     void refreshDisplay (double lastFrameTimeSeconds) override
     {
         if (! player.isPlaying())
@@ -269,6 +275,18 @@ class LottieDemo : public yup::Component
         });
     }
 
+    void loadStream (yup::MemoryInputStream& stream)
+    {
+        auto anim = yup::Animation::loadFromStream (stream);
+        if (! anim.isValid())
+        {
+            statusLabel->setText ("Failed to load animation from stream", yup::dontSendNotification);
+            return;
+        }
+
+        initializePlayer (std::move (anim));
+    }
+
     void loadFile (const yup::File& file)
     {
         auto anim = yup::Animation::loadFromFile (file);
@@ -278,6 +296,11 @@ class LottieDemo : public yup::Component
             return;
         }
 
+        initializePlayer (std::move (anim), file);
+    }
+
+    void initializePlayer (yup::Animation anim, const yup::File& file = {})
+    {
         player.stop();
         player.setAnimation (std::move (anim));
         player.setLooping (looping);

examples/graphics/source/main.cpp

@@ -37,6 +37,28 @@
 #include <BinaryData.h>
 #endif
 
+//==============================================================================
+
+inline yup::File getAssetPath (yup::StringRef subPath = {})
+{
+    yup::File basePath;
+
+#if YUP_WASM
+    basePath = yup::File ("/");
+#else
+    basePath = yup::File (__FILE__)
+                   .getParentDirectory()
+                   .getParentDirectory();
+#endif
+
+    if (! subPath.isEmpty())
+        basePath = basePath.getChildFile (subPath);
+
+    return basePath;
+}
+
+//==============================================================================
+
 #include "examples/Artboard.h"
 #include "examples/Audio.h"
 #include "examples/AudioFileDemo.h"

modules/yup_animation/animation/yup_Animation.cpp

@@ -66,6 +66,18 @@ Animation Animation::loadFromData (const String& jsonText, const LoadOptions& op
     return Animation (std::move (comp));
 }
 
+Animation Animation::loadFromStream (InputStream& stream, const LoadOptions& opts)
+{
+    LottieLoadOptions loaderOpts;
+    loaderOpts.resourceDirectory = opts.resourceDirectory;
+
+    auto comp = LottieReader::parseStream (stream, loaderOpts);
+    if (comp == nullptr)
+        return {};
+
+    return Animation (std::move (comp));
+}
+
 Animation Animation::fromComposition (AnimationComposition::Ptr comp)
 {
     return Animation (std::move (comp));

modules/yup_animation/animation/yup_Animation.h

@@ -77,6 +77,11 @@ class YUP_API Animation
     /** Loads a Lottie animation from a JSON string. */
     [[nodiscard]] static Animation loadFromData (const String& jsonText, const LoadOptions& opts = {});
 
+    /** Loads a Lottie animation from an InputStream.
+        The stream is fully consumed. Both plain JSON and .lottie ZIP streams are supported.
+        Returns an invalid Animation on failure. */
+    [[nodiscard]] static Animation loadFromStream (InputStream& stream, const LoadOptions& opts = {});
+
     /** Wraps an already-constructed AnimationComposition. */
     [[nodiscard]] static Animation fromComposition (AnimationComposition::Ptr comp);
 

modules/yup_animation/io/yup_LottieReader.cpp

@@ -132,23 +132,19 @@ AnimationComposition::Ptr LottieReader::parseFile (const File& file,
         return {};
     }
 
-    // .lottie files are ZIP archives
-    if (file.getFileExtension().equalsIgnoreCase (".lottie"))
-        return parseFromZip (file, {}, options, outError);
+    LottieLoadOptions opts = options;
+    if (opts.resourceDirectory == File())
+        opts.resourceDirectory = file.getParentDirectory();
 
-    const String text = file.loadFileAsString();
-    if (text.isEmpty())
+    auto stream = file.createInputStream();
+    if (stream == nullptr)
     {
         if (outError != nullptr)
-            *outError = "Empty file: " + file.getFullPathName();
+            *outError = "Failed to open file: " + file.getFullPathName();
         return {};
     }
 
-    LottieLoadOptions opts = options;
-    if (opts.resourceDirectory == File())
-        opts.resourceDirectory = file.getParentDirectory();
-
-    return parseData (text, opts, outError);
+    return parseStream (*stream, opts, outError);
 }
 
 //==============================================================================
@@ -169,6 +165,78 @@ AnimationComposition::Ptr LottieReader::parseData (const String& jsonText,
     return reader.parseRoot (root);
 }
 
+//==============================================================================
+AnimationComposition::Ptr LottieReader::parseStream (InputStream& stream,
+                                                     const LottieLoadOptions& options,
+                                                     String* outError)
+{
+    MemoryBlock data;
+    const auto bytesRead = stream.readIntoMemoryBlock (data);
+    if (bytesRead == 0 || data.isEmpty())
+    {
+        if (outError != nullptr)
+            *outError = "Empty or unreadable stream";
+        return {};
+    }
+
+    // .lottie ZIP archives start with "PK" magic bytes
+    if (data.getSize() >= 2 && memcmp (data.getData(), "PK", 2) == 0)
+    {
+        MemoryInputStream memStream (data, false);
+        ZipFile zip (memStream);
+
+        const auto* manifestEntry = zip.getEntry ("manifest.json", true);
+        if (manifestEntry == nullptr)
+        {
+            if (outError != nullptr)
+                *outError = "manifest.json not found in .lottie stream";
+            return {};
+        }
+
+        std::unique_ptr<InputStream> manifestStream (zip.createStreamForEntry (*manifestEntry));
+        if (manifestStream == nullptr)
+            return {};
+
+        var manifest;
+        if (JSON::parse (manifestStream->readEntireStreamAsString(), manifest).failed())
+        {
+            if (outError != nullptr)
+                *outError = "Failed to parse manifest.json";
+            return {};
+        }
+
+        const auto* anims = safeArray (manifest["animations"]);
+        if (anims == nullptr || anims->isEmpty())
+        {
+            if (outError != nullptr)
+                *outError = "No animations found in manifest";
+            return {};
+        }
+
+        const auto& anim = (*anims)[0];
+        const String animId = varString (anim["id"]);
+        String jsonPath = varString (anim["path"]);
+        if (jsonPath.isEmpty())
+            jsonPath = "animations/" + animId + ".json";
+
+        const auto* jsonEntry = zip.getEntry (jsonPath, true);
+        if (jsonEntry == nullptr)
+        {
+            if (outError != nullptr)
+                *outError = "Animation JSON not found inside archive: " + jsonPath;
+            return {};
+        }
+
+        std::unique_ptr<InputStream> jsonStream (zip.createStreamForEntry (*jsonEntry));
+        if (jsonStream == nullptr)
+            return {};
+
+        return parseData (jsonStream->readEntireStreamAsString(), options, outError);
+    }
+
+    return parseData (data.toString(), options, outError);
+}
+
 //==============================================================================
 std::vector<String> LottieReader::listAnimationIds (const File& lottieZipFile)
 {
@@ -240,8 +308,8 @@ AnimationComposition::Ptr LottieReader::parseFromZip (const File& lottieZipFile,
         if (animationId.isEmpty() || id == animationId)
         {
             jsonPath = varString (anim["path"]);
-            if (! jsonPath.endsWithIgnoreCase (".json"))
-                jsonPath += ".json";
+            if (jsonPath.isEmpty())
+                jsonPath = "animations/" + id + ".json";
             break;
         }
     }
@@ -644,7 +712,7 @@ AnimationLayer::Ptr LottieReader::parseLayer (const var& layerObj)
         il->assetRefId = varString (layerObj["refId"]);
         layer = il;
     }
-    else if (ty == 5) // Text — parsed as NullLayer (text rendering not yet supported)
+    else if (ty == 5) // Text — TODO: parsed as NullLayer (text rendering not yet supported)
     {
         layer = new NullLayer();
     }
@@ -656,7 +724,7 @@ AnimationLayer::Ptr LottieReader::parseLayer (const var& layerObj)
     if (layer == nullptr)
         return {};
 
-    // Self-parenting check (gap 22)
+    // Self-parenting check
     if (layer->parentId >= 0 && layer->id == layer->parentId)
     {
         if (errorOut_ != nullptr)

modules/yup_animation/io/yup_LottieReader.h

@@ -57,6 +57,15 @@ class YUP_API LottieReader
                                                               const LottieLoadOptions& options = {},
                                                               String* outError = nullptr);
 
+    /** Parses a Lottie animation from an InputStream.
+        The stream is fully consumed. Both plain Lottie JSON and .lottie ZIP (binary)
+        streams are supported; the format is auto-detected.
+        Returns nullptr on failure.
+    */
+    [[nodiscard]] static AnimationComposition::Ptr parseStream (InputStream& stream,
+                                                                const LottieLoadOptions& options = {},
+                                                                String* outError = nullptr);
+
     /** Lists animation IDs contained inside a `.lottie` ZIP archive.
         Returns an empty vector if the file is not a valid .lottie file.
     */