@shopify/react-native-skia 0.1.158 → 0.1.159

package/cpp/skia/src/core/SkLRUCache.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkLRUCache_DEFINED
+#define SkLRUCache_DEFINED
+
+#include "include/private/SkChecksum.h"
+#include "include/private/SkTHash.h"
+#include "src/core/SkTInternalLList.h"
+
+/**
+ * A generic LRU cache.
+ */
+template <typename K, typename V, typename HashK = SkGoodHash>
+class SkLRUCache : public SkNoncopyable {
+private:
+    struct Entry {
+        Entry(const K& key, V&& value)
+        : fKey(key)
+        , fValue(std::move(value)) {}
+
+        K fKey;
+        V fValue;
+
+        SK_DECLARE_INTERNAL_LLIST_INTERFACE(Entry);
+    };
+
+public:
+    explicit SkLRUCache(int maxCount)
+    : fMaxCount(maxCount) {}
+
+    ~SkLRUCache() {
+        Entry* node = fLRU.head();
+        while (node) {
+            fLRU.remove(node);
+            delete node;
+            node = fLRU.head();
+        }
+    }
+
+    V* find(const K& key) {
+        Entry** value = fMap.find(key);
+        if (!value) {
+            return nullptr;
+        }
+        Entry* entry = *value;
+        if (entry != fLRU.head()) {
+            fLRU.remove(entry);
+            fLRU.addToHead(entry);
+        } // else it's already at head position, don't need to do anything
+        return &entry->fValue;
+    }
+
+    V* insert(const K& key, V value) {
+        SkASSERT(!this->find(key));
+
+        Entry* entry = new Entry(key, std::move(value));
+        fMap.set(entry);
+        fLRU.addToHead(entry);
+        while (fMap.count() > fMaxCount) {
+            this->remove(fLRU.tail()->fKey);
+        }
+        return &entry->fValue;
+    }
+
+    V* insert_or_update(const K& key, V value) {
+        if (V* found = this->find(key)) {
+            *found = std::move(value);
+            return found;
+        } else {
+            return this->insert(key, std::move(value));
+        }
+    }
+
+    int count() {
+        return fMap.count();
+    }
+
+    template <typename Fn>  // f(K*, V*)
+    void foreach(Fn&& fn) {
+        typename SkTInternalLList<Entry>::Iter iter;
+        for (Entry* e = iter.init(fLRU, SkTInternalLList<Entry>::Iter::kHead_IterStart); e;
+             e = iter.next()) {
+            fn(&e->fKey, &e->fValue);
+        }
+    }
+
+    void reset() {
+        fMap.reset();
+        for (Entry* e = fLRU.head(); e; e = fLRU.head()) {
+            fLRU.remove(e);
+            delete e;
+        }
+    }
+
+private:
+    struct Traits {
+        static const K& GetKey(Entry* e) {
+            return e->fKey;
+        }
+
+        static uint32_t Hash(const K& k) {
+            return HashK()(k);
+        }
+    };
+
+    void remove(const K& key) {
+        Entry** value = fMap.find(key);
+        SkASSERT(value);
+        Entry* entry = *value;
+        SkASSERT(key == entry->fKey);
+        fMap.remove(key);
+        fLRU.remove(entry);
+        delete entry;
+    }
+
+    int                             fMaxCount;
+    SkTHashTable<Entry*, K, Traits> fMap;
+    SkTInternalLList<Entry>         fLRU;
+};
+
+#endif

package/cpp/skia/src/core/SkTInternalLList.h

@@ -0,0 +1,302 @@
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTInternalLList_DEFINED
+#define SkTInternalLList_DEFINED
+
+#include "include/core/SkTypes.h"
+
+/**
+ * This macro creates the member variables required by the SkTInternalLList class. It should be
+ * placed in the private section of any class that will be stored in a double linked list.
+ */
+#define SK_DECLARE_INTERNAL_LLIST_INTERFACE(ClassName)              \
+    friend class SkTInternalLList<ClassName>;                       \
+    /* back pointer to the owning list - for debugging */           \
+    SkDEBUGCODE(SkTInternalLList<ClassName>* fList = nullptr;)      \
+    ClassName* fPrev = nullptr;                                     \
+    ClassName* fNext = nullptr
+
+/**
+ * This class implements a templated internal doubly linked list data structure.
+ */
+template <class T> class SkTInternalLList {
+public:
+    SkTInternalLList() {}
+
+    void reset() {
+        fHead = nullptr;
+        fTail = nullptr;
+    }
+
+    void remove(T* entry) {
+        SkASSERT(fHead && fTail);
+        SkASSERT(this->isInList(entry));
+
+        T* prev = entry->fPrev;
+        T* next = entry->fNext;
+
+        if (prev) {
+            prev->fNext = next;
+        } else {
+            fHead = next;
+        }
+        if (next) {
+            next->fPrev = prev;
+        } else {
+            fTail = prev;
+        }
+
+        entry->fPrev = nullptr;
+        entry->fNext = nullptr;
+
+#ifdef SK_DEBUG
+        entry->fList = nullptr;
+#endif
+    }
+
+    void addToHead(T* entry) {
+        SkASSERT(nullptr == entry->fPrev && nullptr == entry->fNext);
+        SkASSERT(nullptr == entry->fList);
+
+        entry->fPrev = nullptr;
+        entry->fNext = fHead;
+        if (fHead) {
+            fHead->fPrev = entry;
+        }
+        fHead = entry;
+        if (nullptr == fTail) {
+            fTail = entry;
+        }
+
+#ifdef SK_DEBUG
+        entry->fList = this;
+#endif
+    }
+
+    void addToTail(T* entry) {
+        SkASSERT(nullptr == entry->fPrev && nullptr == entry->fNext);
+        SkASSERT(nullptr == entry->fList);
+
+        entry->fPrev = fTail;
+        entry->fNext = nullptr;
+        if (fTail) {
+            fTail->fNext = entry;
+        }
+        fTail = entry;
+        if (nullptr == fHead) {
+            fHead = entry;
+        }
+
+#ifdef SK_DEBUG
+        entry->fList = this;
+#endif
+    }
+
+    /**
+     * Inserts a new list entry before an existing list entry. The new entry must not already be
+     * a member of this or any other list. If existingEntry is NULL then the new entry is added
+     * at the tail.
+     */
+    void addBefore(T* newEntry, T* existingEntry) {
+        SkASSERT(newEntry);
+
+        if (nullptr == existingEntry) {
+            this->addToTail(newEntry);
+            return;
+        }
+
+        SkASSERT(this->isInList(existingEntry));
+        newEntry->fNext = existingEntry;
+        T* prev = existingEntry->fPrev;
+        existingEntry->fPrev = newEntry;
+        newEntry->fPrev = prev;
+        if (nullptr == prev) {
+            SkASSERT(fHead == existingEntry);
+            fHead = newEntry;
+        } else {
+            prev->fNext = newEntry;
+        }
+#ifdef SK_DEBUG
+        newEntry->fList = this;
+#endif
+    }
+
+    /**
+     * Inserts a new list entry after an existing list entry. The new entry must not already be
+     * a member of this or any other list. If existingEntry is NULL then the new entry is added
+     * at the head.
+     */
+    void addAfter(T* newEntry, T* existingEntry) {
+        SkASSERT(newEntry);
+
+        if (nullptr == existingEntry) {
+            this->addToHead(newEntry);
+            return;
+        }
+
+        SkASSERT(this->isInList(existingEntry));
+        newEntry->fPrev = existingEntry;
+        T* next = existingEntry->fNext;
+        existingEntry->fNext = newEntry;
+        newEntry->fNext = next;
+        if (nullptr == next) {
+            SkASSERT(fTail == existingEntry);
+            fTail = newEntry;
+        } else {
+            next->fPrev = newEntry;
+        }
+#ifdef SK_DEBUG
+        newEntry->fList = this;
+#endif
+    }
+
+    void concat(SkTInternalLList&& list) {
+        if (list.isEmpty()) {
+            return;
+        }
+
+        list.fHead->fPrev = fTail;
+        if (!fHead) {
+            SkASSERT(!list.fHead->fPrev);
+            fHead = list.fHead;
+        } else {
+            SkASSERT(fTail);
+            fTail->fNext = list.fHead;
+        }
+        fTail = list.fTail;
+
+#ifdef SK_DEBUG
+        for (T* node = list.fHead; node; node = node->fNext) {
+            SkASSERT(node->fList == &list);
+            node->fList = this;
+        }
+#endif
+
+        list.fHead = list.fTail = nullptr;
+    }
+
+    bool isEmpty() const {
+        SkASSERT(SkToBool(fHead) == SkToBool(fTail));
+        return !fHead;
+    }
+
+    T* head() const { return fHead; }
+    T* tail() const { return fTail; }
+
+    class Iter {
+    public:
+        enum IterStart {
+            kHead_IterStart,
+            kTail_IterStart
+        };
+
+        Iter() : fCurr(nullptr) {}
+        Iter(const Iter& iter) : fCurr(iter.fCurr) {}
+        Iter& operator= (const Iter& iter) { fCurr = iter.fCurr; return *this; }
+
+        T* init(const SkTInternalLList& list, IterStart startLoc) {
+            if (kHead_IterStart == startLoc) {
+                fCurr = list.fHead;
+            } else {
+                SkASSERT(kTail_IterStart == startLoc);
+                fCurr = list.fTail;
+            }
+
+            return fCurr;
+        }
+
+        T* get() { return fCurr; }
+
+        /**
+         * Return the next/previous element in the list or NULL if at the end.
+         */
+        T* next() {
+            if (nullptr == fCurr) {
+                return nullptr;
+            }
+
+            fCurr = fCurr->fNext;
+            return fCurr;
+        }
+
+        T* prev() {
+            if (nullptr == fCurr) {
+                return nullptr;
+            }
+
+            fCurr = fCurr->fPrev;
+            return fCurr;
+        }
+
+        /**
+         * C++11 range-for interface.
+         */
+        bool operator!=(const Iter& that) { return fCurr != that.fCurr; }
+        T* operator*() { return this->get(); }
+        void operator++() { this->next(); }
+
+    private:
+        T* fCurr;
+    };
+
+    Iter begin() const {
+        Iter iter;
+        iter.init(*this, Iter::kHead_IterStart);
+        return iter;
+    }
+
+    Iter end() const { return Iter(); }
+
+#ifdef SK_DEBUG
+    void validate() const {
+        SkASSERT(!fHead == !fTail);
+        Iter iter;
+        for (T* item = iter.init(*this, Iter::kHead_IterStart); item; item = iter.next()) {
+            SkASSERT(this->isInList(item));
+            if (nullptr == item->fPrev) {
+                SkASSERT(fHead == item);
+            } else {
+                SkASSERT(item->fPrev->fNext == item);
+            }
+            if (nullptr == item->fNext) {
+                SkASSERT(fTail == item);
+            } else {
+                SkASSERT(item->fNext->fPrev == item);
+            }
+        }
+    }
+
+    /**
+     * Debugging-only method that uses the list back pointer to check if 'entry' is indeed in 'this'
+     * list.
+     */
+    bool isInList(const T* entry) const {
+        return entry->fList == this;
+    }
+
+    /**
+     * Debugging-only method that laboriously counts the list entries.
+     */
+    int countEntries() const {
+        int count = 0;
+        for (T* entry = fHead; entry; entry = entry->fNext) {
+            ++count;
+        }
+        return count;
+    }
+#endif // SK_DEBUG
+
+private:
+    T* fHead = nullptr;
+    T* fTail = nullptr;
+
+    SkTInternalLList(const SkTInternalLList&) = delete;
+    SkTInternalLList& operator=(const SkTInternalLList&) = delete;
+};
+
+#endif

package/cpp/utils/RNSkTimingInfo.h

@@ -29,6 +29,7 @@ public:
     _frameCount = 0;
     _lastFrameCount = -1;
     _didSkip = false;
+    _average = 0;
   }
 
   void beginTiming() { _start = high_resolution_clock::now(); }

package/ios/RNSkia-iOS/RNSkMetalCanvasProvider.h

@@ -6,6 +6,14 @@
 #import <MetalKit/MetalKit.h>
 #import <QuartzCore/CAMetalLayer.h>
 
+using MetalRenderContext = struct {
+  id<MTLCommandQueue> commandQueue;
+  sk_sp<GrDirectContext> skContext;
+};
+
+static std::unordered_map<std::thread::id, std::shared_ptr<MetalRenderContext>>
+    renderContexts;
+
 class RNSkMetalCanvasProvider : public RNSkia::RNSkCanvasProvider {
 public:
   RNSkMetalCanvasProvider(std::function<void()> requestRedraw,
@@ -23,6 +31,13 @@ public:
   CALayer *getLayer();
 
 private:
+  /**
+   * To be able to use static contexts (and avoid reloading the skia context for
+   * each new view, we track the Skia drawing context per thread.
+   * @return The drawing context for the current thread
+   */
+  static std::shared_ptr<MetalRenderContext> getMetalRenderContext();
+
   std::shared_ptr<RNSkia::RNSkPlatformContext> _context;
   float _width = -1;
   float _height = -1;
@@ -30,8 +45,4 @@ private:
 #pragma clang diagnostic ignored "-Wunguarded-availability-new"
   CAMetalLayer *_layer;
 #pragma clang diagnostic pop
-
-  static id<MTLCommandQueue> _commandQueue;
-  static id<MTLDevice> _device;
-  static sk_sp<GrDirectContext> _skContext;
 };

package/ios/RNSkia-iOS/RNSkMetalCanvasProvider.mm

@@ -12,50 +12,40 @@
 
 #pragma clang diagnostic pop
 
-// These static class members are used by all Skia Views
-id<MTLDevice> RNSkMetalCanvasProvider::_device = nullptr;
-id<MTLCommandQueue> RNSkMetalCanvasProvider::_commandQueue = nullptr;
-sk_sp<GrDirectContext> RNSkMetalCanvasProvider::_skContext = nullptr;
+/** Static members */
+std::shared_ptr<MetalRenderContext>
+RNSkMetalCanvasProvider::getMetalRenderContext() {
+  auto threadId = std::this_thread::get_id();
+  if (renderContexts.count(threadId) == 0) {
+    auto drawingContext = std::make_shared<MetalRenderContext>();
+    drawingContext->commandQueue = nullptr;
+    drawingContext->skContext = nullptr;
+    renderContexts.emplace(threadId, drawingContext);
+  }
+  return renderContexts.at(threadId);
+}
 
 RNSkMetalCanvasProvider::RNSkMetalCanvasProvider(std::function<void()> requestRedraw,
                         std::shared_ptr<RNSkia::RNSkPlatformContext> context):
 RNSkCanvasProvider(requestRedraw),
   _context(context) {
-  if (!_device) {
-    _device = MTLCreateSystemDefaultDevice();
-  }
-  if (!_commandQueue) {
-    _commandQueue = id<MTLCommandQueue>(CFRetain((GrMTLHandle)[_device newCommandQueue]));
-  }
-
   #pragma clang diagnostic push
   #pragma clang diagnostic ignored "-Wunguarded-availability-new"
   _layer = [CAMetalLayer layer];
   #pragma clang diagnostic pop
     
+  auto device = MTLCreateSystemDefaultDevice();
+    
   _layer.framebufferOnly = NO;
-  _layer.device = _device;
+  _layer.device = device;
   _layer.opaque = false;
   _layer.contentsScale = _context->getPixelDensity();
   _layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
+  _layer.contentsGravity = kCAGravityBottomRight;
 }
 
 RNSkMetalCanvasProvider::~RNSkMetalCanvasProvider() {
-  if([[NSThread currentThread] isMainThread]) {
-    _layer = NULL;
-  } else {
-    __block auto tempLayer = _layer;
-    dispatch_async(dispatch_get_main_queue(), ^{
-      // By using the tempLayer variable in the block we capture it and it will be
-      // released after the block has finished. This way the CAMetalLayer dealloc will
-      // only be called on the main thread. Problem: this destructor might be called from
-      // releasing the RNSkDrawViewImpl from a thread capture (after dtor has started),
-      // which would cause the CAMetalLayer dealloc to be called on another thread which
-      // causes a crash.
-      // https://github.com/Shopify/react-native-skia/issues/398
-      tempLayer = tempLayer;
-    });
-  }
+  
 }
 
 /**
@@ -76,11 +66,13 @@ void RNSkMetalCanvasProvider::renderToCanvas(const std::function<void(SkCanvas*)
     return;
   }
   
-  if(_skContext == nullptr) {
-    GrContextOptions grContextOptions;
-    _skContext = GrDirectContext::MakeMetal((__bridge void*)_device,
-                                            (__bridge void*)_commandQueue,
-                                            grContextOptions);
+  // Get render context for current thread
+  auto renderContext = getMetalRenderContext();
+  
+  if (renderContext->skContext == nullptr) {
+    auto device = MTLCreateSystemDefaultDevice();
+    renderContext->commandQueue = id<MTLCommandQueue>(CFRetain((GrMTLHandle)[device newCommandQueue]));
+    renderContext->skContext = GrDirectContext::MakeMetal((__bridge void*)device, (__bridge void*)renderContext->commandQueue);
   }
   
   // Wrap in auto release pool since we want the system to clean up after rendering
@@ -88,35 +80,29 @@ void RNSkMetalCanvasProvider::renderToCanvas(const std::function<void(SkCanvas*)
   // fast in the simulator without this.
   @autoreleasepool
   {
-    id<CAMetalDrawable> currentDrawable = [_layer nextDrawable];
-    if(currentDrawable == nullptr) {
-      return;
-    }
-    
-    GrMtlTextureInfo fbInfo;
-    fbInfo.fTexture.retain((__bridge void*)currentDrawable.texture);
-    
-    GrBackendRenderTarget backendRT(_layer.drawableSize.width,
-                                    _layer.drawableSize.height,
-                                    1,
-                                    fbInfo);
-
-    auto skSurface = SkSurface::MakeFromBackendRenderTarget(_skContext.get(),
-                                                            backendRT,
-                                                            kTopLeft_GrSurfaceOrigin,
-                                                            kBGRA_8888_SkColorType,
-                                                            nullptr,
-                                                            nullptr);
+    GrMTLHandle drawableHandle;
+    auto skSurface = SkSurface::MakeFromCAMetalLayer(renderContext->skContext.get(),
+                                                     (__bridge GrMTLHandle)_layer,
+                                                     kTopLeft_GrSurfaceOrigin,
+                                                     1,
+                                                     kBGRA_8888_SkColorType,
+                                                     nullptr,
+                                                     nullptr,
+                                                     &drawableHandle);
     
     if(skSurface == nullptr || skSurface->getCanvas() == nullptr) {
       RNSkia::RNSkLogger::logToConsole("Skia surface could not be created from parameters.");
       return;
     }
     
-    skSurface->getCanvas()->clear(SK_AlphaTRANSPARENT);
-    cb(skSurface->getCanvas());
+    SkCanvas *canvas = skSurface->getCanvas();
+    canvas->clear(SK_AlphaTRANSPARENT);
+    cb(canvas);    
+    skSurface->flushAndSubmit();
     
-    id<MTLCommandBuffer> commandBuffer([_commandQueue commandBuffer]);
+    id<CAMetalDrawable> currentDrawable = (__bridge id<CAMetalDrawable>)drawableHandle;
+    id<MTLCommandBuffer> commandBuffer([renderContext->commandQueue commandBuffer]);
+    commandBuffer.label = @"PresentSkia";
     [commandBuffer presentDrawable:currentDrawable];
     [commandBuffer commit];
   }

package/ios/RNSkia-iOS/SkiaDomViewManager.h

@@ -0,0 +1,8 @@
+
+#pragma once
+
+#import <React/RCTViewManager.h>
+
+@interface SkiaDomViewManager : RCTViewManager
+
+@end

package/ios/RNSkia-iOS/SkiaDomViewManager.mm

@@ -0,0 +1,51 @@
+
+#include <SkiaDomViewManager.h>
+#include <React/RCTBridge+Private.h>
+
+#include <RNSkPlatformContext.h>
+#include <RNSkDomView.h>
+#include <RNSkIOSView.h>
+
+#include <SkiaManager.h>
+#include <RNSkiaModule.h>
+#include <SkiaUIView.h>
+
+
+
+@implementation SkiaDomViewManager
+
+RCT_EXPORT_MODULE(SkiaDomView)
+
+- (SkiaManager*) skiaManager {
+  auto bridge = [RCTBridge currentBridge];
+  auto skiaModule = (RNSkiaModule*)[bridge moduleForName:@"RNSkia"];
+  return [skiaModule manager];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(nativeID, NSNumber, SkiaUIView) {
+  // Get parameter
+  int nativeId = [[RCTConvert NSString:json] intValue];
+  [(SkiaUIView*)view setNativeId:nativeId];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(mode, NSString, SkiaUIView) {
+  std::string mode = json != NULL ? [[RCTConvert NSString:json] UTF8String] : "default";
+  [(SkiaUIView*)view setDrawingMode: mode];
+}
+
+RCT_CUSTOM_VIEW_PROPERTY(debug, BOOL, SkiaUIView) {
+  bool debug = json != NULL ? [RCTConvert BOOL:json] : false;
+  [(SkiaUIView*)view setDebugMode: debug];
+}
+
+- (UIView *)view
+{
+  auto skManager = [[self skiaManager] skManager];
+  // Pass SkManager as a raw pointer to avoid circular dependenciesr
+  return [[SkiaUIView alloc] initWithManager: skManager.get()
+                                     factory: [](std::shared_ptr<RNSkia::RNSkPlatformContext> context) {
+    return std::make_shared<RNSkiOSView<RNSkia::RNSkDomView>>(context);
+  }];
+}
+
+@end