【iOS】SDWebImage解析

1
[imageView sd_setImageWithURL:imageUrl placeholderImage:nil];//第一个参数是图片的URL第二个参数是占位图片加载失败时显示

1
[button sd_setImageWithURL:imageUrl forState:UIControlStateNormal placeholderImage:nil];//第一个参数是图片的URL，第二个参数是按钮状态，第三个参数是占位图片，加载失败时显示

1
- (nullable id<SDWebImageOperation>)sd_internalSetImageWithURL:(nullable NSURL *)url
2
                                              placeholderImage:(nullable UIImage *)placeholder
3
                                                       options:(SDWebImageOptions)options
4
                                                       context:(nullable SDWebImageContext *)context
5
                                                 setImageBlock:(nullable SDSetImageBlock)setImageBlock
6
                                                      progress:(nullable SDImageLoaderProgressBlock)progressBlock
7
                                                     completed:(nullable SDInternalCompletionBlock)completedBlock {
8

9
    // Very common mistake is to send the URL using NSString object instead of NSURL. For some strange reason, Xcode won't
10
    // throw any warning for this type mismatch. Here we failsafe this error by allowing URLs to be passed as NSString.
11
    //  if url is NSString and shouldUseWeakMemoryCache is true, [cacheKeyForURL:context] will crash. just for a  global protect.
12
    if ([url isKindOfClass:NSString.class]) {
13
        url = [NSURL URLWithString:(NSString *)url];
14
    }
15
    // Prevents app crashing on argument type error like sending NSNull instead of NSURL
16
    if (![url isKindOfClass:NSURL.class]) {
17
        url = nil;
18
    }
19

20
    if (context) {
21
        // copy to avoid mutable object
22
        context = [context copy];
23
    } else {
24
        context = [NSDictionary dictionary];
25
    }
26
    NSString *validOperationKey = context[SDWebImageContextSetImageOperationKey];
27
    if (!validOperationKey) {
28
        // pass through the operation key to downstream, which can used for tracing operation or image view class
29
        validOperationKey = NSStringFromClass([self class]);
30
        SDWebImageMutableContext *mutableContext = [context mutableCopy];
31
        mutableContext[SDWebImageContextSetImageOperationKey] = validOperationKey;
32
        context = [mutableContext copy];
33
    }
34
    self.sd_latestOperationKey = validOperationKey;
35
    if (!(SD_OPTIONS_CONTAINS(options, SDWebImageAvoidAutoCancelImage))) {
36
        // cancel previous loading for the same set-image operation key by default
37
        [self sd_cancelImageLoadOperationWithKey:validOperationKey];
38
    }
39
    SDWebImageLoadState *loadState = [self sd_imageLoadStateForKey:validOperationKey];
40
    if (!loadState) {
41
        loadState = [SDWebImageLoadState new];
42
    }
43
    loadState.url = url;
44
    [self sd_setImageLoadState:loadState forKey:validOperationKey];
45

46
    SDWebImageManager *manager = context[SDWebImageContextCustomManager];
47
    if (!manager) {
48
        manager = [SDWebImageManager sharedManager];
49
    } else {
50
        // remove this manager to avoid retain cycle (manger -> loader -> operation -> context -> manager)
51
        SDWebImageMutableContext *mutableContext = [context mutableCopy];
52
        mutableContext[SDWebImageContextCustomManager] = nil;
53
        context = [mutableContext copy];
54
    }
55
    SDCallbackQueue *queue = context[SDWebImageContextCallbackQueue];
56
    BOOL shouldUseWeakCache = NO;
57
    if ([manager.imageCache isKindOfClass:SDImageCache.class]) {
58
        shouldUseWeakCache = ((SDImageCache *)manager.imageCache).config.shouldUseWeakMemoryCache;
59
    }
60
    if (!(options & SDWebImageDelayPlaceholder)) {
61
        if (shouldUseWeakCache) {
62
            NSString *key = [manager cacheKeyForURL:url context:context];
63
            // call memory cache to trigger weak cache sync logic, ignore the return value and go on normal query
64
            // this unfortunately will cause twice memory cache query, but it's fast enough
65
            // in the future the weak cache feature may be re-design or removed
66
            [((SDImageCache *)manager.imageCache) imageFromMemoryCacheForKey:key];
67
        }
68
        [(queue ?: SDCallbackQueue.mainQueue) async:^{
69
            [self sd_setImage:placeholder imageData:nil basedOnClassOrViaCustomSetImageBlock:setImageBlock cacheType:SDImageCacheTypeNone imageURL:url];
70
        }];
71
    }
72

73
    id <SDWebImageOperation> operation = nil;
74

75
    if (url) {
76
        // reset the progress
77
        NSProgress *imageProgress = loadState.progress;
78
        if (imageProgress) {
79
            imageProgress.totalUnitCount = 0;
80
            imageProgress.completedUnitCount = 0;
81
        }
82

83
#if SD_UIKIT || SD_MAC
84
        // check and start image indicator
85
        [self sd_startImageIndicatorWithQueue:queue];
86
        id<SDWebImageIndicator> imageIndicator = self.sd_imageIndicator;
87
#endif
88

89
        SDImageLoaderProgressBlock combinedProgressBlock = ^(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL) {
90
            if (imageProgress) {
91
                imageProgress.totalUnitCount = expectedSize;
92
                imageProgress.completedUnitCount = receivedSize;
93
            }
94
#if SD_UIKIT || SD_MAC
95
            if ([imageIndicator respondsToSelector:@selector(updateIndicatorProgress:)]) {
96
                double progress = 0;
97
                if (expectedSize != 0) {
98
                    progress = (double)receivedSize / expectedSize;
99
                }
100
                progress = MAX(MIN(progress, 1), 0); // 0.0 - 1.0
101
                dispatch_async(dispatch_get_main_queue(), ^{
102
                    [imageIndicator updateIndicatorProgress:progress];
103
                });
104
            }
105
#endif
106
            if (progressBlock) {
107
                progressBlock(receivedSize, expectedSize, targetURL);
108
            }
109
        };
110
        @weakify(self);
111
        operation = [manager loadImageWithURL:url options:options context:context progress:combinedProgressBlock completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
112
            @strongify(self);
113
            if (!self) { return; }
114
            // if the progress not been updated, mark it to complete state
115
            if (imageProgress && finished && !error && imageProgress.totalUnitCount == 0 && imageProgress.completedUnitCount == 0) {
116
                imageProgress.totalUnitCount = SDWebImageProgressUnitCountUnknown;
117
                imageProgress.completedUnitCount = SDWebImageProgressUnitCountUnknown;
118
            }
119

120
#if SD_UIKIT || SD_MAC
121
            // check and stop image indicator
122
            if (finished) {
123
                [self sd_stopImageIndicatorWithQueue:queue];
124
            }
125
#endif
126

127
            BOOL shouldCallCompletedBlock = finished || (options & SDWebImageAvoidAutoSetImage);
128
            BOOL shouldNotSetImage = ((image && (options & SDWebImageAvoidAutoSetImage)) ||
129
                                      (!image && !(options & SDWebImageDelayPlaceholder)));
130
            SDWebImageNoParamsBlock callCompletedBlockClosure = ^{
131
                if (!self) { return; }
132
                if (!shouldNotSetImage) {
133
                    [self sd_setNeedsLayout];
134
                }
135
                if (completedBlock && shouldCallCompletedBlock) {
136
                    completedBlock(image, data, error, cacheType, finished, url);
137
                }
138
            };
139

140
            // case 1a: we got an image, but the SDWebImageAvoidAutoSetImage flag is set
141
            // OR
142
            // case 1b: we got no image and the SDWebImageDelayPlaceholder is not set
143
            if (shouldNotSetImage) {
144
                [(queue ?: SDCallbackQueue.mainQueue) async:callCompletedBlockClosure];
145
                return;
146
            }
147

148
            UIImage *targetImage = nil;
149
            NSData *targetData = nil;
150
            if (image) {
151
                // case 2a: we got an image and the SDWebImageAvoidAutoSetImage is not set
152
                targetImage = image;
153
                targetData = data;
154
            } else if (options & SDWebImageDelayPlaceholder) {
155
                // case 2b: we got no image and the SDWebImageDelayPlaceholder flag is set
156
                targetImage = placeholder;
157
                targetData = nil;
158
            }
159

160
#if SD_UIKIT || SD_MAC
161
            // check whether we should use the image transition
162
            SDWebImageTransition *transition = nil;
163
            BOOL shouldUseTransition = NO;
164
            if (options & SDWebImageForceTransition) {
165
                // Always
166
                shouldUseTransition = YES;
167
            } else if (cacheType == SDImageCacheTypeNone) {
168
                // From network
169
                shouldUseTransition = YES;
170
            } else {
171
                // From disk (and, user don't use sync query)
172
                if (cacheType == SDImageCacheTypeMemory) {
173
                    shouldUseTransition = NO;
174
                } else if (cacheType == SDImageCacheTypeDisk) {
175
                    if (options & SDWebImageQueryMemoryDataSync || options & SDWebImageQueryDiskDataSync) {
176
                        shouldUseTransition = NO;
177
                    } else {
178
                        shouldUseTransition = YES;
179
                    }
180
                } else {
181
                    // Not valid cache type, fallback
182
                    shouldUseTransition = NO;
183
                }
184
            }
185
            if (finished && shouldUseTransition) {
186
                transition = self.sd_imageTransition;
187
            }
188
#endif
189
            [(queue ?: SDCallbackQueue.mainQueue) async:^{
190
#if SD_UIKIT || SD_MAC
191
                [self sd_setImage:targetImage imageData:targetData options:options basedOnClassOrViaCustomSetImageBlock:setImageBlock transition:transition cacheType:cacheType imageURL:imageURL callback:callCompletedBlockClosure];
192
#else
193
                [self sd_setImage:targetImage imageData:targetData basedOnClassOrViaCustomSetImageBlock:setImageBlock cacheType:cacheType imageURL:imageURL];
194
                callCompletedBlockClosure();
195
#endif
196
            }];
197
        }];
198
        [self sd_setImageLoadOperation:operation forKey:validOperationKey];
199
    } else {
200
#if SD_UIKIT || SD_MAC
201
        [self sd_stopImageIndicatorWithQueue:queue];
202
#endif
203
        if (completedBlock) {
204
            [(queue ?: SDCallbackQueue.mainQueue) async:^{
205
                NSError *error = [NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidURL userInfo:@{NSLocalizedDescriptionKey : @"Image url is nil"}];
206
                completedBlock(nil, nil, error, SDImageCacheTypeNone, YES, url);
207
            }];
208
        }
209
    }
210

211
    return operation;
212
}