react-native-fast-image 8.23.0 → 8.24.0

package/README.md

@@ -105,6 +105,25 @@ When `source` changes, the image that's showing stays until the new one has load
 
 Remote url to load the image from. e.g. `'https://facebook.github.io/react/img/logo_og.png'`.
 
+#### Photo library images (iOS)
+
+A photo library url (`ph://<localIdentifier>`, as camera roll libraries give) loads when the app has SDWebImagePhotosPlugin. Add it to the app's `ios/Podfile` and run `pod install`:
+
+```ruby
+pod 'SDWebImagePhotosPlugin'
+```
+
+With Expo, add it with [expo-build-properties](https://docs.expo.dev/versions/latest/sdk/build-properties/):
+
+```json
+[
+    "expo-build-properties",
+    { "ios": { "extraPods": [{ "name": "SDWebImagePhotosPlugin" }] } }
+]
+```
+
+The app needs access to the photo library, which it has if it got the url from there. A photo library image is decoded at about the view's size, since photos are large and usually shown small; `onLoad` still reports the photo's own size. `FastImage.preload` of a `ph://` source loads the full-size photo (there's no view to size it for), which doesn't make a view's smaller copy load faster, so preloading photo library images usually isn't worth it. Without the plugin, a `ph://` source fails with `onError`, saying so. `assets-library://` urls aren't supported. On Android, photo pickers give `content://` urls, which load as they are.
+
 ---
 
 ### `source.headers?: object`
@@ -239,7 +258,7 @@ iOS only. Decodes a large image at about the size it's shown at, instead of at f
 
 Use it when you show images much larger than their views and can't get them at the right size, e.g. user uploads or other people's URLs in a list. If you control the images, serve them at the size they're shown instead (resized on your server or by an image CDN), which also saves bandwidth.
 
-Decoding a smaller copy can take a little longer, so use it where the memory matters. Needs SDWebImage 5.19.7 or later. On Android images are already decoded at about the view's size.
+Decoding a smaller copy can take a little longer, so use it where the memory matters. Needs SDWebImage 5.19.7 or later. Photo library images are always decoded this way. On Android images are already decoded at about the view's size.
 
 ---
 

package/ios/FastImage/FFFDownsampledImage.m

@@ -89,7 +89,12 @@ static CGSize FFFPixelSize(NSData* data) {
     // After a load that isn't downsampled (e.g. a preload), this class
     // wouldn't be used, and the box would be decoded as SDWebImage does (to
     // fill it, stretched). With its own url, a downsampled load only shares
-    // downloads with other downsampled ones.
+    // downloads with other downsampled ones. Not a photo library url, which
+    // isn't downloaded, and whose loader reads everything after ph:// as the
+    // photo's identifier.
+    if ([url.scheme isEqualToString: @"ph"]) {
+        return url;
+    }
     NSURLComponents* components = [NSURLComponents componentsWithURL: url resolvingAgainstBaseURL: NO];
     if (!components) {
         return url;

package/ios/FastImage/FFFastImageSource.h

@@ -53,9 +53,18 @@ typedef NS_ENUM(NSInteger, FFFCacheControl) {
 - (SDWebImageOptions)cacheOptions;
 
 // The loader for `cache: 'web'` images, whose HTTP cache is their own (see
-// webURLCache), or nil for SDWebImage's shared one.
+// webURLCache), for photo library images (ph://, see FFFPhotosLoader), or nil
+// for SDWebImage's shared one.
 - (id<SDImageLoader>)imageLoader;
 
+// Whether the source is a photo library image (ph://<localIdentifier>),
+// which is decoded at about the view's size.
+- (BOOL)isPhotoLibrary;
+
+// A photo library image's own size in pixels (for onLoad when it comes from
+// a cache, where the size it was decoded from isn't recorded), or zero.
+- (CGSize)photoPixelSize;
+
 // The HTTP cache of `cache: 'web'` images: their own rather than the app's
 // shared NSURLCache, so clearDiskCache can empty it without the app's other
 // responses. 50 MB, as on Android.

package/ios/FastImage/FFFastImageSource.m

@@ -5,9 +5,150 @@
 #import <SDWebImage/SDWebImageError.h>
 #import <SDWebImage/SDWebImageDownloaderOperation.h>
 #import <SDWebImage/NSData+ImageContentType.h>
+#import <objc/message.h>
 
 static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
 
+// The photo's own size in pixels, looked up by its identifier (the url after
+// ph://), or zero. Through the runtime, as the Photos framework is only there
+// when the app links it (with SDWebImagePhotosPlugin). Kept once looked up.
+static CGSize FFFLookUpPhotoPixelSize(NSURL *url)
+{
+    Class assetClass = NSClassFromString(@"PHAsset");
+    SEL fetch = NSSelectorFromString(@"fetchAssetsWithLocalIdentifiers:options:");
+    NSString *prefix = @"ph://";
+    NSString *string = url.absoluteString;
+    if (!assetClass || ![assetClass respondsToSelector:fetch] || ![string hasPrefix:prefix]) {
+        return CGSizeZero;
+    }
+    id (*fetchAssets)(id, SEL, NSArray *, id) = (void *)objc_msgSend;
+    id result = fetchAssets(assetClass, fetch, @[[string substringFromIndex:prefix.length]], nil);
+    id asset = [result respondsToSelector:@selector(firstObject)] ? [result firstObject] : nil;
+    if (!asset) {
+        return CGSizeZero;
+    }
+    return CGSizeMake([[asset valueForKey:@"pixelWidth"] doubleValue], [[asset valueForKey:@"pixelHeight"] doubleValue]);
+}
+
+static NSCache<NSString *, NSValue *> *FFFPhotoSizes(void)
+{
+    static NSCache *sizes;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        sizes = [NSCache new];
+    });
+    return sizes;
+}
+
+static CGSize FFFPhotoPixelSize(NSURL *url)
+{
+    NSString *key = url.absoluteString;
+    NSValue *known = key ? [FFFPhotoSizes() objectForKey:key] : nil;
+    if (known) {
+        return known.CGSizeValue;
+    }
+    CGSize size = FFFLookUpPhotoPixelSize(url);
+    if (key && size.width > 0 && size.height > 0) {
+        [FFFPhotoSizes() setObject:[NSValue valueWithCGSize:size] forKey:key];
+    }
+    return size;
+}
+
+// Loads photo library images (ph://<localIdentifier>) with
+// SDWebImagePhotosPlugin's loader when the app has it (the pod): FastImage
+// finds it at runtime, so it doesn't depend on it or on the Photos framework.
+// Its own instance, so the app's use of the plugin is left as it is. Without
+// the plugin, or for a source it can't load (assets-library://), the load
+// fails with `failure`.
+@interface FFFPhotosLoader : NSObject <SDImageLoader>
+@property (nonatomic, strong) id<SDImageLoader> plugin;
+@property (nonatomic, copy) NSString *failure;
+@end
+
+@implementation FFFPhotosLoader
+
++ (FFFPhotosLoader *)photosLoader
+{
+    static FFFPhotosLoader *loader;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        loader = [FFFPhotosLoader new];
+        Class pluginClass = NSClassFromString(@"SDImagePhotosLoader");
+        id<SDImageLoader> plugin = pluginClass ? [pluginClass new] : nil;
+        if ([plugin conformsToProtocol:@protocol(SDImageLoader)]) {
+            // One image per load, at full quality. By default the plugin
+            // first sends a quick low quality one, which a view would show
+            // (and fade in) before the one it asked for.
+            // PHImageRequestOptionsDeliveryModeHighQualityFormat. Skipped if
+            // a later version of the plugin renames these.
+            NSObject *requestOptions = [(NSObject *)plugin respondsToSelector:NSSelectorFromString(@"imageRequestOptions")]
+                ? [(NSObject *)plugin valueForKey:@"imageRequestOptions"]
+                : nil;
+            if ([requestOptions respondsToSelector:NSSelectorFromString(@"setDeliveryMode:")]) {
+                [requestOptions setValue:@1 forKey:@"deliveryMode"];
+            }
+            loader.plugin = plugin;
+        } else {
+            loader.failure = @"Photo library images (ph://) need SDWebImagePhotosPlugin: add pod 'SDWebImagePhotosPlugin' to the app's Podfile";
+        }
+    });
+    return loader;
+}
+
++ (FFFPhotosLoader *)assetsLibraryLoader
+{
+    static FFFPhotosLoader *loader;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        loader = [FFFPhotosLoader new];
+        loader.failure = @"assets-library:// urls aren't supported: use the photo's ph:// url (with SDWebImagePhotosPlugin)";
+    });
+    return loader;
+}
+
+- (BOOL)canRequestImageForURL:(NSURL *)url
+{
+    return YES;
+}
+
+- (id<SDWebImageOperation>)requestImageWithURL:(NSURL *)url
+                                        options:(SDWebImageOptions)options
+                                        context:(SDWebImageContext *)context
+                                       progress:(SDImageLoaderProgressBlock)progressBlock
+                                      completed:(SDImageLoaderCompletedBlock)completedBlock
+{
+    if (!self.plugin) {
+        if (completedBlock) {
+            NSError *error = [NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidURL userInfo:@{NSLocalizedDescriptionKey: self.failure}];
+            completedBlock(nil, nil, error, YES);
+        }
+        return nil;
+    }
+    return [self.plugin requestImageWithURL:url options:options context:context progress:progressBlock completed:^(UIImage *image, NSData *data, NSError *error, BOOL finished) {
+        if (!image || !completedBlock) {
+            if (completedBlock) {
+                completedBlock(image, data, error, finished);
+            }
+            return;
+        }
+        // Looks up the photo's own size for onLoad here, off the main thread
+        // (the image is decoded at about the view's size).
+        dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+            FFFPhotoPixelSize(url);
+            dispatch_async(dispatch_get_main_queue(), ^{
+                completedBlock(image, data, error, finished);
+            });
+        });
+    }];
+}
+
+- (BOOL)shouldBlockFailedURLWithURL:(NSURL *)url error:(NSError *)error
+{
+    return self.plugin ? [self.plugin shouldBlockFailedURLWithURL:url error:error] : NO;
+}
+
+@end
+
 // Downloads `cache: 'web'` images. The HTTP cache only stores a response whose
 // body is an image: a page sent instead (e.g. a captive portal's, with status
 // 200) would be served from there until it expired, and each load would fail.
@@ -75,8 +216,24 @@ static NSUInteger const FFFWebCacheSize = 50 * 1024 * 1024;
     return 0;
 }
 
+- (BOOL)isPhotoLibrary
+{
+    return [_url.scheme isEqualToString:@"ph"];
+}
+
+- (CGSize)photoPixelSize
+{
+    return [self isPhotoLibrary] ? FFFPhotoPixelSize(_url) : CGSizeZero;
+}
+
 - (id<SDImageLoader>)imageLoader
 {
+    if ([self isPhotoLibrary]) {
+        return [FFFPhotosLoader photosLoader];
+    }
+    if ([_url.scheme isEqualToString:@"assets-library"]) {
+        return [FFFPhotosLoader assetsLibraryLoader];
+    }
     if (_cacheControl != FFFCacheControlWeb) {
         return nil;
     }

package/ios/FastImage/FFFastImageView.m

@@ -570,7 +570,9 @@ NSString *FFFErrorMessage(NSError *error)
 
 - (void) sendOnLoad: (UIImage*)image {
     // The full image's size, also when it was decoded smaller.
-    CGSize size = [FFFDownsampledImage sourceSizeOfImage: image];
+    // A photo library image's own size (it's decoded at about the view's
+    // size), looked up when it loaded.
+    CGSize size = [_source isPhotoLibrary] ? [_source photoPixelSize] : [FFFDownsampledImage sourceSizeOfImage: image];
     if (CGSizeEqualToSize(size, CGSizeZero)) {
         size = image.size;
     }
@@ -646,11 +648,15 @@ NSString *FFFErrorMessage(NSError *error)
     }
 }
 
-// Whether images are decoded at about the view's size (downsample).
-// Not for `repeat`, which tiles the image at its own size, or SDWebImage
-// before 5.19.
+// Whether images are decoded at about the view's size (downsample, from
+// SDWebImage 5.19, and always for photo library images, which are large and
+// usually shown small: Photos makes them at the size asked for, on any
+// version). Not for `repeat`, which tiles the image at its own size.
 - (BOOL) downsamples {
-    return _downsample && _resizeMode != RCTResizeModeRepeat && [FFFDownsampledImage isSupported];
+    if (_resizeMode == RCTResizeModeRepeat) {
+        return NO;
+    }
+    return [_source isPhotoLibrary] || (_downsample && [FFFDownsampledImage isSupported]);
 }
 
 // Whether the view has been laid out with an area. One that's 0 wide or tall
@@ -823,6 +829,13 @@ NSString *FFFErrorMessage(NSError *error)
     }
     NSString* key = _source.cacheKeyFilter ? _source.cacheKey : _source.url.absoluteString;
     [FFFDownsampledImage addToContext: context forKey: key box: box cover: self.decodedCover];
+    if ([_source isPhotoLibrary]) {
+        // Photos makes the photo at the size asked for, with no file
+        // downloaded: SDWebImage would keep this smaller copy on disk as the
+        // photo's original, and a larger view would get it from there.
+        context[SDWebImageContextOriginalStoreCacheType] = @(SDImageCacheTypeNone);
+        context[SDWebImageContextOriginalQueryCacheType] = @(SDImageCacheTypeNone);
+    }
     if (!_source.memoryCache) {
         // The smaller copy is only kept in memory, so it isn't kept (the
         // downloaded file is still on disk).

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-fast-image",
-    "version": "8.23.0",
+    "version": "8.24.0",
     "description": "🚩 FastImage, performant React Native image component.",
     "keywords": [
         "cache",