@momo-kits/native-kits 0.0.1-beta.4 → 0.0.1-beta.5

package/example/ios/Pods/SDWebImage/SDWebImage/Core/SDAnimatedImagePlayer.m

@@ -0,0 +1,420 @@
+/*
+* This file is part of the SDWebImage package.
+* (c) Olivier Poitrey <rs@dailymotion.com>
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
+
+#import "SDAnimatedImagePlayer.h"
+#import "NSImage+Compatibility.h"
+#import "SDDisplayLink.h"
+#import "SDDeviceHelper.h"
+#import "SDInternalMacros.h"
+
+@interface SDAnimatedImagePlayer () {
+    SD_LOCK_DECLARE(_lock);
+    NSRunLoopMode _runLoopMode;
+}
+
+@property (nonatomic, strong, readwrite) UIImage *currentFrame;
+@property (nonatomic, assign, readwrite) NSUInteger currentFrameIndex;
+@property (nonatomic, assign, readwrite) NSUInteger currentLoopCount;
+@property (nonatomic, strong) id<SDAnimatedImageProvider> animatedProvider;
+@property (nonatomic, strong) NSMutableDictionary<NSNumber *, UIImage *> *frameBuffer;
+@property (nonatomic, assign) NSTimeInterval currentTime;
+@property (nonatomic, assign) BOOL bufferMiss;
+@property (nonatomic, assign) BOOL needsDisplayWhenImageBecomesAvailable;
+@property (nonatomic, assign) BOOL shouldReverse;
+@property (nonatomic, assign) NSUInteger maxBufferCount;
+@property (nonatomic, strong) NSOperationQueue *fetchQueue;
+@property (nonatomic, strong) SDDisplayLink *displayLink;
+
+@end
+
+@implementation SDAnimatedImagePlayer
+
+- (instancetype)initWithProvider:(id<SDAnimatedImageProvider>)provider {
+    self = [super init];
+    if (self) {
+        NSUInteger animatedImageFrameCount = provider.animatedImageFrameCount;
+        // Check the frame count
+        if (animatedImageFrameCount <= 1) {
+            return nil;
+        }
+        self.totalFrameCount = animatedImageFrameCount;
+        // Get the current frame and loop count.
+        self.totalLoopCount = provider.animatedImageLoopCount;
+        self.animatedProvider = provider;
+        self.playbackRate = 1.0;
+        SD_LOCK_INIT(_lock);
+#if SD_UIKIT
+        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didReceiveMemoryWarning:) name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
+#endif
+    }
+    return self;
+}
+
++ (instancetype)playerWithProvider:(id<SDAnimatedImageProvider>)provider {
+    SDAnimatedImagePlayer *player = [[SDAnimatedImagePlayer alloc] initWithProvider:provider];
+    return player;
+}
+
+#pragma mark - Life Cycle
+
+- (void)dealloc {
+#if SD_UIKIT
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
+#endif
+}
+
+- (void)didReceiveMemoryWarning:(NSNotification *)notification {
+    [_fetchQueue cancelAllOperations];
+    NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
+        NSNumber *currentFrameIndex = @(self.currentFrameIndex);
+        SD_LOCK(self->_lock);
+        NSArray *keys = self.frameBuffer.allKeys;
+        // only keep the next frame for later rendering
+        for (NSNumber * key in keys) {
+            if (![key isEqualToNumber:currentFrameIndex]) {
+                [self.frameBuffer removeObjectForKey:key];
+            }
+        }
+        SD_UNLOCK(self->_lock);
+    }];
+    [_fetchQueue addOperation:operation];
+}
+
+#pragma mark - Private
+- (NSOperationQueue *)fetchQueue {
+    if (!_fetchQueue) {
+        _fetchQueue = [[NSOperationQueue alloc] init];
+        _fetchQueue.maxConcurrentOperationCount = 1;
+    }
+    return _fetchQueue;
+}
+
+- (NSMutableDictionary<NSNumber *,UIImage *> *)frameBuffer {
+    if (!_frameBuffer) {
+        _frameBuffer = [NSMutableDictionary dictionary];
+    }
+    return _frameBuffer;
+}
+
+- (SDDisplayLink *)displayLink {
+    if (!_displayLink) {
+        _displayLink = [SDDisplayLink displayLinkWithTarget:self selector:@selector(displayDidRefresh:)];
+        [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:self.runLoopMode];
+        [_displayLink stop];
+    }
+    return _displayLink;
+}
+
+- (void)setRunLoopMode:(NSRunLoopMode)runLoopMode {
+    if ([_runLoopMode isEqual:runLoopMode]) {
+        return;
+    }
+    if (_displayLink) {
+        if (_runLoopMode) {
+            [_displayLink removeFromRunLoop:[NSRunLoop mainRunLoop] forMode:_runLoopMode];
+        }
+        if (runLoopMode.length > 0) {
+            [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:runLoopMode];
+        }
+    }
+    _runLoopMode = [runLoopMode copy];
+}
+
+- (NSRunLoopMode)runLoopMode {
+    if (!_runLoopMode) {
+        _runLoopMode = [[self class] defaultRunLoopMode];
+    }
+    return _runLoopMode;
+}
+
+#pragma mark - State Control
+
+- (void)setupCurrentFrame {
+    if (self.currentFrameIndex != 0) {
+        return;
+    }
+    if (self.playbackMode == SDAnimatedImagePlaybackModeReverse ||
+               self.playbackMode == SDAnimatedImagePlaybackModeReversedBounce) {
+        self.currentFrameIndex = self.totalFrameCount - 1;
+    }
+    
+    if (!self.currentFrame && [self.animatedProvider isKindOfClass:[UIImage class]]) {
+        UIImage *image = (UIImage *)self.animatedProvider;
+        // Cache the poster image if available, but should not callback to avoid caller thread issues
+        #if SD_MAC
+        UIImage *posterFrame = [[NSImage alloc] initWithCGImage:image.CGImage scale:image.scale orientation:kCGImagePropertyOrientationUp];
+        #else
+        UIImage *posterFrame = [[UIImage alloc] initWithCGImage:image.CGImage scale:image.scale orientation:image.imageOrientation];
+        #endif
+        if (posterFrame) {
+            // HACK: The first frame should not check duration and immediately display
+            self.needsDisplayWhenImageBecomesAvailable = YES;
+            SD_LOCK(self->_lock);
+            self.frameBuffer[@(self.currentFrameIndex)] = posterFrame;
+            SD_UNLOCK(self->_lock);
+        }
+    }
+    
+}
+
+- (void)resetCurrentFrameStatus {
+    // These should not trigger KVO, user don't need to receive an `index == 0, image == nil` callback.
+    _currentFrame = nil;
+    _currentFrameIndex = 0;
+    _currentLoopCount = 0;
+    _currentTime = 0;
+    _bufferMiss = NO;
+    _needsDisplayWhenImageBecomesAvailable = NO;
+}
+
+- (void)clearFrameBuffer {
+    SD_LOCK(_lock);
+    [_frameBuffer removeAllObjects];
+    SD_UNLOCK(_lock);
+}
+
+#pragma mark - Animation Control
+- (void)startPlaying {
+    [self.displayLink start];
+    // Setup frame
+    [self setupCurrentFrame];
+    // Calculate max buffer size
+    [self calculateMaxBufferCount];
+}
+
+- (void)stopPlaying {
+    [_fetchQueue cancelAllOperations];
+    // Using `_displayLink` here because when UIImageView dealloc, it may trigger `[self stopAnimating]`, we already release the display link in SDAnimatedImageView's dealloc method.
+    [_displayLink stop];
+    // We need to reset the frame status, but not trigger any handle. This can ensure next time's playing status correct.
+    [self resetCurrentFrameStatus];
+}
+
+- (void)pausePlaying {
+    [_fetchQueue cancelAllOperations];
+    [_displayLink stop];
+}
+
+- (BOOL)isPlaying {
+    return _displayLink.isRunning;
+}
+
+- (void)seekToFrameAtIndex:(NSUInteger)index loopCount:(NSUInteger)loopCount {
+    if (index >= self.totalFrameCount) {
+        return;
+    }
+    self.currentFrameIndex = index;
+    self.currentLoopCount = loopCount;
+    self.currentFrame = [self.animatedProvider animatedImageFrameAtIndex:index];
+    [self handleFrameChange];
+}
+
+#pragma mark - Core Render
+- (void)displayDidRefresh:(SDDisplayLink *)displayLink {
+    // If for some reason a wild call makes it through when we shouldn't be animating, bail.
+    // Early return!
+    if (!self.isPlaying) {
+        return;
+    }
+    
+    NSUInteger totalFrameCount = self.totalFrameCount;
+    if (totalFrameCount <= 1) {
+        // Total frame count less than 1, wrong configuration and stop animating
+        [self stopPlaying];
+        return;
+    }
+    
+    NSTimeInterval playbackRate = self.playbackRate;
+    if (playbackRate <= 0) {
+        // Does not support <= 0 play rate
+        [self stopPlaying];
+        return;
+    }
+    
+    // Calculate refresh duration
+    NSTimeInterval duration = self.displayLink.duration;
+    
+    NSUInteger currentFrameIndex = self.currentFrameIndex;
+    NSUInteger nextFrameIndex = (currentFrameIndex + 1) % totalFrameCount;
+    
+    if (self.playbackMode == SDAnimatedImagePlaybackModeReverse) {
+        nextFrameIndex = currentFrameIndex == 0 ? (totalFrameCount - 1) : (currentFrameIndex - 1) % totalFrameCount;
+        
+    } else if (self.playbackMode == SDAnimatedImagePlaybackModeBounce ||
+               self.playbackMode == SDAnimatedImagePlaybackModeReversedBounce) {
+        if (currentFrameIndex == 0) {
+            self.shouldReverse = false;
+        } else if (currentFrameIndex == totalFrameCount - 1) {
+            self.shouldReverse = true;
+        }
+        nextFrameIndex = self.shouldReverse ? (currentFrameIndex - 1) : (currentFrameIndex + 1);
+        nextFrameIndex %= totalFrameCount;
+    }
+    
+    
+    // Check if we need to display new frame firstly
+    BOOL bufferFull = NO;
+    if (self.needsDisplayWhenImageBecomesAvailable) {
+        UIImage *currentFrame;
+        SD_LOCK(_lock);
+        currentFrame = self.frameBuffer[@(currentFrameIndex)];
+        SD_UNLOCK(_lock);
+        
+        // Update the current frame
+        if (currentFrame) {
+            SD_LOCK(_lock);
+            // Remove the frame buffer if need
+            if (self.frameBuffer.count > self.maxBufferCount) {
+                self.frameBuffer[@(currentFrameIndex)] = nil;
+            }
+            // Check whether we can stop fetch
+            if (self.frameBuffer.count == totalFrameCount) {
+                bufferFull = YES;
+            }
+            SD_UNLOCK(_lock);
+            
+            // Update the current frame immediately
+            self.currentFrame = currentFrame;
+            [self handleFrameChange];
+            
+            self.bufferMiss = NO;
+            self.needsDisplayWhenImageBecomesAvailable = NO;
+        }
+        else {
+            self.bufferMiss = YES;
+        }
+    }
+    
+    // Check if we have the frame buffer
+    if (!self.bufferMiss) {
+        // Then check if timestamp is reached
+        self.currentTime += duration;
+        NSTimeInterval currentDuration = [self.animatedProvider animatedImageDurationAtIndex:currentFrameIndex];
+        currentDuration = currentDuration / playbackRate;
+        if (self.currentTime < currentDuration) {
+            // Current frame timestamp not reached, prefetch frame in advance.
+            [self prefetchFrameAtIndex:currentFrameIndex
+                             nextIndex:nextFrameIndex
+                            bufferFull:bufferFull];
+            return;
+        }
+        
+        // Otherwise, we should be ready to display next frame
+        self.needsDisplayWhenImageBecomesAvailable = YES;
+        self.currentFrameIndex = nextFrameIndex;
+        self.currentTime -= currentDuration;
+        NSTimeInterval nextDuration = [self.animatedProvider animatedImageDurationAtIndex:nextFrameIndex];
+        nextDuration = nextDuration / playbackRate;
+        if (self.currentTime > nextDuration) {
+            // Do not skip frame
+            self.currentTime = nextDuration;
+        }
+        
+        // Update the loop count when last frame rendered
+        if (nextFrameIndex == 0) {
+            // Update the loop count
+            self.currentLoopCount++;
+            [self handleLoopChange];
+            
+            // if reached the max loop count, stop animating, 0 means loop indefinitely
+            NSUInteger maxLoopCount = self.totalLoopCount;
+            if (maxLoopCount != 0 && (self.currentLoopCount >= maxLoopCount)) {
+                [self stopPlaying];
+                return;
+            }
+        }
+    }
+    
+    // Since we support handler, check animating state again
+    if (!self.isPlaying) {
+        return;
+    }
+    
+    [self prefetchFrameAtIndex:currentFrameIndex
+                     nextIndex:nextFrameIndex
+                    bufferFull:bufferFull];
+}
+
+// Check if we should prefetch next frame or current frame
+// When buffer miss, means the decode speed is slower than render speed, we fetch current miss frame
+// Or, most cases, the decode speed is faster than render speed, we fetch next frame
+- (void)prefetchFrameAtIndex:(NSUInteger)currentIndex
+                   nextIndex:(NSUInteger)nextIndex
+                  bufferFull:(BOOL)bufferFull {
+    NSUInteger fetchFrameIndex = currentIndex;
+    UIImage *fetchFrame = nil;
+    if (!self.bufferMiss) {
+        fetchFrameIndex = nextIndex;
+        SD_LOCK(_lock);
+        fetchFrame = self.frameBuffer[@(nextIndex)];
+        SD_UNLOCK(_lock);
+    }
+    if (!fetchFrame && !bufferFull && self.fetchQueue.operationCount == 0) {
+        // Prefetch next frame in background queue
+        id<SDAnimatedImageProvider> animatedProvider = self.animatedProvider;
+        @weakify(self);
+        NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
+            @strongify(self);
+            if (!self) {
+                return;
+            }
+            UIImage *frame = [animatedProvider animatedImageFrameAtIndex:fetchFrameIndex];
+
+            BOOL isAnimating = self.displayLink.isRunning;
+            if (isAnimating) {
+                SD_LOCK(self->_lock);
+                self.frameBuffer[@(fetchFrameIndex)] = frame;
+                SD_UNLOCK(self->_lock);
+            }
+        }];
+        [self.fetchQueue addOperation:operation];
+    }
+}
+
+- (void)handleFrameChange {
+    if (self.animationFrameHandler) {
+        self.animationFrameHandler(self.currentFrameIndex, self.currentFrame);
+    }
+}
+
+- (void)handleLoopChange {
+    if (self.animationLoopHandler) {
+        self.animationLoopHandler(self.currentLoopCount);
+    }
+}
+
+#pragma mark - Util
+- (void)calculateMaxBufferCount {
+    NSUInteger bytes = CGImageGetBytesPerRow(self.currentFrame.CGImage) * CGImageGetHeight(self.currentFrame.CGImage);
+    if (bytes == 0) bytes = 1024;
+    
+    NSUInteger max = 0;
+    if (self.maxBufferSize > 0) {
+        max = self.maxBufferSize;
+    } else {
+        // Calculate based on current memory, these factors are by experience
+        NSUInteger total = [SDDeviceHelper totalMemory];
+        NSUInteger free = [SDDeviceHelper freeMemory];
+        max = MIN(total * 0.2, free * 0.6);
+    }
+    
+    NSUInteger maxBufferCount = (double)max / (double)bytes;
+    if (!maxBufferCount) {
+        // At least 1 frame
+        maxBufferCount = 1;
+    }
+    
+    self.maxBufferCount = maxBufferCount;
+}
+
++ (NSString *)defaultRunLoopMode {
+    // Key off `activeProcessorCount` (as opposed to `processorCount`) since the system could shut down cores in certain situations.
+    return [NSProcessInfo processInfo].activeProcessorCount > 1 ? NSRunLoopCommonModes : NSDefaultRunLoopMode;
+}
+
+@end

package/example/ios/Pods/SDWebImage/SDWebImage/Core/SDAnimatedImageRep.h

@@ -0,0 +1,23 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDWebImageCompat.h"
+
+#if SD_MAC
+
+/**
+ A subclass of `NSBitmapImageRep` to fix that GIF duration issue because `NSBitmapImageRep` will reset `NSImageCurrentFrameDuration` by using `kCGImagePropertyGIFDelayTime` but not `kCGImagePropertyGIFUnclampedDelayTime`.
+ This also fix the GIF loop count issue, which will use the Netscape standard (See http://www6.uniovi.es/gifanim/gifabout.htm)  to only place once when the `kCGImagePropertyGIFLoopCount` is nil. This is what modern browser's behavior.
+ Built in GIF coder use this instead of `NSBitmapImageRep` for better GIF rendering. If you do not want this, only enable `SDImageIOCoder`, which just call `NSImage` API and actually use `NSBitmapImageRep` for GIF image.
+ This also support APNG format using `SDImageAPNGCoder`. Which provide full alpha-channel support and the correct duration match the `kCGImagePropertyAPNGUnclampedDelayTime`.
+ */
+@interface SDAnimatedImageRep : NSBitmapImageRep
+
+@end
+
+#endif

package/example/ios/Pods/SDWebImage/SDWebImage/Core/SDAnimatedImageRep.m

@@ -0,0 +1,133 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDAnimatedImageRep.h"
+
+#if SD_MAC
+
+#import "SDImageIOAnimatedCoderInternal.h"
+#import "SDImageGIFCoder.h"
+#import "SDImageAPNGCoder.h"
+#import "SDImageHEICCoder.h"
+#import "SDImageAWebPCoder.h"
+
+@implementation SDAnimatedImageRep {
+    CGImageSourceRef _imageSource;
+}
+
+- (void)dealloc {
+    if (_imageSource) {
+        CFRelease(_imageSource);
+        _imageSource = NULL;
+    }
+}
+
+- (instancetype)copyWithZone:(NSZone *)zone {
+  SDAnimatedImageRep *imageRep = [super copyWithZone:zone];
+  CFRetain(imageRep->_imageSource);
+  return imageRep;
+}
+
+// `NSBitmapImageRep`'s `imageRepWithData:` is not designed initializer
++ (instancetype)imageRepWithData:(NSData *)data {
+    SDAnimatedImageRep *imageRep = [[SDAnimatedImageRep alloc] initWithData:data];
+    return imageRep;
+}
+
+// We should override init method for `NSBitmapImageRep` to do initialize about animated image format
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunguarded-availability"
+- (instancetype)initWithData:(NSData *)data {
+    self = [super initWithData:data];
+    if (self) {
+        CGImageSourceRef imageSource = CGImageSourceCreateWithData((__bridge CFDataRef) data, NULL);
+        if (!imageSource) {
+            return self;
+        }
+        _imageSource = imageSource;
+        NSUInteger frameCount = CGImageSourceGetCount(imageSource);
+        if (frameCount <= 1) {
+            return self;
+        }
+        CFStringRef type = CGImageSourceGetType(imageSource);
+        if (!type) {
+            return self;
+        }
+        if (CFStringCompare(type, kSDUTTypeGIF, 0) == kCFCompareEqualTo) {
+            // GIF
+            // Fix the `NSBitmapImageRep` GIF loop count calculation issue
+            // Which will use 0 when there are no loop count information metadata in GIF data
+            NSUInteger loopCount = [SDImageGIFCoder imageLoopCountWithSource:imageSource];
+            [self setProperty:NSImageLoopCount withValue:@(loopCount)];
+        } else if (CFStringCompare(type, kSDUTTypePNG, 0) == kCFCompareEqualTo) {
+            // APNG
+            // Do initialize about frame count, current frame/duration and loop count
+            [self setProperty:NSImageFrameCount withValue:@(frameCount)];
+            [self setProperty:NSImageCurrentFrame withValue:@(0)];
+            NSUInteger loopCount = [SDImageAPNGCoder imageLoopCountWithSource:imageSource];
+            [self setProperty:NSImageLoopCount withValue:@(loopCount)];
+        } else if (CFStringCompare(type, kSDUTTypeHEICS, 0) == kCFCompareEqualTo) {
+            // HEIC
+            // Do initialize about frame count, current frame/duration and loop count
+            [self setProperty:NSImageFrameCount withValue:@(frameCount)];
+            [self setProperty:NSImageCurrentFrame withValue:@(0)];
+            NSUInteger loopCount = [SDImageHEICCoder imageLoopCountWithSource:imageSource];
+            [self setProperty:NSImageLoopCount withValue:@(loopCount)];
+        } else if (CFStringCompare(type, kSDUTTypeWebP, 0) == kCFCompareEqualTo) {
+            // WebP
+            // Do initialize about frame count, current frame/duration and loop count
+            [self setProperty:NSImageFrameCount withValue:@(frameCount)];
+            [self setProperty:NSImageCurrentFrame withValue:@(0)];
+            NSUInteger loopCount = [SDImageAWebPCoder imageLoopCountWithSource:imageSource];
+            [self setProperty:NSImageLoopCount withValue:@(loopCount)];
+        }
+    }
+    return self;
+}
+
+// `NSBitmapImageRep` will use `kCGImagePropertyGIFDelayTime` whenever you call `setProperty:withValue:` with `NSImageCurrentFrame` to change the current frame. We override it and use the actual `kCGImagePropertyGIFUnclampedDelayTime` if need.
+- (void)setProperty:(NSBitmapImageRepPropertyKey)property withValue:(id)value {
+    [super setProperty:property withValue:value];
+    if ([property isEqualToString:NSImageCurrentFrame]) {
+        // Access the image source
+        CGImageSourceRef imageSource = _imageSource;
+        if (!imageSource) {
+            return;
+        }
+        // Check format type
+        CFStringRef type = CGImageSourceGetType(imageSource);
+        if (!type) {
+            return;
+        }
+        NSUInteger index = [value unsignedIntegerValue];
+        NSTimeInterval frameDuration = 0;
+        if (CFStringCompare(type, kSDUTTypeGIF, 0) == kCFCompareEqualTo) {
+            // GIF
+            frameDuration = [SDImageGIFCoder frameDurationAtIndex:index source:imageSource];
+        } else if (CFStringCompare(type, kSDUTTypePNG, 0) == kCFCompareEqualTo) {
+            // APNG
+            frameDuration = [SDImageAPNGCoder frameDurationAtIndex:index source:imageSource];
+        } else if (CFStringCompare(type, kSDUTTypeHEICS, 0) == kCFCompareEqualTo) {
+            // HEIC
+            frameDuration = [SDImageHEICCoder frameDurationAtIndex:index source:imageSource];
+        } else if (CFStringCompare(type, kSDUTTypeWebP, 0) == kCFCompareEqualTo) {
+            // WebP
+            frameDuration = [SDImageAWebPCoder frameDurationAtIndex:index source:imageSource];
+        }
+        if (!frameDuration) {
+            return;
+        }
+        // Reset super frame duration with the actual frame duration
+        [super setProperty:NSImageCurrentFrameDuration withValue:@(frameDuration)];
+    }
+}
+#pragma clang diagnostic pop
+
+@end
+
+#endif