replace HUD

Podfile

@@ -11,6 +11,8 @@ target 'WXDownloadingKit' do
   pod 'MGSwipeTableCell'
   
   pod 'Reachability'
+  
+  pod 'MBProgressHUD'
 
 end
 
@@ -23,5 +25,7 @@ target 'WXDownloadingComponent' do
   pod 'MGSwipeTableCell'
   
   pod 'Reachability'
+  
+  pod 'MBProgressHUD'
 
 end

Podfile.lock

 PODS:
+  - MBProgressHUD (1.2.0)
   - MGSwipeTableCell (1.6.11)
   - Reachability (3.2)
   - YYKit (1.0.9):
@@ -6,21 +7,24 @@ PODS:
   - YYKit/no-arc (1.0.9)
 
 DEPENDENCIES:
+  - MBProgressHUD
   - MGSwipeTableCell
   - Reachability
   - YYKit
 
 SPEC REPOS:
   https://github.com/cocoapods/specs.git:
+    - MBProgressHUD
     - MGSwipeTableCell
     - Reachability
     - YYKit
 
 SPEC CHECKSUMS:
+  MBProgressHUD: 3ee5efcc380f6a79a7cc9b363dd669c5e1ae7406
   MGSwipeTableCell: b804e4e450dee439c42250be90bd50458bf67fce
   Reachability: 33e18b67625424e47b6cde6d202dce689ad7af96
   YYKit: 7cda43304a8dc3696c449041e2cb3107b4e236e7
 
-PODFILE CHECKSUM: c868a7d98611d357247477b920106b0538a46ea8
+PODFILE CHECKSUM: b9c7ad7c7b87e8ff4d6441b8c7486e604fc18b7b
 
 COCOAPODS: 1.7.2

Pods/MBProgressHUD/LICENSE

+Copyright © 2009-2020 Matej Bukovinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file

Pods/MBProgressHUD/MBProgressHUD.h

+//
+//  MBProgressHUD.h
+//  Version 1.2.0
+//  Created by Matej Bukovinski on 2.4.09.
+//
+
+// This code is distributed under the terms and conditions of the MIT license.
+
+// Copyright © 2009-2016 Matej Bukovinski
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <CoreGraphics/CoreGraphics.h>
+
+@class MBBackgroundView;
+@protocol MBProgressHUDDelegate;
+
+
+extern CGFloat const MBProgressMaxOffset;
+
+typedef NS_ENUM(NSInteger, MBProgressHUDMode) {
+    /// UIActivityIndicatorView.
+    MBProgressHUDModeIndeterminate,
+    /// A round, pie-chart like, progress view.
+    MBProgressHUDModeDeterminate,
+    /// Horizontal progress bar.
+    MBProgressHUDModeDeterminateHorizontalBar,
+    /// Ring-shaped progress view.
+    MBProgressHUDModeAnnularDeterminate,
+    /// Shows a custom view.
+    MBProgressHUDModeCustomView,
+    /// Shows only labels.
+    MBProgressHUDModeText
+};
+
+typedef NS_ENUM(NSInteger, MBProgressHUDAnimation) {
+    /// Opacity animation
+    MBProgressHUDAnimationFade,
+    /// Opacity + scale animation (zoom in when appearing zoom out when disappearing)
+    MBProgressHUDAnimationZoom,
+    /// Opacity + scale animation (zoom out style)
+    MBProgressHUDAnimationZoomOut,
+    /// Opacity + scale animation (zoom in style)
+    MBProgressHUDAnimationZoomIn
+};
+
+typedef NS_ENUM(NSInteger, MBProgressHUDBackgroundStyle) {
+    /// Solid color background
+    MBProgressHUDBackgroundStyleSolidColor,
+    /// UIVisualEffectView or UIToolbar.layer background view
+    MBProgressHUDBackgroundStyleBlur
+};
+
+typedef void (^MBProgressHUDCompletionBlock)(void);
+
+
+NS_ASSUME_NONNULL_BEGIN
+
+
+/**
+ * Displays a simple HUD window containing a progress indicator and two optional labels for short messages.
+ *
+ * This is a simple drop-in class for displaying a progress HUD view similar to Apple's private UIProgressHUD class.
+ * The MBProgressHUD window spans over the entire space given to it by the initWithFrame: constructor and catches all
+ * user input on this region, thereby preventing the user operations on components below the view.
+ *
+ * @note To still allow touches to pass through the HUD, you can set hud.userInteractionEnabled = NO.
+ * @attention MBProgressHUD is a UI class and should therefore only be accessed on the main thread.
+ */
+@interface MBProgressHUD : UIView
+
+/**
+ * Creates a new HUD, adds it to provided view and shows it. The counterpart to this method is hideHUDForView:animated:.
+ *
+ * @note This method sets removeFromSuperViewOnHide. The HUD will automatically be removed from the view hierarchy when hidden.
+ *
+ * @param view The view that the HUD will be added to
+ * @param animated If set to YES the HUD will appear using the current animationType. If set to NO the HUD will not use
+ * animations while appearing.
+ * @return A reference to the created HUD.
+ *
+ * @see hideHUDForView:animated:
+ * @see animationType
+ */
++ (instancetype)showHUDAddedTo:(UIView *)view animated:(BOOL)animated;
+
+/// @name Showing and hiding
+
+/**
+ * Finds the top-most HUD subview that hasn't finished and hides it. The counterpart to this method is showHUDAddedTo:animated:.
+ *
+ * @note This method sets removeFromSuperViewOnHide. The HUD will automatically be removed from the view hierarchy when hidden.
+ *
+ * @param view The view that is going to be searched for a HUD subview.
+ * @param animated If set to YES the HUD will disappear using the current animationType. If set to NO the HUD will not use
+ * animations while disappearing.
+ * @return YES if a HUD was found and removed, NO otherwise.
+ *
+ * @see showHUDAddedTo:animated:
+ * @see animationType
+ */
++ (BOOL)hideHUDForView:(UIView *)view animated:(BOOL)animated;
+
+/**
+ * Finds the top-most HUD subview that hasn't finished and returns it.
+ *
+ * @param view The view that is going to be searched.
+ * @return A reference to the last HUD subview discovered.
+ */
++ (nullable MBProgressHUD *)HUDForView:(UIView *)view NS_SWIFT_NAME(forView(_:));
+
+/**
+ * A convenience constructor that initializes the HUD with the view's bounds. Calls the designated constructor with
+ * view.bounds as the parameter.
+ *
+ * @param view The view instance that will provide the bounds for the HUD. Should be the same instance as
+ * the HUD's superview (i.e., the view that the HUD will be added to).
+ */
+- (instancetype)initWithView:(UIView *)view;
+
+/**
+ * Displays the HUD.
+ *
+ * @note You need to make sure that the main thread completes its run loop soon after this method call so that
+ * the user interface can be updated. Call this method when your task is already set up to be executed in a new thread
+ * (e.g., when using something like NSOperation or making an asynchronous call like NSURLRequest).
+ *
+ * @param animated If set to YES the HUD will appear using the current animationType. If set to NO the HUD will not use
+ * animations while appearing.
+ *
+ * @see animationType
+ */
+- (void)showAnimated:(BOOL)animated;
+
+/**
+ * Hides the HUD. This still calls the hudWasHidden: delegate. This is the counterpart of the show: method. Use it to
+ * hide the HUD when your task completes.
+ *
+ * @param animated If set to YES the HUD will disappear using the current animationType. If set to NO the HUD will not use
+ * animations while disappearing.
+ *
+ * @see animationType
+ */
+- (void)hideAnimated:(BOOL)animated;
+
+/**
+ * Hides the HUD after a delay. This still calls the hudWasHidden: delegate. This is the counterpart of the show: method. Use it to
+ * hide the HUD when your task completes.
+ *
+ * @param animated If set to YES the HUD will disappear using the current animationType. If set to NO the HUD will not use
+ * animations while disappearing.
+ * @param delay Delay in seconds until the HUD is hidden.
+ *
+ * @see animationType
+ */
+- (void)hideAnimated:(BOOL)animated afterDelay:(NSTimeInterval)delay;
+
+/**
+ * The HUD delegate object. Receives HUD state notifications.
+ */
+@property (weak, nonatomic) id<MBProgressHUDDelegate> delegate;
+
+/**
+ * Called after the HUD is hidden.
+ */
+@property (copy, nullable) MBProgressHUDCompletionBlock completionBlock;
+
+/**
+ * Grace period is the time (in seconds) that the invoked method may be run without
+ * showing the HUD. If the task finishes before the grace time runs out, the HUD will
+ * not be shown at all.
+ * This may be used to prevent HUD display for very short tasks.
+ * Defaults to 0 (no grace time).
+ * @note The graceTime needs to be set before the hud is shown. You thus can't use `showHUDAddedTo:animated:`,
+ * but instead need to alloc / init the HUD, configure the grace time and than show it manually.
+ */
+@property (assign, nonatomic) NSTimeInterval graceTime;
+
+/**
+ * The minimum time (in seconds) that the HUD is shown.
+ * This avoids the problem of the HUD being shown and than instantly hidden.
+ * Defaults to 0 (no minimum show time).
+ */
+@property (assign, nonatomic) NSTimeInterval minShowTime;
+
+/**
+ * Removes the HUD from its parent view when hidden.
+ * Defaults to NO.
+ */
+@property (assign, nonatomic) BOOL removeFromSuperViewOnHide;
+
+/// @name Appearance
+
+/**
+ * MBProgressHUD operation mode. The default is MBProgressHUDModeIndeterminate.
+ */
+@property (assign, nonatomic) MBProgressHUDMode mode;
+
+/**
+ * A color that gets forwarded to all labels and supported indicators. Also sets the tintColor
+ * for custom views on iOS 7+. Set to nil to manage color individually.
+ * Defaults to semi-translucent black on iOS 7 and later and white on earlier iOS versions.
+ */
+@property (strong, nonatomic, nullable) UIColor *contentColor UI_APPEARANCE_SELECTOR;
+
+/**
+ * The animation type that should be used when the HUD is shown and hidden.
+ */
+@property (assign, nonatomic) MBProgressHUDAnimation animationType UI_APPEARANCE_SELECTOR;
+
+/**
+ * The bezel offset relative to the center of the view. You can use MBProgressMaxOffset
+ * and -MBProgressMaxOffset to move the HUD all the way to the screen edge in each direction.
+ * E.g., CGPointMake(0.f, MBProgressMaxOffset) would position the HUD centered on the bottom edge.
+ */
+@property (assign, nonatomic) CGPoint offset UI_APPEARANCE_SELECTOR;
+
+/**
+ * The amount of space between the HUD edge and the HUD elements (labels, indicators or custom views).
+ * This also represents the minimum bezel distance to the edge of the HUD view.
+ * Defaults to 20.f
+ */
+@property (assign, nonatomic) CGFloat margin UI_APPEARANCE_SELECTOR;
+
+/**
+ * The minimum size of the HUD bezel. Defaults to CGSizeZero (no minimum size).
+ */
+@property (assign, nonatomic) CGSize minSize UI_APPEARANCE_SELECTOR;
+
+/**
+ * Force the HUD dimensions to be equal if possible.
+ */
+@property (assign, nonatomic, getter = isSquare) BOOL square UI_APPEARANCE_SELECTOR;
+
+/**
+ * When enabled, the bezel center gets slightly affected by the device accelerometer data.
+ * Defaults to NO.
+ *
+ * @note This can cause main thread checker assertions on certain devices. https://github.com/jdg/MBProgressHUD/issues/552
+ */
+@property (assign, nonatomic, getter=areDefaultMotionEffectsEnabled) BOOL defaultMotionEffectsEnabled UI_APPEARANCE_SELECTOR;
+
+/// @name Progress
+
+/**
+ * The progress of the progress indicator, from 0.0 to 1.0. Defaults to 0.0.
+ */
+@property (assign, nonatomic) float progress;
+
+/// @name ProgressObject
+
+/**
+ * The NSProgress object feeding the progress information to the progress indicator.
+ */
+@property (strong, nonatomic, nullable) NSProgress *progressObject;
+
+/// @name Views
+
+/**
+ * The view containing the labels and indicator (or customView).
+ */
+@property (strong, nonatomic, readonly) MBBackgroundView *bezelView;
+
+/**
+ * View covering the entire HUD area, placed behind bezelView.
+ */
+@property (strong, nonatomic, readonly) MBBackgroundView *backgroundView;
+
+/**
+ * The UIView (e.g., a UIImageView) to be shown when the HUD is in MBProgressHUDModeCustomView.
+ * The view should implement intrinsicContentSize for proper sizing. For best results use approximately 37 by 37 pixels.
+ */
+@property (strong, nonatomic, nullable) UIView *customView;
+
+/**
+ * A label that holds an optional short message to be displayed below the activity indicator. The HUD is automatically resized to fit
+ * the entire text.
+ */
+@property (strong, nonatomic, readonly) UILabel *label;
+
+/**
+ * A label that holds an optional details message displayed below the labelText message. The details text can span multiple lines.
+ */
+@property (strong, nonatomic, readonly) UILabel *detailsLabel;
+
+/**
+ * A button that is placed below the labels. Visible only if a target / action is added and a title is assigned..
+ */
+@property (strong, nonatomic, readonly) UIButton *button;
+
+@end
+
+
+@protocol MBProgressHUDDelegate <NSObject>
+
+@optional
+
+/**
+ * Called after the HUD was fully hidden from the screen.
+ */
+- (void)hudWasHidden:(MBProgressHUD *)hud;
+
+@end
+
+
+/**
+ * A progress view for showing definite progress by filling up a circle (pie chart).
+ */
+@interface MBRoundProgressView : UIView
+
+/**
+ * Progress (0.0 to 1.0)
+ */
+@property (nonatomic, assign) float progress;
+
+/**
+ * Indicator progress color.
+ * Defaults to white [UIColor whiteColor].
+ */
+@property (nonatomic, strong) UIColor *progressTintColor;
+
+/**
+ * Indicator background (non-progress) color.
+ * Only applicable on iOS versions older than iOS 7.
+ * Defaults to translucent white (alpha 0.1).
+ */
+@property (nonatomic, strong) UIColor *backgroundTintColor;
+
+/*
+ * Display mode - NO = round or YES = annular. Defaults to round.
+ */
+@property (nonatomic, assign, getter = isAnnular) BOOL annular;
+
+@end
+
+
+/**
+ * A flat bar progress view.
+ */
+@interface MBBarProgressView : UIView
+
+/**
+ * Progress (0.0 to 1.0)
+ */
+@property (nonatomic, assign) float progress;
+
+/**
+ * Bar border line color.
+ * Defaults to white [UIColor whiteColor].
+ */
+@property (nonatomic, strong) UIColor *lineColor;
+
+/**
+ * Bar background color.
+ * Defaults to clear [UIColor clearColor];
+ */
+@property (nonatomic, strong) UIColor *progressRemainingColor;
+
+/**
+ * Bar progress color.
+ * Defaults to white [UIColor whiteColor].
+ */
+@property (nonatomic, strong) UIColor *progressColor;
+
+@end
+
+
+@interface MBBackgroundView : UIView
+
+/**
+ * The background style.
+ * Defaults to MBProgressHUDBackgroundStyleBlur.
+ */
+@property (nonatomic) MBProgressHUDBackgroundStyle style;
+
+/**
+ * The blur effect style, when using MBProgressHUDBackgroundStyleBlur.
+ * Defaults to UIBlurEffectStyleLight.
+ */
+@property (nonatomic) UIBlurEffectStyle blurEffectStyle;
+
+/**
+ * The background color or the blur tint color.
+ *
+ * Defaults to nil on iOS 13 and later and
+ * `[UIColor colorWithWhite:0.8f alpha:0.6f]`
+ * on older systems.
+ */
+@property (nonatomic, strong, nullable) UIColor *color;
+
+@end
+
+NS_ASSUME_NONNULL_END

Pods/MBProgressHUD/MBProgressHUD.m

+//
+// MBProgressHUD.m
+// Version 1.2.0
+// Created by Matej Bukovinski on 2.4.09.
+//
+
+#import "MBProgressHUD.h"
+#import <tgmath.h>
+
+#define MBMainThreadAssert() NSAssert([NSThread isMainThread], @"MBProgressHUD needs to be accessed on the main thread.");
+
+CGFloat const MBProgressMaxOffset = 1000000.f;
+
+static const CGFloat MBDefaultPadding = 4.f;
+static const CGFloat MBDefaultLabelFontSize = 16.f;
+static const CGFloat MBDefaultDetailsLabelFontSize = 12.f;
+
+
+@interface MBProgressHUD ()
+
+@property (nonatomic, assign) BOOL useAnimation;
+@property (nonatomic, assign, getter=hasFinished) BOOL finished;
+@property (nonatomic, strong) UIView *indicator;
+@property (nonatomic, strong) NSDate *showStarted;
+@property (nonatomic, strong) NSArray *paddingConstraints;
+@property (nonatomic, strong) NSArray *bezelConstraints;
+@property (nonatomic, strong) UIView *topSpacer;
+@property (nonatomic, strong) UIView *bottomSpacer;
+@property (nonatomic, strong) UIMotionEffectGroup *bezelMotionEffects;
+@property (nonatomic, weak) NSTimer *graceTimer;
+@property (nonatomic, weak) NSTimer *minShowTimer;
+@property (nonatomic, weak) NSTimer *hideDelayTimer;
+@property (nonatomic, weak) CADisplayLink *progressObjectDisplayLink;
+
+@end
+
+
+@interface MBProgressHUDRoundedButton : UIButton
+@end
+
+
+@implementation MBProgressHUD
+
+#pragma mark - Class methods
+
++ (instancetype)showHUDAddedTo:(UIView *)view animated:(BOOL)animated {
+    MBProgressHUD *hud = [[self alloc] initWithView:view];
+    hud.removeFromSuperViewOnHide = YES;
+    [view addSubview:hud];
+    [hud showAnimated:animated];
+    return hud;
+}
+
++ (BOOL)hideHUDForView:(UIView *)view animated:(BOOL)animated {
+    MBProgressHUD *hud = [self HUDForView:view];
+    if (hud != nil) {
+        hud.removeFromSuperViewOnHide = YES;
+        [hud hideAnimated:animated];
+        return YES;
+    }
+    return NO;
+}
+
++ (MBProgressHUD *)HUDForView:(UIView *)view {
+    NSEnumerator *subviewsEnum = [view.subviews reverseObjectEnumerator];
+    for (UIView *subview in subviewsEnum) {
+        if ([subview isKindOfClass:self]) {
+            MBProgressHUD *hud = (MBProgressHUD *)subview;
+            if (hud.hasFinished == NO) {
+                return hud;
+            }
+        }
+    }
+    return nil;
+}
+
+#pragma mark - Lifecycle
+
+- (void)commonInit {
+    // Set default values for properties
+    _animationType = MBProgressHUDAnimationFade;
+    _mode = MBProgressHUDModeIndeterminate;
+    _margin = 20.0f;
+    _defaultMotionEffectsEnabled = NO;
+
+    if (@available(iOS 13.0, tvOS 13, *)) {
+       _contentColor = [[UIColor labelColor] colorWithAlphaComponent:0.7f];
+    } else {
+        _contentColor = [UIColor colorWithWhite:0.f alpha:0.7f];
+    }
+
+    // Transparent background
+    self.opaque = NO;
+    self.backgroundColor = [UIColor clearColor];
+    // Make it invisible for now
+    self.alpha = 0.0f;
+    self.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    self.layer.allowsGroupOpacity = NO;
+
+    [self setupViews];
+    [self updateIndicators];
+    [self registerForNotifications];
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    if ((self = [super initWithFrame:frame])) {
+        [self commonInit];
+    }
+    return self;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+    if ((self = [super initWithCoder:aDecoder])) {
+        [self commonInit];
+    }
+    return self;
+}
+
+- (id)initWithView:(UIView *)view {
+    NSAssert(view, @"View must not be nil.");
+    return [self initWithFrame:view.bounds];
+}
+
+- (void)dealloc {
+    [self unregisterFromNotifications];
+}
+
+#pragma mark - Show & hide
+
+- (void)showAnimated:(BOOL)animated {
+    MBMainThreadAssert();
+    [self.minShowTimer invalidate];
+    self.useAnimation = animated;
+    self.finished = NO;
+    // If the grace time is set, postpone the HUD display
+    if (self.graceTime > 0.0) {
+        NSTimer *timer = [NSTimer timerWithTimeInterval:self.graceTime target:self selector:@selector(handleGraceTimer:) userInfo:nil repeats:NO];
+        [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
+        self.graceTimer = timer;
+    }
+    // ... otherwise show the HUD immediately
+    else {
+        [self showUsingAnimation:self.useAnimation];
+    }
+}
+
+- (void)hideAnimated:(BOOL)animated {
+    MBMainThreadAssert();
+    [self.graceTimer invalidate];
+    self.useAnimation = animated;
+    self.finished = YES;
+    // If the minShow time is set, calculate how long the HUD was shown,
+    // and postpone the hiding operation if necessary
+    if (self.minShowTime > 0.0 && self.showStarted) {
+        NSTimeInterval interv = [[NSDate date] timeIntervalSinceDate:self.showStarted];
+        if (interv < self.minShowTime) {
+            NSTimer *timer = [NSTimer timerWithTimeInterval:(self.minShowTime - interv) target:self selector:@selector(handleMinShowTimer:) userInfo:nil repeats:NO];
+            [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
+            self.minShowTimer = timer;
+            return;
+        }
+    }
+    // ... otherwise hide the HUD immediately
+    [self hideUsingAnimation:self.useAnimation];
+}
+
+- (void)hideAnimated:(BOOL)animated afterDelay:(NSTimeInterval)delay {
+    // Cancel any scheduled hideAnimated:afterDelay: calls
+    [self.hideDelayTimer invalidate];
+
+    NSTimer *timer = [NSTimer timerWithTimeInterval:delay target:self selector:@selector(handleHideTimer:) userInfo:@(animated) repeats:NO];
+    [[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];
+    self.hideDelayTimer = timer;
+}
+
+#pragma mark - Timer callbacks
+
+- (void)handleGraceTimer:(NSTimer *)theTimer {
+    // Show the HUD only if the task is still running
+    if (!self.hasFinished) {
+        [self showUsingAnimation:self.useAnimation];
+    }
+}
+
+- (void)handleMinShowTimer:(NSTimer *)theTimer {
+    [self hideUsingAnimation:self.useAnimation];
+}
+
+- (void)handleHideTimer:(NSTimer *)timer {
+    [self hideAnimated:[timer.userInfo boolValue]];
+}
+
+#pragma mark - View Hierrarchy
+
+- (void)didMoveToSuperview {
+    [self updateForCurrentOrientationAnimated:NO];
+}
+
+#pragma mark - Internal show & hide operations
+
+- (void)showUsingAnimation:(BOOL)animated {
+    // Cancel any previous animations
+    [self.bezelView.layer removeAllAnimations];
+    [self.backgroundView.layer removeAllAnimations];
+
+    // Cancel any scheduled hideAnimated:afterDelay: calls
+    [self.hideDelayTimer invalidate];
+
+    self.showStarted = [NSDate date];
+    self.alpha = 1.f;
+
+    // Needed in case we hide and re-show with the same NSProgress object attached.
+    [self setNSProgressDisplayLinkEnabled:YES];
+
+    // Set up motion effects only at this point to avoid needlessly
+    // creating the effect if it was disabled after initialization.
+    [self updateBezelMotionEffects];
+
+    if (animated) {
+        [self animateIn:YES withType:self.animationType completion:NULL];
+    } else {
+        self.bezelView.alpha = 1.f;
+        self.backgroundView.alpha = 1.f;
+    }
+}
+
+- (void)hideUsingAnimation:(BOOL)animated {
+    // Cancel any scheduled hideAnimated:afterDelay: calls.
+    // This needs to happen here instead of in done,
+    // to avoid races if another hideAnimated:afterDelay:
+    // call comes in while the HUD is animating out.
+    [self.hideDelayTimer invalidate];
+
+    if (animated && self.showStarted) {
+        self.showStarted = nil;
+        [self animateIn:NO withType:self.animationType completion:^(BOOL finished) {
+            [self done];
+        }];
+    } else {
+        self.showStarted = nil;
+        self.bezelView.alpha = 0.f;
+        self.backgroundView.alpha = 1.f;
+        [self done];
+    }
+}
+
+- (void)animateIn:(BOOL)animatingIn withType:(MBProgressHUDAnimation)type completion:(void(^)(BOOL finished))completion {
+    // Automatically determine the correct zoom animation type
+    if (type == MBProgressHUDAnimationZoom) {
+        type = animatingIn ? MBProgressHUDAnimationZoomIn : MBProgressHUDAnimationZoomOut;
+    }
+
+    CGAffineTransform small = CGAffineTransformMakeScale(0.5f, 0.5f);
+    CGAffineTransform large = CGAffineTransformMakeScale(1.5f, 1.5f);
+
+    // Set starting state
+    UIView *bezelView = self.bezelView;
+    if (animatingIn && bezelView.alpha == 0.f && type == MBProgressHUDAnimationZoomIn) {
+        bezelView.transform = small;
+    } else if (animatingIn && bezelView.alpha == 0.f && type == MBProgressHUDAnimationZoomOut) {
+        bezelView.transform = large;
+    }
+
+    // Perform animations
+    dispatch_block_t animations = ^{
+        if (animatingIn) {
+            bezelView.transform = CGAffineTransformIdentity;
+        } else if (!animatingIn && type == MBProgressHUDAnimationZoomIn) {
+            bezelView.transform = large;
+        } else if (!animatingIn && type == MBProgressHUDAnimationZoomOut) {
+            bezelView.transform = small;
+        }
+        CGFloat alpha = animatingIn ? 1.f : 0.f;
+        bezelView.alpha = alpha;
+        self.backgroundView.alpha = alpha;
+    };
+    [UIView animateWithDuration:0.3 delay:0. usingSpringWithDamping:1.f initialSpringVelocity:0.f options:UIViewAnimationOptionBeginFromCurrentState animations:animations completion:completion];
+}
+
+- (void)done {
+    [self setNSProgressDisplayLinkEnabled:NO];
+
+    if (self.hasFinished) {
+        self.alpha = 0.0f;
+        if (self.removeFromSuperViewOnHide) {
+            [self removeFromSuperview];
+        }
+    }
+    MBProgressHUDCompletionBlock completionBlock = self.completionBlock;
+    if (completionBlock) {
+        completionBlock();
+    }
+    id<MBProgressHUDDelegate> delegate = self.delegate;
+    if ([delegate respondsToSelector:@selector(hudWasHidden:)]) {
+        [delegate performSelector:@selector(hudWasHidden:) withObject:self];
+    }
+}
+
+#pragma mark - UI
+
+- (void)setupViews {
+    UIColor *defaultColor = self.contentColor;
+
+    MBBackgroundView *backgroundView = [[MBBackgroundView alloc] initWithFrame:self.bounds];
+    backgroundView.style = MBProgressHUDBackgroundStyleSolidColor;
+    backgroundView.backgroundColor = [UIColor clearColor];
+    backgroundView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    backgroundView.alpha = 0.f;
+    [self addSubview:backgroundView];
+    _backgroundView = backgroundView;
+
+    MBBackgroundView *bezelView = [MBBackgroundView new];
+    bezelView.translatesAutoresizingMaskIntoConstraints = NO;
+    bezelView.layer.cornerRadius = 5.f;
+    bezelView.alpha = 0.f;
+    [self addSubview:bezelView];
+    _bezelView = bezelView;
+
+    UILabel *label = [UILabel new];
+    label.adjustsFontSizeToFitWidth = NO;
+    label.textAlignment = NSTextAlignmentCenter;
+    label.textColor = defaultColor;
+    label.font = [UIFont boldSystemFontOfSize:MBDefaultLabelFontSize];
+    label.opaque = NO;
+    label.backgroundColor = [UIColor clearColor];
+    _label = label;
+
+    UILabel *detailsLabel = [UILabel new];
+    detailsLabel.adjustsFontSizeToFitWidth = NO;
+    detailsLabel.textAlignment = NSTextAlignmentCenter;
+    detailsLabel.textColor = defaultColor;
+    detailsLabel.numberOfLines = 0;
+    detailsLabel.font = [UIFont boldSystemFontOfSize:MBDefaultDetailsLabelFontSize];
+    detailsLabel.opaque = NO;
+    detailsLabel.backgroundColor = [UIColor clearColor];
+    _detailsLabel = detailsLabel;
+
+    UIButton *button = [MBProgressHUDRoundedButton buttonWithType:UIButtonTypeCustom];
+    button.titleLabel.textAlignment = NSTextAlignmentCenter;
+    button.titleLabel.font = [UIFont boldSystemFontOfSize:MBDefaultDetailsLabelFontSize];
+    [button setTitleColor:defaultColor forState:UIControlStateNormal];
+    _button = button;
+
+    for (UIView *view in @[label, detailsLabel, button]) {
+        view.translatesAutoresizingMaskIntoConstraints = NO;
+        [view setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisHorizontal];
+        [view setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisVertical];
+        [bezelView addSubview:view];
+    }
+
+    UIView *topSpacer = [UIView new];
+    topSpacer.translatesAutoresizingMaskIntoConstraints = NO;
+    topSpacer.hidden = YES;
+    [bezelView addSubview:topSpacer];
+    _topSpacer = topSpacer;
+
+    UIView *bottomSpacer = [UIView new];
+    bottomSpacer.translatesAutoresizingMaskIntoConstraints = NO;
+    bottomSpacer.hidden = YES;
+    [bezelView addSubview:bottomSpacer];
+    _bottomSpacer = bottomSpacer;
+}
+
+- (void)updateIndicators {
+    UIView *indicator = self.indicator;
+    BOOL isActivityIndicator = [indicator isKindOfClass:[UIActivityIndicatorView class]];
+    BOOL isRoundIndicator = [indicator isKindOfClass:[MBRoundProgressView class]];
+
+    MBProgressHUDMode mode = self.mode;
+    if (mode == MBProgressHUDModeIndeterminate) {
+        if (!isActivityIndicator) {
+            // Update to indeterminate indicator
+            UIActivityIndicatorView *activityIndicator;
+            [indicator removeFromSuperview];
+#if !TARGET_OS_MACCATALYST
+            if (@available(iOS 13.0, tvOS 13.0, *)) {
+#endif
+                activityIndicator = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleLarge];
+                activityIndicator.color = [UIColor whiteColor];
+#if !TARGET_OS_MACCATALYST
+            } else {
+               activityIndicator = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];
+            }
+#endif
+            [activityIndicator startAnimating];
+            indicator = activityIndicator;
+            [self.bezelView addSubview:indicator];
+        }
+    }
+    else if (mode == MBProgressHUDModeDeterminateHorizontalBar) {
+        // Update to bar determinate indicator
+        [indicator removeFromSuperview];
+        indicator = [[MBBarProgressView alloc] init];
+        [self.bezelView addSubview:indicator];
+    }
+    else if (mode == MBProgressHUDModeDeterminate || mode == MBProgressHUDModeAnnularDeterminate) {
+        if (!isRoundIndicator) {
+            // Update to determinante indicator
+            [indicator removeFromSuperview];
+            indicator = [[MBRoundProgressView alloc] init];
+            [self.bezelView addSubview:indicator];
+        }
+        if (mode == MBProgressHUDModeAnnularDeterminate) {
+            [(MBRoundProgressView *)indicator setAnnular:YES];
+        }
+    }
+    else if (mode == MBProgressHUDModeCustomView && self.customView != indicator) {
+        // Update custom view indicator
+        [indicator removeFromSuperview];
+        indicator = self.customView;
+        [self.bezelView addSubview:indicator];
+    }
+    else if (mode == MBProgressHUDModeText) {
+        [indicator removeFromSuperview];
+        indicator = nil;
+    }
+    indicator.translatesAutoresizingMaskIntoConstraints = NO;
+    self.indicator = indicator;
+
+    if ([indicator respondsToSelector:@selector(setProgress:)]) {
+        [(id)indicator setValue:@(self.progress) forKey:@"progress"];
+    }
+
+    [indicator setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisHorizontal];
+    [indicator setContentCompressionResistancePriority:998.f forAxis:UILayoutConstraintAxisVertical];
+
+    [self updateViewsForColor:self.contentColor];
+    [self setNeedsUpdateConstraints];
+}
+
+- (void)updateViewsForColor:(UIColor *)color {
+    if (!color) return;
+
+    self.label.textColor = color;
+    self.detailsLabel.textColor = color;
+    [self.button setTitleColor:color forState:UIControlStateNormal];
+
+    // UIAppearance settings are prioritized. If they are preset the set color is ignored.
+
+    UIView *indicator = self.indicator;
+    if ([indicator isKindOfClass:[UIActivityIndicatorView class]]) {
+        UIActivityIndicatorView *appearance = nil;
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 90000
+        appearance = [UIActivityIndicatorView appearanceWhenContainedIn:[MBProgressHUD class], nil];
+#else
+        // For iOS 9+
+        appearance = [UIActivityIndicatorView appearanceWhenContainedInInstancesOfClasses:@[[MBProgressHUD class]]];
+#endif
+
+        if (appearance.color == nil) {
+            ((UIActivityIndicatorView *)indicator).color = color;
+        }
+    } else if ([indicator isKindOfClass:[MBRoundProgressView class]]) {
+        MBRoundProgressView *appearance = nil;
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 90000
+        appearance = [MBRoundProgressView appearanceWhenContainedIn:[MBProgressHUD class], nil];
+#else
+        appearance = [MBRoundProgressView appearanceWhenContainedInInstancesOfClasses:@[[MBProgressHUD class]]];
+#endif
+        if (appearance.progressTintColor == nil) {
+            ((MBRoundProgressView *)indicator).progressTintColor = color;
+        }
+        if (appearance.backgroundTintColor == nil) {
+            ((MBRoundProgressView *)indicator).backgroundTintColor = [color colorWithAlphaComponent:0.1];
+        }
+    } else if ([indicator isKindOfClass:[MBBarProgressView class]]) {
+        MBBarProgressView *appearance = nil;
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 90000
+        appearance = [MBBarProgressView appearanceWhenContainedIn:[MBProgressHUD class], nil];
+#else
+        appearance = [MBBarProgressView appearanceWhenContainedInInstancesOfClasses:@[[MBProgressHUD class]]];
+#endif
+        if (appearance.progressColor == nil) {
+            ((MBBarProgressView *)indicator).progressColor = color;
+        }
+        if (appearance.lineColor == nil) {
+            ((MBBarProgressView *)indicator).lineColor = color;
+        }
+    } else {
+        [indicator setTintColor:color];
+    }
+}
+
+- (void)updateBezelMotionEffects {
+    MBBackgroundView *bezelView = self.bezelView;
+    UIMotionEffectGroup *bezelMotionEffects = self.bezelMotionEffects;
+
+    if (self.defaultMotionEffectsEnabled && !bezelMotionEffects) {
+        CGFloat effectOffset = 10.f;
+        UIInterpolatingMotionEffect *effectX = [[UIInterpolatingMotionEffect alloc] initWithKeyPath:@"center.x" type:UIInterpolatingMotionEffectTypeTiltAlongHorizontalAxis];
+        effectX.maximumRelativeValue = @(effectOffset);
+        effectX.minimumRelativeValue = @(-effectOffset);
+
+        UIInterpolatingMotionEffect *effectY = [[UIInterpolatingMotionEffect alloc] initWithKeyPath:@"center.y" type:UIInterpolatingMotionEffectTypeTiltAlongVerticalAxis];
+        effectY.maximumRelativeValue = @(effectOffset);
+        effectY.minimumRelativeValue = @(-effectOffset);
+
+        UIMotionEffectGroup *group = [[UIMotionEffectGroup alloc] init];
+        group.motionEffects = @[effectX, effectY];
+
+        self.bezelMotionEffects = group;
+        [bezelView addMotionEffect:group];
+    } else if (bezelMotionEffects) {
+        self.bezelMotionEffects = nil;
+        [bezelView removeMotionEffect:bezelMotionEffects];
+    }
+}
+
+#pragma mark - Layout
+
+- (void)updateConstraints {
+    UIView *bezel = self.bezelView;
+    UIView *topSpacer = self.topSpacer;
+    UIView *bottomSpacer = self.bottomSpacer;
+    CGFloat margin = self.margin;
+    NSMutableArray *bezelConstraints = [NSMutableArray array];
+    NSDictionary *metrics = @{@"margin": @(margin)};
+
+    NSMutableArray *subviews = [NSMutableArray arrayWithObjects:self.topSpacer, self.label, self.detailsLabel, self.button, self.bottomSpacer, nil];
+    if (self.indicator) [subviews insertObject:self.indicator atIndex:1];
+
+    // Remove existing constraints
+    [self removeConstraints:self.constraints];
+    [topSpacer removeConstraints:topSpacer.constraints];
+    [bottomSpacer removeConstraints:bottomSpacer.constraints];
+    if (self.bezelConstraints) {
+        [bezel removeConstraints:self.bezelConstraints];
+        self.bezelConstraints = nil;
+    }
+
+    // Center bezel in container (self), applying the offset if set
+    CGPoint offset = self.offset;
+    NSMutableArray *centeringConstraints = [NSMutableArray array];
+    [centeringConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeCenterX relatedBy:NSLayoutRelationEqual toItem:self attribute:NSLayoutAttributeCenterX multiplier:1.f constant:offset.x]];
+    [centeringConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeCenterY relatedBy:NSLayoutRelationEqual toItem:self attribute:NSLayoutAttributeCenterY multiplier:1.f constant:offset.y]];
+    [self applyPriority:998.f toConstraints:centeringConstraints];
+    [self addConstraints:centeringConstraints];
+
+    // Ensure minimum side margin is kept
+    NSMutableArray *sideConstraints = [NSMutableArray array];
+    [sideConstraints addObjectsFromArray:[NSLayoutConstraint constraintsWithVisualFormat:@"|-(>=margin)-[bezel]-(>=margin)-|" options:0 metrics:metrics views:NSDictionaryOfVariableBindings(bezel)]];
+    [sideConstraints addObjectsFromArray:[NSLayoutConstraint constraintsWithVisualFormat:@"V:|-(>=margin)-[bezel]-(>=margin)-|" options:0 metrics:metrics views:NSDictionaryOfVariableBindings(bezel)]];
+    [self applyPriority:999.f toConstraints:sideConstraints];
+    [self addConstraints:sideConstraints];
+
+    // Minimum bezel size, if set
+    CGSize minimumSize = self.minSize;
+    if (!CGSizeEqualToSize(minimumSize, CGSizeZero)) {
+        NSMutableArray *minSizeConstraints = [NSMutableArray array];
+        [minSizeConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeWidth relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:minimumSize.width]];
+        [minSizeConstraints addObject:[NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:minimumSize.height]];
+        [self applyPriority:997.f toConstraints:minSizeConstraints];
+        [bezelConstraints addObjectsFromArray:minSizeConstraints];
+    }
+
+    // Square aspect ratio, if set
+    if (self.square) {
+        NSLayoutConstraint *square = [NSLayoutConstraint constraintWithItem:bezel attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeWidth multiplier:1.f constant:0];
+        square.priority = 997.f;
+        [bezelConstraints addObject:square];
+    }
+
+    // Top and bottom spacing
+    [topSpacer addConstraint:[NSLayoutConstraint constraintWithItem:topSpacer attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:margin]];
+    [bottomSpacer addConstraint:[NSLayoutConstraint constraintWithItem:bottomSpacer attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationGreaterThanOrEqual toItem:nil attribute:NSLayoutAttributeNotAnAttribute multiplier:1.f constant:margin]];
+    // Top and bottom spaces should be equal
+    [bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:topSpacer attribute:NSLayoutAttributeHeight relatedBy:NSLayoutRelationEqual toItem:bottomSpacer attribute:NSLayoutAttributeHeight multiplier:1.f constant:0.f]];
+
+    // Layout subviews in bezel
+    NSMutableArray *paddingConstraints = [NSMutableArray new];
+    [subviews enumerateObjectsUsingBlock:^(UIView *view, NSUInteger idx, BOOL *stop) {
+        // Center in bezel
+        [bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeCenterX relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeCenterX multiplier:1.f constant:0.f]];
+        // Ensure the minimum edge margin is kept
+        [bezelConstraints addObjectsFromArray:[NSLayoutConstraint constraintsWithVisualFormat:@"|-(>=margin)-[view]-(>=margin)-|" options:0 metrics:metrics views:NSDictionaryOfVariableBindings(view)]];
+        // Element spacing
+        if (idx == 0) {
+            // First, ensure spacing to bezel edge
+            [bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeTop relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeTop multiplier:1.f constant:0.f]];
+        } else if (idx == subviews.count - 1) {
+            // Last, ensure spacing to bezel edge
+            [bezelConstraints addObject:[NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeBottom relatedBy:NSLayoutRelationEqual toItem:bezel attribute:NSLayoutAttributeBottom multiplier:1.f constant:0.f]];
+        }
+        if (idx > 0) {
+            // Has previous
+            NSLayoutConstraint *padding = [NSLayoutConstraint constraintWithItem:view attribute:NSLayoutAttributeTop relatedBy:NSLayoutRelationEqual toItem:subviews[idx - 1] attribute:NSLayoutAttributeBottom multiplier:1.f constant:0.f];
+            [bezelConstraints addObject:padding];
+            [paddingConstraints addObject:padding];
+        }
+    }];
+
+    [bezel addConstraints:bezelConstraints];
+    self.bezelConstraints = bezelConstraints;
+
+    self.paddingConstraints = [paddingConstraints copy];
+    [self updatePaddingConstraints];
+
+    [super updateConstraints];
+}
+
+- (void)layoutSubviews {
+    // There is no need to update constraints if they are going to
+    // be recreated in [super layoutSubviews] due to needsUpdateConstraints being set.
+    // This also avoids an issue on iOS 8, where updatePaddingConstraints
+    // would trigger a zombie object access.
+    if (!self.needsUpdateConstraints) {
+        [self updatePaddingConstraints];
+    }
+    [super layoutSubviews];
+}
+
+- (void)updatePaddingConstraints {
+    // Set padding dynamically, depending on whether the view is visible or not
+    __block BOOL hasVisibleAncestors = NO;
+    [self.paddingConstraints enumerateObjectsUsingBlock:^(NSLayoutConstraint *padding, NSUInteger idx, BOOL *stop) {
+        UIView *firstView = (UIView *)padding.firstItem;
+        UIView *secondView = (UIView *)padding.secondItem;
+        BOOL firstVisible = !firstView.hidden && !CGSizeEqualToSize(firstView.intrinsicContentSize, CGSizeZero);
+        BOOL secondVisible = !secondView.hidden && !CGSizeEqualToSize(secondView.intrinsicContentSize, CGSizeZero);
+        // Set if both views are visible or if there's a visible view on top that doesn't have padding
+        // added relative to the current view yet
+        padding.constant = (firstVisible && (secondVisible || hasVisibleAncestors)) ? MBDefaultPadding : 0.f;
+        hasVisibleAncestors |= secondVisible;
+    }];
+}
+
+- (void)applyPriority:(UILayoutPriority)priority toConstraints:(NSArray *)constraints {
+    for (NSLayoutConstraint *constraint in constraints) {
+        constraint.priority = priority;
+    }
+}
+
+#pragma mark - Properties
+
+- (void)setMode:(MBProgressHUDMode)mode {
+    if (mode != _mode) {
+        _mode = mode;
+        [self updateIndicators];
+    }
+}
+
+- (void)setCustomView:(UIView *)customView {
+    if (customView != _customView) {
+        _customView = customView;
+        if (self.mode == MBProgressHUDModeCustomView) {
+            [self updateIndicators];
+        }
+    }
+}
+
+- (void)setOffset:(CGPoint)offset {
+    if (!CGPointEqualToPoint(offset, _offset)) {
+        _offset = offset;
+        [self setNeedsUpdateConstraints];
+    }
+}
+
+- (void)setMargin:(CGFloat)margin {
+    if (margin != _margin) {
+        _margin = margin;
+        [self setNeedsUpdateConstraints];
+    }
+}
+
+- (void)setMinSize:(CGSize)minSize {
+    if (!CGSizeEqualToSize(minSize, _minSize)) {
+        _minSize = minSize;
+        [self setNeedsUpdateConstraints];
+    }
+}
+
+- (void)setSquare:(BOOL)square {
+    if (square != _square) {
+        _square = square;
+        [self setNeedsUpdateConstraints];
+    }
+}
+
+- (void)setProgressObjectDisplayLink:(CADisplayLink *)progressObjectDisplayLink {
+    if (progressObjectDisplayLink != _progressObjectDisplayLink) {
+        [_progressObjectDisplayLink invalidate];
+
+        _progressObjectDisplayLink = progressObjectDisplayLink;
+
+        [_progressObjectDisplayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSDefaultRunLoopMode];
+    }
+}
+
+- (void)setProgressObject:(NSProgress *)progressObject {
+    if (progressObject != _progressObject) {
+        _progressObject = progressObject;
+        [self setNSProgressDisplayLinkEnabled:YES];
+    }
+}
+
+- (void)setProgress:(float)progress {
+    if (progress != _progress) {
+        _progress = progress;
+        UIView *indicator = self.indicator;
+        if ([indicator respondsToSelector:@selector(setProgress:)]) {
+            [(id)indicator setValue:@(self.progress) forKey:@"progress"];
+        }
+    }
+}
+
+- (void)setContentColor:(UIColor *)contentColor {
+    if (contentColor != _contentColor && ![contentColor isEqual:_contentColor]) {
+        _contentColor = contentColor;
+        [self updateViewsForColor:contentColor];
+    }
+}
+
+- (void)setDefaultMotionEffectsEnabled:(BOOL)defaultMotionEffectsEnabled {
+    if (defaultMotionEffectsEnabled != _defaultMotionEffectsEnabled) {
+        _defaultMotionEffectsEnabled = defaultMotionEffectsEnabled;
+        [self updateBezelMotionEffects];
+    }
+}
+
+#pragma mark - NSProgress
+
+- (void)setNSProgressDisplayLinkEnabled:(BOOL)enabled {
+    // We're using CADisplayLink, because NSProgress can change very quickly and observing it may starve the main thread,
+    // so we're refreshing the progress only every frame draw
+    if (enabled && self.progressObject) {
+        // Only create if not already active.
+        if (!self.progressObjectDisplayLink) {
+            self.progressObjectDisplayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(updateProgressFromProgressObject)];
+        }
+    } else {
+        self.progressObjectDisplayLink = nil;
+    }
+}
+
+- (void)updateProgressFromProgressObject {
+    self.progress = self.progressObject.fractionCompleted;
+}
+
+#pragma mark - Notifications
+
+- (void)registerForNotifications {
+#if !TARGET_OS_TV && !TARGET_OS_MACCATALYST
+    NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+
+    [nc addObserver:self selector:@selector(statusBarOrientationDidChange:)
+               name:UIApplicationDidChangeStatusBarOrientationNotification object:nil];
+#endif
+}
+
+- (void)unregisterFromNotifications {
+#if !TARGET_OS_TV && !TARGET_OS_MACCATALYST
+    NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
+    [nc removeObserver:self name:UIApplicationDidChangeStatusBarOrientationNotification object:nil];
+#endif
+}
+
+#if !TARGET_OS_TV && !TARGET_OS_MACCATALYST
+- (void)statusBarOrientationDidChange:(NSNotification *)notification {
+    UIView *superview = self.superview;
+    if (!superview) {
+        return;
+    } else {
+        [self updateForCurrentOrientationAnimated:YES];
+    }
+}
+#endif
+
+- (void)updateForCurrentOrientationAnimated:(BOOL)animated {
+    // Stay in sync with the superview in any case
+    if (self.superview) {
+        self.frame = self.superview.bounds;
+    }
+
+    // Not needed on iOS 8+, compile out when the deployment target allows,
+    // to avoid sharedApplication problems on extension targets
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < 80000
+    // Only needed pre iOS 8 when added to a window
+    BOOL iOS8OrLater = kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_8_0;
+    if (iOS8OrLater || ![self.superview isKindOfClass:[UIWindow class]]) return;
+
+    // Make extension friendly. Will not get called on extensions (iOS 8+) due to the above check.
+    // This just ensures we don't get a warning about extension-unsafe API.
+    Class UIApplicationClass = NSClassFromString(@"UIApplication");
+    if (!UIApplicationClass || ![UIApplicationClass respondsToSelector:@selector(sharedApplication)]) return;
+
+    UIApplication *application = [UIApplication performSelector:@selector(sharedApplication)];
+    UIInterfaceOrientation orientation = application.statusBarOrientation;
+    CGFloat radians = 0;
+
+    if (UIInterfaceOrientationIsLandscape(orientation)) {
+        radians = orientation == UIInterfaceOrientationLandscapeLeft ? -(CGFloat)M_PI_2 : (CGFloat)M_PI_2;
+        // Window coordinates differ!
+        self.bounds = CGRectMake(0, 0, self.bounds.size.height, self.bounds.size.width);
+    } else {
+        radians = orientation == UIInterfaceOrientationPortraitUpsideDown ? (CGFloat)M_PI : 0.f;
+    }
+
+    if (animated) {
+        [UIView animateWithDuration:0.3 animations:^{
+            self.transform = CGAffineTransformMakeRotation(radians);
+        }];
+    } else {
+        self.transform = CGAffineTransformMakeRotation(radians);
+    }
+#endif
+}
+
+@end
+
+
+@implementation MBRoundProgressView
+
+#pragma mark - Lifecycle
+
+- (id)init {
+    return [self initWithFrame:CGRectMake(0.f, 0.f, 37.f, 37.f)];
+}
+
+- (id)initWithFrame:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    if (self) {
+        self.backgroundColor = [UIColor clearColor];
+        self.opaque = NO;
+        _progress = 0.f;
+        _annular = NO;
+        _progressTintColor = [[UIColor alloc] initWithWhite:1.f alpha:1.f];
+        _backgroundTintColor = [[UIColor alloc] initWithWhite:1.f alpha:.1f];
+    }
+    return self;
+}
+
+#pragma mark - Layout
+
+- (CGSize)intrinsicContentSize {
+    return CGSizeMake(37.f, 37.f);
+}
+
+#pragma mark - Properties
+
+- (void)setProgress:(float)progress {
+    if (progress != _progress) {
+        _progress = progress;
+        [self setNeedsDisplay];
+    }
+}
+
+- (void)setProgressTintColor:(UIColor *)progressTintColor {
+    NSAssert(progressTintColor, @"The color should not be nil.");
+    if (progressTintColor != _progressTintColor && ![progressTintColor isEqual:_progressTintColor]) {
+        _progressTintColor = progressTintColor;
+        [self setNeedsDisplay];
+    }
+}
+
+- (void)setBackgroundTintColor:(UIColor *)backgroundTintColor {
+    NSAssert(backgroundTintColor, @"The color should not be nil.");
+    if (backgroundTintColor != _backgroundTintColor && ![backgroundTintColor isEqual:_backgroundTintColor]) {
+        _backgroundTintColor = backgroundTintColor;
+        [self setNeedsDisplay];
+    }
+}
+
+#pragma mark - Drawing
+
+- (void)drawRect:(CGRect)rect {
+    CGContextRef context = UIGraphicsGetCurrentContext();
+
+    if (_annular) {
+        // Draw background
+        CGFloat lineWidth = 2.f;
+        UIBezierPath *processBackgroundPath = [UIBezierPath bezierPath];
+        processBackgroundPath.lineWidth = lineWidth;
+        processBackgroundPath.lineCapStyle = kCGLineCapButt;
+        CGPoint center = CGPointMake(CGRectGetMidX(self.bounds), CGRectGetMidY(self.bounds));
+        CGFloat radius = (self.bounds.size.width - lineWidth)/2;
+        CGFloat startAngle = - ((float)M_PI / 2); // 90 degrees
+        CGFloat endAngle = (2 * (float)M_PI) + startAngle;
+        [processBackgroundPath addArcWithCenter:center radius:radius startAngle:startAngle endAngle:endAngle clockwise:YES];
+        [_backgroundTintColor set];
+        [processBackgroundPath stroke];
+        // Draw progress
+        UIBezierPath *processPath = [UIBezierPath bezierPath];
+        processPath.lineCapStyle = kCGLineCapSquare;
+        processPath.lineWidth = lineWidth;
+        endAngle = (self.progress * 2 * (float)M_PI) + startAngle;
+        [processPath addArcWithCenter:center radius:radius startAngle:startAngle endAngle:endAngle clockwise:YES];
+        [_progressTintColor set];
+        [processPath stroke];
+    } else {
+        // Draw background
+        CGFloat lineWidth = 2.f;
+        CGRect allRect = self.bounds;
+        CGRect circleRect = CGRectInset(allRect, lineWidth/2.f, lineWidth/2.f);
+        CGPoint center = CGPointMake(CGRectGetMidX(self.bounds), CGRectGetMidY(self.bounds));
+        [_progressTintColor setStroke];
+        [_backgroundTintColor setFill];
+        CGContextSetLineWidth(context, lineWidth);
+        CGContextStrokeEllipseInRect(context, circleRect);
+        // 90 degrees
+        CGFloat startAngle = - ((float)M_PI / 2.f);
+        // Draw progress
+        UIBezierPath *processPath = [UIBezierPath bezierPath];
+        processPath.lineCapStyle = kCGLineCapButt;
+        processPath.lineWidth = lineWidth * 2.f;
+        CGFloat radius = (CGRectGetWidth(self.bounds) / 2.f) - (processPath.lineWidth / 2.f);
+        CGFloat endAngle = (self.progress * 2.f * (float)M_PI) + startAngle;
+        [processPath addArcWithCenter:center radius:radius startAngle:startAngle endAngle:endAngle clockwise:YES];
+        // Ensure that we don't get color overlapping when _progressTintColor alpha < 1.f.
+        CGContextSetBlendMode(context, kCGBlendModeCopy);
+        [_progressTintColor set];
+        [processPath stroke];
+    }
+}
+
+@end
+
+
+@implementation MBBarProgressView
+
+#pragma mark - Lifecycle
+
+- (id)init {
+    return [self initWithFrame:CGRectMake(.0f, .0f, 120.0f, 20.0f)];
+}
+
+- (id)initWithFrame:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    if (self) {
+        _progress = 0.f;
+        _lineColor = [UIColor whiteColor];
+        _progressColor = [UIColor whiteColor];
+        _progressRemainingColor = [UIColor clearColor];
+        self.backgroundColor = [UIColor clearColor];
+        self.opaque = NO;
+    }
+    return self;
+}
+
+#pragma mark - Layout
+
+- (CGSize)intrinsicContentSize {
+    return CGSizeMake(120.f, 10.f);
+}
+
+#pragma mark - Properties
+
+- (void)setProgress:(float)progress {
+    if (progress != _progress) {
+        _progress = progress;
+        [self setNeedsDisplay];
+    }
+}
+
+- (void)setProgressColor:(UIColor *)progressColor {
+    NSAssert(progressColor, @"The color should not be nil.");
+    if (progressColor != _progressColor && ![progressColor isEqual:_progressColor]) {
+        _progressColor = progressColor;
+        [self setNeedsDisplay];
+    }
+}
+
+- (void)setProgressRemainingColor:(UIColor *)progressRemainingColor {
+    NSAssert(progressRemainingColor, @"The color should not be nil.");
+    if (progressRemainingColor != _progressRemainingColor && ![progressRemainingColor isEqual:_progressRemainingColor]) {
+        _progressRemainingColor = progressRemainingColor;
+        [self setNeedsDisplay];
+    }
+}
+
+#pragma mark - Drawing
+
+- (void)drawRect:(CGRect)rect {
+    CGContextRef context = UIGraphicsGetCurrentContext();
+
+    CGContextSetLineWidth(context, 2);
+    CGContextSetStrokeColorWithColor(context,[_lineColor CGColor]);
+    CGContextSetFillColorWithColor(context, [_progressRemainingColor CGColor]);
+
+    // Draw background and Border
+    CGFloat radius = (rect.size.height / 2) - 2;
+    CGContextMoveToPoint(context, 2, rect.size.height/2);
+    CGContextAddArcToPoint(context, 2, 2, radius + 2, 2, radius);
+    CGContextAddArcToPoint(context, rect.size.width - 2, 2, rect.size.width - 2, rect.size.height / 2, radius);
+    CGContextAddArcToPoint(context, rect.size.width - 2, rect.size.height - 2, rect.size.width - radius - 2, rect.size.height - 2, radius);
+    CGContextAddArcToPoint(context, 2, rect.size.height - 2, 2, rect.size.height/2, radius);
+    CGContextDrawPath(context, kCGPathFillStroke);
+
+    CGContextSetFillColorWithColor(context, [_progressColor CGColor]);
+    radius = radius - 2;
+    CGFloat amount = self.progress * rect.size.width;
+
+    // Progress in the middle area
+    if (amount >= radius + 4 && amount <= (rect.size.width - radius - 4)) {
+        CGContextMoveToPoint(context, 4, rect.size.height/2);
+        CGContextAddArcToPoint(context, 4, 4, radius + 4, 4, radius);
+        CGContextAddLineToPoint(context, amount, 4);
+        CGContextAddLineToPoint(context, amount, radius + 4);
+
+        CGContextMoveToPoint(context, 4, rect.size.height/2);
+        CGContextAddArcToPoint(context, 4, rect.size.height - 4, radius + 4, rect.size.height - 4, radius);
+        CGContextAddLineToPoint(context, amount, rect.size.height - 4);
+        CGContextAddLineToPoint(context, amount, radius + 4);
+
+        CGContextFillPath(context);
+    }
+
+    // Progress in the right arc
+    else if (amount > radius + 4) {
+        CGFloat x = amount - (rect.size.width - radius - 4);
+
+        CGContextMoveToPoint(context, 4, rect.size.height/2);
+        CGContextAddArcToPoint(context, 4, 4, radius + 4, 4, radius);
+        CGContextAddLineToPoint(context, rect.size.width - radius - 4, 4);
+        CGFloat angle = -acos(x/radius);
+        if (isnan(angle)) angle = 0;
+        CGContextAddArc(context, rect.size.width - radius - 4, rect.size.height/2, radius, M_PI, angle, 0);
+        CGContextAddLineToPoint(context, amount, rect.size.height/2);
+
+        CGContextMoveToPoint(context, 4, rect.size.height/2);
+        CGContextAddArcToPoint(context, 4, rect.size.height - 4, radius + 4, rect.size.height - 4, radius);
+        CGContextAddLineToPoint(context, rect.size.width - radius - 4, rect.size.height - 4);
+        angle = acos(x/radius);
+        if (isnan(angle)) angle = 0;
+        CGContextAddArc(context, rect.size.width - radius - 4, rect.size.height/2, radius, -M_PI, angle, 1);
+        CGContextAddLineToPoint(context, amount, rect.size.height/2);
+
+        CGContextFillPath(context);
+    }
+
+    // Progress is in the left arc
+    else if (amount < radius + 4 && amount > 0) {
+        CGContextMoveToPoint(context, 4, rect.size.height/2);
+        CGContextAddArcToPoint(context, 4, 4, radius + 4, 4, radius);
+        CGContextAddLineToPoint(context, radius + 4, rect.size.height/2);
+
+        CGContextMoveToPoint(context, 4, rect.size.height/2);
+        CGContextAddArcToPoint(context, 4, rect.size.height - 4, radius + 4, rect.size.height - 4, radius);
+        CGContextAddLineToPoint(context, radius + 4, rect.size.height/2);
+
+        CGContextFillPath(context);
+    }
+}
+
+@end
+
+
+@interface MBBackgroundView ()
+
+@property UIVisualEffectView *effectView;
+
+@end
+
+
+@implementation MBBackgroundView
+
+#pragma mark - Lifecycle
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    if ((self = [super initWithFrame:frame])) {
+        _style = MBProgressHUDBackgroundStyleBlur;
+        if (@available(iOS 13.0, *)) {
+            #if TARGET_OS_TV
+            _blurEffectStyle = UIBlurEffectStyleRegular;
+            #else
+            _blurEffectStyle = UIBlurEffectStyleSystemThickMaterial;
+            #endif
+            // Leaving the color unassigned yields best results.
+        } else {
+            _blurEffectStyle = UIBlurEffectStyleLight;
+            _color = [UIColor colorWithWhite:0.8f alpha:0.6f];
+        }
+
+        self.clipsToBounds = YES;
+
+        [self updateForBackgroundStyle];
+    }
+    return self;
+}
+
+#pragma mark - Layout
+
+- (CGSize)intrinsicContentSize {
+    // Smallest size possible. Content pushes against this.
+    return CGSizeZero;
+}
+
+#pragma mark - Appearance
+
+- (void)setStyle:(MBProgressHUDBackgroundStyle)style {
+    if (_style != style) {
+        _style = style;
+        [self updateForBackgroundStyle];
+    }
+}
+
+- (void)setColor:(UIColor *)color {
+    NSAssert(color, @"The color should not be nil.");
+    if (color != _color && ![color isEqual:_color]) {
+        _color = color;
+        [self updateViewsForColor:color];
+    }
+}
+
+- (void)setBlurEffectStyle:(UIBlurEffectStyle)blurEffectStyle {
+    if (_blurEffectStyle == blurEffectStyle) {
+        return;
+    }
+
+    _blurEffectStyle = blurEffectStyle;
+
+    [self updateForBackgroundStyle];
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark - Views
+
+- (void)updateForBackgroundStyle {
+    [self.effectView removeFromSuperview];
+    self.effectView = nil;
+
+    MBProgressHUDBackgroundStyle style = self.style;
+    if (style == MBProgressHUDBackgroundStyleBlur) {
+        UIBlurEffect *effect =  [UIBlurEffect effectWithStyle:self.blurEffectStyle];
+        UIVisualEffectView *effectView = [[UIVisualEffectView alloc] initWithEffect:effect];
+        [self insertSubview:effectView atIndex:0];
+        effectView.frame = self.bounds;
+        effectView.autoresizingMask = UIViewAutoresizingFlexibleHeight | UIViewAutoresizingFlexibleWidth;
+        self.backgroundColor = self.color;
+        self.layer.allowsGroupOpacity = NO;
+        self.effectView = effectView;
+    } else {
+        self.backgroundColor = self.color;
+    }
+}
+
+- (void)updateViewsForColor:(UIColor *)color {
+    if (self.style == MBProgressHUDBackgroundStyleBlur) {
+        self.backgroundColor = self.color;
+    } else {
+        self.backgroundColor = self.color;
+    }
+}
+
+@end
+
+
+@implementation MBProgressHUDRoundedButton
+
+#pragma mark - Lifecycle
+
+- (instancetype)initWithFrame:(CGRect)frame {
+    self = [super initWithFrame:frame];
+    if (self) {
+        CALayer *layer = self.layer;
+        layer.borderWidth = 1.f;
+    }
+    return self;
+}
+
+#pragma mark - Layout
+
+- (void)layoutSubviews {
+    [super layoutSubviews];
+    // Fully rounded corners
+    CGFloat height = CGRectGetHeight(self.bounds);
+    self.layer.cornerRadius = ceil(height / 2.f);
+}
+
+- (CGSize)intrinsicContentSize {
+    // Only show if we have associated control events and a title
+    if ((self.allControlEvents == 0) || ([self titleForState:UIControlStateNormal].length == 0))
+		return CGSizeZero;
+    CGSize size = [super intrinsicContentSize];
+    // Add some side padding
+    size.width += 20.f;
+    return size;
+}
+
+#pragma mark - Color
+
+- (void)setTitleColor:(UIColor *)color forState:(UIControlState)state {
+    [super setTitleColor:color forState:state];
+    // Update related colors
+    [self setHighlighted:self.highlighted];
+    self.layer.borderColor = color.CGColor;
+}
+
+- (void)setHighlighted:(BOOL)highlighted {
+    [super setHighlighted:highlighted];
+    UIColor *baseColor = [self titleColorForState:UIControlStateSelected];
+    self.backgroundColor = highlighted ? [baseColor colorWithAlphaComponent:0.1f] : [UIColor clearColor];
+}
+
+@end

Pods/MBProgressHUD/README.mdown

+# MBProgressHUD
+
+[![Build Status](https://travis-ci.org/matej/MBProgressHUD.svg?branch=master)](https://travis-ci.org/matej/MBProgressHUD) [![codecov.io](https://codecov.io/github/matej/MBProgressHUD/coverage.svg?branch=master)](https://codecov.io/github/matej/MBProgressHUD?branch=master)
+ [![SwiftPM compatible](https://img.shields.io/badge/SwiftPM-compatible-brightgreen.svg)](https://github.com/apple/swift-package-manager) [![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage#adding-frameworks-to-an-application) [![Accio supported](https://img.shields.io/badge/Accio-supported-0A7CF5.svg?style=flat)](https://github.com/JamitLabs/Accio) [![CocoaPods compatible](https://img.shields.io/cocoapods/v/MBProgressHUD.svg?style=flat)](https://cocoapods.org/pods/MBProgressHUD) [![License: MIT](https://img.shields.io/cocoapods/l/MBProgressHUD.svg?style=flat)](http://opensource.org/licenses/MIT)
+
+`MBProgressHUD` is an iOS drop-in class that displays a translucent HUD with an indicator and/or labels while work is being done in a background thread. The HUD is meant as a replacement for the undocumented, private `UIKit` `UIProgressHUD` with some additional features.
+
+[![](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/1-small.png)](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/1.png)
+[![](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/2-small.png)](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/2.png)
+[![](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/3-small.png)](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/3.png)
+[![](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/4-small.png)](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/4.png)
+[![](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/5-small.png)](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/5.png)
+[![](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/6-small.png)](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/6.png)
+[![](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/7-small.png)](https://raw.githubusercontent.com/wiki/matej/MBProgressHUD/Screenshots/7.png)
+
+**NOTE:** The class has recently undergone a major rewrite. The old version is available in the [legacy](https://github.com/jdg/MBProgressHUD/tree/legacy) branch, should you need it.
+
+## Requirements
+
+`MBProgressHUD` works on iOS 9.0+. It depends on the following Apple frameworks, which should already be included with most Xcode templates:
+
+* Foundation.framework
+* UIKit.framework
+* CoreGraphics.framework
+
+You will need the latest developer tools in order to build `MBProgressHUD`. Old Xcode versions might work, but compatibility will not be explicitly maintained.
+
+## Adding MBProgressHUD to your project
+
+### CocoaPods
+
+[CocoaPods](http://cocoapods.org) is the recommended way to add MBProgressHUD to your project.
+
+1. Add a pod entry for MBProgressHUD to your Podfile `pod 'MBProgressHUD', '~> 1.2.0'`
+2. Install the pod(s) by running `pod install`.
+3. Include MBProgressHUD wherever you need it with `#import "MBProgressHUD.h"`.
+
+### Carthage
+
+1. Add MBProgressHUD to your Cartfile. e.g., `github "jdg/MBProgressHUD" ~> 1.2.0`
+2. Run `carthage update`
+3. Follow the rest of the [standard Carthage installation instructions](https://github.com/Carthage/Carthage#adding-frameworks-to-an-application) to add MBProgressHUD to your project.
+
+### SwiftPM / Accio
+
+1. Add the following to your `Package.swift`:
+	```swift
+	.package(url: "https://github.com/jdg/MBProgressHUD.git", .upToNextMajor(from: "1.2.0")),
+	```
+2. Next, add `MBProgressHUD` to your App targets dependencies like so:
+	```swift
+	.target(name: "App", dependencies: ["MBProgressHUD"]),
+	```
+3. Then open your project in Xcode 11+ (SwiftPM) or run `accio update` (Accio).
+
+### Source files
+
+Alternatively you can directly add the `MBProgressHUD.h` and `MBProgressHUD.m` source files to your project.
+
+1. Download the [latest code version](https://github.com/matej/MBProgressHUD/archive/master.zip) or add the repository as a git submodule to your git-tracked project.
+2. Open your project in Xcode, then drag and drop `MBProgressHUD.h` and `MBProgressHUD.m` onto your project (use the "Product Navigator view"). Make sure to select Copy items when asked if you extracted the code archive outside of your project.
+3. Include MBProgressHUD wherever you need it with `#import "MBProgressHUD.h"`.
+
+### Static library
+
+You can also add MBProgressHUD as a static library to your project or workspace.
+
+1. Download the [latest code version](https://github.com/matej/MBProgressHUD/downloads) or add the repository as a git submodule to your git-tracked project.
+2. Open your project in Xcode, then drag and drop `MBProgressHUD.xcodeproj` onto your project or workspace (use the "Product Navigator view").
+3. Select your target and go to the Build phases tab. In the Link Binary With Libraries section select the add button. On the sheet find and add `libMBProgressHUD.a`. You might also need to add `MBProgressHUD` to the Target Dependencies list.
+4. Include MBProgressHUD wherever you need it with `#import <MBProgressHUD/MBProgressHUD.h>`.
+
+## Usage
+
+The main guideline you need to follow when dealing with MBProgressHUD while running long-running tasks is keeping the main thread work-free, so the UI can be updated promptly. The recommended way of using MBProgressHUD is therefore to set it up on the main thread and then spinning the task, that you want to perform, off onto a new thread.
+
+```objective-c
+[MBProgressHUD showHUDAddedTo:self.view animated:YES];
+dispatch_async(dispatch_get_global_queue( DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
+	// Do something...
+	dispatch_async(dispatch_get_main_queue(), ^{
+		[MBProgressHUD hideHUDForView:self.view animated:YES];
+	});
+});
+```
+
+You can add the HUD on any view or window. It is however a good idea to avoid adding the HUD to certain `UIKit` views with complex view hierarchies - like `UITableView` or `UICollectionView`. Those can mutate their subviews in unexpected ways and thereby break HUD display.
+
+If you need to configure the HUD you can do this by using the MBProgressHUD reference that showHUDAddedTo:animated: returns.
+
+```objective-c
+MBProgressHUD *hud = [MBProgressHUD showHUDAddedTo:self.view animated:YES];
+hud.mode = MBProgressHUDModeAnnularDeterminate;
+hud.label.text = @"Loading";
+[self doSomethingInBackgroundWithProgressCallback:^(float progress) {
+	hud.progress = progress;
+} completionCallback:^{
+	[hud hideAnimated:YES];
+}];
+```
+
+You can also use a `NSProgress` object and MBProgressHUD will update itself when there is progress reported through that object.
+
+```objective-c
+MBProgressHUD *hud = [MBProgressHUD showHUDAddedTo:self.view animated:YES];
+hud.mode = MBProgressHUDModeAnnularDeterminate;
+hud.label.text = @"Loading";
+NSProgress *progress = [self doSomethingInBackgroundCompletion:^{
+	[hud hideAnimated:YES];
+}];
+hud.progressObject = progress;
+```
+
+Keep in mind that UI updates, inclining calls to MBProgressHUD should always be done on the main thread.
+
+If you need to run your long-running task in the main thread, you should perform it with a slight delay, so UIKit will have enough time to update the UI (i.e., draw the HUD) before you block the main thread with your task.
+
+```objective-c
+[MBProgressHUD showHUDAddedTo:self.view animated:YES];
+dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, 0.01 * NSEC_PER_SEC);
+dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
+	// Do something...
+	[MBProgressHUD hideHUDForView:self.view animated:YES];
+});
+```
+
+You should be aware that any HUD updates issued inside the above block won't be displayed until the block completes.
+
+For more examples, including how to use MBProgressHUD with asynchronous operations such as NSURLConnection, take a look at the bundled demo project. Extensive API documentation is provided in the header file (MBProgressHUD.h).
+
+
+## License
+
+This code is distributed under the terms and conditions of the [MIT license](LICENSE).
+
+## Change-log
+
+A brief summary of each MBProgressHUD release can be found in the [CHANGELOG](CHANGELOG.mdown).

Pods/Manifest.lock

 PODS:
+  - MBProgressHUD (1.2.0)
   - MGSwipeTableCell (1.6.11)
   - Reachability (3.2)
   - YYKit (1.0.9):
@@ -6,21 +7,24 @@ PODS:
   - YYKit/no-arc (1.0.9)
 
 DEPENDENCIES:
+  - MBProgressHUD
   - MGSwipeTableCell
   - Reachability
   - YYKit
 
 SPEC REPOS:
   https://github.com/cocoapods/specs.git:
+    - MBProgressHUD
     - MGSwipeTableCell
     - Reachability
     - YYKit
 
 SPEC CHECKSUMS:
+  MBProgressHUD: 3ee5efcc380f6a79a7cc9b363dd669c5e1ae7406
   MGSwipeTableCell: b804e4e450dee439c42250be90bd50458bf67fce
   Reachability: 33e18b67625424e47b6cde6d202dce689ad7af96
   YYKit: 7cda43304a8dc3696c449041e2cb3107b4e236e7
 
-PODFILE CHECKSUM: c868a7d98611d357247477b920106b0538a46ea8
+PODFILE CHECKSUM: b9c7ad7c7b87e8ff4d6441b8c7486e604fc18b7b
 
 COCOAPODS: 1.7.2

Pods/Pods.xcodeproj/xcuserdata/davinci.pi.xcuserdatad/xcschemes/MBProgressHUD.xcscheme

+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1100"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForAnalyzing = "YES"
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "82B0A41D3031FF27D78E17B0A9A46FB0"
+               BuildableName = "MBProgressHUD.framework"
+               BlueprintName = "MBProgressHUD"
+               ReferencedContainer = "container:Pods.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      buildConfiguration = "Debug">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      buildConfiguration = "Debug"
+      allowLocationSimulation = "YES">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES"
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

Pods/Pods.xcodeproj/xcuserdata/davinci.pi.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -4,41 +4,48 @@
 <dict>
 	<key>SchemeUserState</key>
 	<dict>
-		<key>MGSwipeTableCell.xcscheme</key>
+		<key>MBProgressHUD.xcscheme</key>
 		<dict>
 			<key>isShown</key>
 			<false/>
 			<key>orderHint</key>
 			<integer>1</integer>
 		</dict>
-		<key>Pods-WXDownloadingComponent.xcscheme</key>
+		<key>MGSwipeTableCell.xcscheme</key>
 		<dict>
 			<key>isShown</key>
 			<false/>
 			<key>orderHint</key>
 			<integer>2</integer>
 		</dict>
-		<key>Pods-WXDownloadingKit.xcscheme</key>
+		<key>Pods-WXDownloadingComponent.xcscheme</key>
 		<dict>
 			<key>isShown</key>
 			<false/>
 			<key>orderHint</key>
 			<integer>3</integer>
 		</dict>
-		<key>Reachability.xcscheme</key>
+		<key>Pods-WXDownloadingKit.xcscheme</key>
 		<dict>
 			<key>isShown</key>
 			<false/>
 			<key>orderHint</key>
 			<integer>4</integer>
 		</dict>
-		<key>YYKit.xcscheme</key>
+		<key>Reachability.xcscheme</key>
 		<dict>
 			<key>isShown</key>
 			<false/>
 			<key>orderHint</key>
 			<integer>5</integer>
 		</dict>
+		<key>YYKit.xcscheme</key>
+		<dict>
+			<key>isShown</key>
+			<false/>
+			<key>orderHint</key>
+			<integer>6</integer>
+		</dict>
 	</dict>
 	<key>SuppressBuildableAutocreation</key>
 	<dict/>

Pods/Target Support Files/MBProgressHUD/MBProgressHUD-Info.plist

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>${EXECUTABLE_NAME}</string>
+  <key>CFBundleIdentifier</key>
+  <string>${PRODUCT_BUNDLE_IDENTIFIER}</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>${PRODUCT_NAME}</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.2.0</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>${CURRENT_PROJECT_VERSION}</string>
+  <key>NSPrincipalClass</key>
+  <string></string>
+</dict>
+</plist>

Pods/Target Support Files/MBProgressHUD/MBProgressHUD-dummy.m

+#import <Foundation/Foundation.h>
+@interface PodsDummy_MBProgressHUD : NSObject
+@end
+@implementation PodsDummy_MBProgressHUD
+@end

Pods/Target Support Files/MBProgressHUD/MBProgressHUD-prefix.pch

+#ifdef __OBJC__
+#import <UIKit/UIKit.h>
+#else
+#ifndef FOUNDATION_EXPORT
+#if defined(__cplusplus)
+#define FOUNDATION_EXPORT extern "C"
+#else
+#define FOUNDATION_EXPORT extern
+#endif
+#endif
+#endif
+

Pods/Target Support Files/MBProgressHUD/MBProgressHUD-umbrella.h

+#ifdef __OBJC__
+#import <UIKit/UIKit.h>
+#else
+#ifndef FOUNDATION_EXPORT
+#if defined(__cplusplus)
+#define FOUNDATION_EXPORT extern "C"
+#else
+#define FOUNDATION_EXPORT extern
+#endif
+#endif
+#endif
+
+#import "MBProgressHUD.h"
+
+FOUNDATION_EXPORT double MBProgressHUDVersionNumber;
+FOUNDATION_EXPORT const unsigned char MBProgressHUDVersionString[];
+

Pods/Target Support Files/MBProgressHUD/MBProgressHUD.modulemap

+framework module MBProgressHUD {
+  umbrella header "MBProgressHUD-umbrella.h"
+
+  export *
+  module * { export * }
+}

Pods/Target Support Files/MBProgressHUD/MBProgressHUD.xcconfig

+CONFIGURATION_BUILD_DIR = ${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD
+GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
+OTHER_LDFLAGS = $(inherited) -framework "CoreGraphics" -framework "QuartzCore"
+PODS_BUILD_DIR = ${BUILD_DIR}
+PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
+PODS_ROOT = ${SRCROOT}
+PODS_TARGET_SRCROOT = ${PODS_ROOT}/MBProgressHUD
+PRODUCT_BUNDLE_IDENTIFIER = org.cocoapods.${PRODUCT_NAME:rfc1034identifier}
+SKIP_INSTALL = YES

Pods/Target Support Files/Pods-WXDownloadingComponent/Pods-WXDownloadingComponent-acknowledgements.markdown

 # Acknowledgements
 This application makes use of the following third party libraries:
 
+## MBProgressHUD
+
+Copyright © 2009-2020 Matej Bukovinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
 ## MGSwipeTableCell
 
 The MIT License (MIT)

Pods/Target Support Files/Pods-WXDownloadingComponent/Pods-WXDownloadingComponent-acknowledgements.plist

@@ -14,6 +14,34 @@
 		</dict>
 		<dict>
 			<key>FooterText</key>
+			<string>Copyright © 2009-2020 Matej Bukovinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.</string>
+			<key>License</key>
+			<string>MIT</string>
+			<key>Title</key>
+			<string>MBProgressHUD</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
 			<string>The MIT License (MIT)
 
 Copyright (c) 2018 Imanol Fernandez @MortimerGoro

Pods/Target Support Files/Pods-WXDownloadingComponent/Pods-WXDownloadingComponent.debug.xcconfig

-FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit" "${PODS_ROOT}/YYKit/Vendor"
+FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD" "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit" "${PODS_ROOT}/YYKit/Vendor"
 GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
-HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers"
+HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD/MBProgressHUD.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers"
 LD_RUNPATH_SEARCH_PATHS = $(inherited) '@executable_path/Frameworks' '@loader_path/Frameworks' '@executable_path/../../Frameworks'
-OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" -iframework "${PODS_ROOT}/YYKit/Vendor" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/YYKit"
-OTHER_LDFLAGS = $(inherited) -ObjC -l"sqlite3" -l"z" -framework "Accelerate" -framework "AssetsLibrary" -framework "CoreFoundation" -framework "CoreGraphics" -framework "CoreImage" -framework "CoreText" -framework "ImageIO" -framework "MGSwipeTableCell" -framework "MobileCoreServices" -framework "QuartzCore" -framework "Reachability" -framework "SystemConfiguration" -framework "UIKit" -framework "YYKit"
+OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD/MBProgressHUD.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" -iframework "${PODS_ROOT}/YYKit/Vendor" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/YYKit"
+OTHER_LDFLAGS = $(inherited) -ObjC -l"sqlite3" -l"z" -framework "Accelerate" -framework "AssetsLibrary" -framework "CoreFoundation" -framework "CoreGraphics" -framework "CoreImage" -framework "CoreText" -framework "ImageIO" -framework "MBProgressHUD" -framework "MGSwipeTableCell" -framework "MobileCoreServices" -framework "QuartzCore" -framework "Reachability" -framework "SystemConfiguration" -framework "UIKit" -framework "YYKit"
 PODS_BUILD_DIR = ${BUILD_DIR}
 PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
 PODS_PODFILE_DIR_PATH = ${SRCROOT}/.

Pods/Target Support Files/Pods-WXDownloadingComponent/Pods-WXDownloadingComponent.release.xcconfig

-FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit" "${PODS_ROOT}/YYKit/Vendor"
+FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD" "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit" "${PODS_ROOT}/YYKit/Vendor"
 GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
-HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers"
+HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD/MBProgressHUD.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers"
 LD_RUNPATH_SEARCH_PATHS = $(inherited) '@executable_path/Frameworks' '@loader_path/Frameworks' '@executable_path/../../Frameworks'
-OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" -iframework "${PODS_ROOT}/YYKit/Vendor" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/YYKit"
-OTHER_LDFLAGS = $(inherited) -ObjC -l"sqlite3" -l"z" -framework "Accelerate" -framework "AssetsLibrary" -framework "CoreFoundation" -framework "CoreGraphics" -framework "CoreImage" -framework "CoreText" -framework "ImageIO" -framework "MGSwipeTableCell" -framework "MobileCoreServices" -framework "QuartzCore" -framework "Reachability" -framework "SystemConfiguration" -framework "UIKit" -framework "YYKit"
+OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD/MBProgressHUD.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" -iframework "${PODS_ROOT}/YYKit/Vendor" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/YYKit"
+OTHER_LDFLAGS = $(inherited) -ObjC -l"sqlite3" -l"z" -framework "Accelerate" -framework "AssetsLibrary" -framework "CoreFoundation" -framework "CoreGraphics" -framework "CoreImage" -framework "CoreText" -framework "ImageIO" -framework "MBProgressHUD" -framework "MGSwipeTableCell" -framework "MobileCoreServices" -framework "QuartzCore" -framework "Reachability" -framework "SystemConfiguration" -framework "UIKit" -framework "YYKit"
 PODS_BUILD_DIR = ${BUILD_DIR}
 PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
 PODS_PODFILE_DIR_PATH = ${SRCROOT}/.

Pods/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit-acknowledgements.markdown

 # Acknowledgements
 This application makes use of the following third party libraries:
 
+## MBProgressHUD
+
+Copyright © 2009-2020 Matej Bukovinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
 ## MGSwipeTableCell
 
 The MIT License (MIT)

Pods/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit-acknowledgements.plist

@@ -14,6 +14,34 @@
 		</dict>
 		<dict>
 			<key>FooterText</key>
+			<string>Copyright © 2009-2020 Matej Bukovinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.</string>
+			<key>License</key>
+			<string>MIT</string>
+			<key>Title</key>
+			<string>MBProgressHUD</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
 			<string>The MIT License (MIT)
 
 Copyright (c) 2018 Imanol Fernandez @MortimerGoro

Pods/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit-frameworks-Debug-input-files.xcfilelist

 ${PODS_ROOT}/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit-frameworks.sh
+${BUILT_PRODUCTS_DIR}/MBProgressHUD/MBProgressHUD.framework
 ${BUILT_PRODUCTS_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework
 ${BUILT_PRODUCTS_DIR}/Reachability/Reachability.framework
 ${BUILT_PRODUCTS_DIR}/YYKit/YYKit.framework
\ No newline at end of file

Pods/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit-frameworks-Debug-output-files.xcfilelist

+${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/MBProgressHUD.framework
 ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/MGSwipeTableCell.framework
 ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/Reachability.framework
 ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/YYKit.framework
\ No newline at end of file

Pods/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit-frameworks-Release-input-files.xcfilelist

 ${PODS_ROOT}/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit-frameworks.sh
+${BUILT_PRODUCTS_DIR}/MBProgressHUD/MBProgressHUD.framework
 ${BUILT_PRODUCTS_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework
 ${BUILT_PRODUCTS_DIR}/Reachability/Reachability.framework
 ${BUILT_PRODUCTS_DIR}/YYKit/YYKit.framework
\ No newline at end of file

Pods/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit-frameworks-Release-output-files.xcfilelist

+${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/MBProgressHUD.framework
 ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/MGSwipeTableCell.framework
 ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/Reachability.framework
 ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/YYKit.framework
\ No newline at end of file

Pods/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit-frameworks.sh

@@ -161,11 +161,13 @@ strip_invalid_archs() {
 
 
 if [[ "$CONFIGURATION" == "Debug" ]]; then
+  install_framework "${BUILT_PRODUCTS_DIR}/MBProgressHUD/MBProgressHUD.framework"
   install_framework "${BUILT_PRODUCTS_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework"
   install_framework "${BUILT_PRODUCTS_DIR}/Reachability/Reachability.framework"
   install_framework "${BUILT_PRODUCTS_DIR}/YYKit/YYKit.framework"
 fi
 if [[ "$CONFIGURATION" == "Release" ]]; then
+  install_framework "${BUILT_PRODUCTS_DIR}/MBProgressHUD/MBProgressHUD.framework"
   install_framework "${BUILT_PRODUCTS_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework"
   install_framework "${BUILT_PRODUCTS_DIR}/Reachability/Reachability.framework"
   install_framework "${BUILT_PRODUCTS_DIR}/YYKit/YYKit.framework"

Pods/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit.debug.xcconfig

-FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit" "${PODS_ROOT}/YYKit/Vendor"
+FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD" "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit" "${PODS_ROOT}/YYKit/Vendor"
 GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
-HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers"
+HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD/MBProgressHUD.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers"
 LD_RUNPATH_SEARCH_PATHS = $(inherited) '@executable_path/Frameworks' '@loader_path/Frameworks'
-OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" -iframework "${PODS_ROOT}/YYKit/Vendor" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/YYKit"
-OTHER_LDFLAGS = $(inherited) -ObjC -l"sqlite3" -l"z" -framework "Accelerate" -framework "AssetsLibrary" -framework "CoreFoundation" -framework "CoreGraphics" -framework "CoreImage" -framework "CoreText" -framework "ImageIO" -framework "MGSwipeTableCell" -framework "MobileCoreServices" -framework "QuartzCore" -framework "Reachability" -framework "SystemConfiguration" -framework "UIKit" -framework "YYKit"
+OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD/MBProgressHUD.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" -iframework "${PODS_ROOT}/YYKit/Vendor" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/YYKit"
+OTHER_LDFLAGS = $(inherited) -ObjC -l"sqlite3" -l"z" -framework "Accelerate" -framework "AssetsLibrary" -framework "CoreFoundation" -framework "CoreGraphics" -framework "CoreImage" -framework "CoreText" -framework "ImageIO" -framework "MBProgressHUD" -framework "MGSwipeTableCell" -framework "MobileCoreServices" -framework "QuartzCore" -framework "Reachability" -framework "SystemConfiguration" -framework "UIKit" -framework "YYKit"
 PODS_BUILD_DIR = ${BUILD_DIR}
 PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
 PODS_PODFILE_DIR_PATH = ${SRCROOT}/.

Pods/Target Support Files/Pods-WXDownloadingKit/Pods-WXDownloadingKit.release.xcconfig

-FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit" "${PODS_ROOT}/YYKit/Vendor"
+FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD" "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit" "${PODS_ROOT}/YYKit/Vendor"
 GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
-HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers"
+HEADER_SEARCH_PATHS = $(inherited) "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD/MBProgressHUD.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers"
 LD_RUNPATH_SEARCH_PATHS = $(inherited) '@executable_path/Frameworks' '@loader_path/Frameworks'
-OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" -iframework "${PODS_ROOT}/YYKit/Vendor" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/YYKit"
-OTHER_LDFLAGS = $(inherited) -ObjC -l"sqlite3" -l"z" -framework "Accelerate" -framework "AssetsLibrary" -framework "CoreFoundation" -framework "CoreGraphics" -framework "CoreImage" -framework "CoreText" -framework "ImageIO" -framework "MGSwipeTableCell" -framework "MobileCoreServices" -framework "QuartzCore" -framework "Reachability" -framework "SystemConfiguration" -framework "UIKit" -framework "YYKit"
+OTHER_CFLAGS = $(inherited) -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD/MBProgressHUD.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell/MGSwipeTableCell.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/Reachability/Reachability.framework/Headers" -isystem "${PODS_CONFIGURATION_BUILD_DIR}/YYKit/YYKit.framework/Headers" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MBProgressHUD" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/MGSwipeTableCell" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/Reachability" -iframework "${PODS_ROOT}/YYKit/Vendor" -iframework "${PODS_CONFIGURATION_BUILD_DIR}/YYKit"
+OTHER_LDFLAGS = $(inherited) -ObjC -l"sqlite3" -l"z" -framework "Accelerate" -framework "AssetsLibrary" -framework "CoreFoundation" -framework "CoreGraphics" -framework "CoreImage" -framework "CoreText" -framework "ImageIO" -framework "MBProgressHUD" -framework "MGSwipeTableCell" -framework "MobileCoreServices" -framework "QuartzCore" -framework "Reachability" -framework "SystemConfiguration" -framework "UIKit" -framework "YYKit"
 PODS_BUILD_DIR = ${BUILD_DIR}
 PODS_CONFIGURATION_BUILD_DIR = ${PODS_BUILD_DIR}/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
 PODS_PODFILE_DIR_PATH = ${SRCROOT}/.

WXDownloadingKit.xcodeproj/project.pbxproj

@@ -3,7 +3,7 @@
 	archiveVersion = 1;
 	classes = {
 	};
-	objectVersion = 50;
+	objectVersion = 51;
 	objects = {
 
 /* Begin PBXBuildFile section */
@@ -28,11 +28,6 @@
 		7390472B2410EACA00181090 /* CODownloadObject.m in Sources */ = {isa = PBXBuildFile; fileRef = 739047172410EACA00181090 /* CODownloadObject.m */; };
 		739047362411099C00181090 /* CODownloadCell.m in Sources */ = {isa = PBXBuildFile; fileRef = 739047352411099C00181090 /* CODownloadCell.m */; };
 		7390473924110C5700181090 /* WXCOUtility.m in Sources */ = {isa = PBXBuildFile; fileRef = 7390473824110C5700181090 /* WXCOUtility.m */; };
-		73904744241132A500181090 /* SVRadialGradientLayer.m in Sources */ = {isa = PBXBuildFile; fileRef = 7390473B241132A500181090 /* SVRadialGradientLayer.m */; };
-		73904745241132A500181090 /* SVProgressAnimatedView.m in Sources */ = {isa = PBXBuildFile; fileRef = 7390473E241132A500181090 /* SVProgressAnimatedView.m */; };
-		73904746241132A500181090 /* SVProgressHUD.m in Sources */ = {isa = PBXBuildFile; fileRef = 73904740241132A500181090 /* SVProgressHUD.m */; };
-		73904747241132A500181090 /* SVIndefiniteAnimatedView.m in Sources */ = {isa = PBXBuildFile; fileRef = 73904741241132A500181090 /* SVIndefiniteAnimatedView.m */; };
-		73904748241132A500181090 /* SVProgressHUD.bundle in Resources */ = {isa = PBXBuildFile; fileRef = 73904742241132A500181090 /* SVProgressHUD.bundle */; };
 		739047522411E2C900181090 /* WXDownloadingComponent.h in Headers */ = {isa = PBXBuildFile; fileRef = 739047502411E2C900181090 /* WXDownloadingComponent.h */; settings = {ATTRIBUTES = (Public, ); }; };
 		739047552411E2C900181090 /* WXDownloadingComponent.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 7390474E2411E2C900181090 /* WXDownloadingComponent.framework */; };
 		739047562411E2C900181090 /* WXDownloadingComponent.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = 7390474E2411E2C900181090 /* WXDownloadingComponent.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; };
@@ -142,15 +137,6 @@
 		739047352411099C00181090 /* CODownloadCell.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = CODownloadCell.m; sourceTree = "<group>"; };
 		7390473724110C5700181090 /* WXCOUtility.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WXCOUtility.h; sourceTree = "<group>"; };
 		7390473824110C5700181090 /* WXCOUtility.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = WXCOUtility.m; sourceTree = "<group>"; };
-		7390473B241132A500181090 /* SVRadialGradientLayer.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SVRadialGradientLayer.m; sourceTree = "<group>"; };
-		7390473C241132A500181090 /* SVIndefiniteAnimatedView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVIndefiniteAnimatedView.h; sourceTree = "<group>"; };
-		7390473D241132A500181090 /* SVProgressHUD.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVProgressHUD.h; sourceTree = "<group>"; };
-		7390473E241132A500181090 /* SVProgressAnimatedView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SVProgressAnimatedView.m; sourceTree = "<group>"; };
-		7390473F241132A500181090 /* SVRadialGradientLayer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVRadialGradientLayer.h; sourceTree = "<group>"; };
-		73904740241132A500181090 /* SVProgressHUD.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SVProgressHUD.m; sourceTree = "<group>"; };
-		73904741241132A500181090 /* SVIndefiniteAnimatedView.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SVIndefiniteAnimatedView.m; sourceTree = "<group>"; };
-		73904742241132A500181090 /* SVProgressHUD.bundle */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.plug-in"; path = SVProgressHUD.bundle; sourceTree = "<group>"; };
-		73904743241132A500181090 /* SVProgressAnimatedView.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SVProgressAnimatedView.h; sourceTree = "<group>"; };
 		7390474E2411E2C900181090 /* WXDownloadingComponent.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = WXDownloadingComponent.framework; sourceTree = BUILT_PRODUCTS_DIR; };
 		739047502411E2C900181090 /* WXDownloadingComponent.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = WXDownloadingComponent.h; sourceTree = "<group>"; };
 		739047512411E2C900181090 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
@@ -212,7 +198,6 @@
 		7390469D2410DB7800181090 /* WXDownloadingKit */ = {
 			isa = PBXGroup;
 			children = (
-				7390473A241132A500181090 /* SVProgressHUD */,
 				739046E92410DFC300181090 /* Downloading */,
 				7390469E2410DB7800181090 /* AppDelegate.h */,
 				7390469F2410DB7800181090 /* AppDelegate.m */,
@@ -321,22 +306,6 @@
 			path = View;
 			sourceTree = "<group>";
 		};
-		7390473A241132A500181090 /* SVProgressHUD */ = {
-			isa = PBXGroup;
-			children = (
-				7390473C241132A500181090 /* SVIndefiniteAnimatedView.h */,
-				73904741241132A500181090 /* SVIndefiniteAnimatedView.m */,
-				73904743241132A500181090 /* SVProgressAnimatedView.h */,
-				7390473E241132A500181090 /* SVProgressAnimatedView.m */,
-				7390473D241132A500181090 /* SVProgressHUD.h */,
-				73904740241132A500181090 /* SVProgressHUD.m */,
-				7390473F241132A500181090 /* SVRadialGradientLayer.h */,
-				7390473B241132A500181090 /* SVRadialGradientLayer.m */,
-				73904742241132A500181090 /* SVProgressHUD.bundle */,
-			);
-			path = SVProgressHUD;
-			sourceTree = "<group>";
-		};
 		7390474F2411E2C900181090 /* WXDownloadingComponent */ = {
 			isa = PBXGroup;
 			children = (
@@ -469,7 +438,6 @@
 				739046AE2410DB7900181090 /* LaunchScreen.storyboard in Resources */,
 				739046AB2410DB7900181090 /* Assets.xcassets in Resources */,
 				739046A92410DB7800181090 /* Main.storyboard in Resources */,
-				73904748241132A500181090 /* SVProgressHUD.bundle in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -552,17 +520,14 @@
 			buildActionMask = 2147483647;
 			files = (
 				7390471B2410EACA00181090 /* BPDownloadContent.m in Sources */,
-				73904747241132A500181090 /* SVIndefiniteAnimatedView.m in Sources */,
 				739047232410EACA00181090 /* CODownloadManager+Paper.m in Sources */,
 				7390471D2410EACA00181090 /* BPDownloadManager.m in Sources */,
 				739047272410EACA00181090 /* CODownloadManager+ByURL.m in Sources */,
 				739047362411099C00181090 /* CODownloadCell.m in Sources */,
 				739047192410EACA00181090 /* BPFileManager.m in Sources */,
 				739047202410EACA00181090 /* SyncDownloadHandler.m in Sources */,
-				73904744241132A500181090 /* SVRadialGradientLayer.m in Sources */,
 				7390471C2410EACA00181090 /* BPNetWorkService.m in Sources */,
 				739046A62410DB7800181090 /* ViewController.m in Sources */,
-				73904746241132A500181090 /* SVProgressHUD.m in Sources */,
 				739047292410EACA00181090 /* CODownloadModel.m in Sources */,
 				7390473924110C5700181090 /* WXCOUtility.m in Sources */,
 				7390471A2410EACA00181090 /* BPDownloader.m in Sources */,
@@ -572,7 +537,6 @@
 				7390472B2410EACA00181090 /* CODownloadObject.m in Sources */,
 				739047182410EACA00181090 /* BPNetWorkConfig.m in Sources */,
 				739046B12410DB7900181090 /* main.m in Sources */,
-				73904745241132A500181090 /* SVProgressAnimatedView.m in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

WXDownloadingKit.xcodeproj/xcuserdata/davinci.pi.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -12,7 +12,7 @@
 		<key>WXDownloadingKit.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>6</integer>
+			<integer>7</integer>
 		</dict>
 	</dict>
 	<key>SuppressBuildableAutocreation</key>

WXDownloadingKit/Downloading/Other/WXCOUtility.h

@@ -17,7 +17,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 + (UIViewController *)getCurrentVC;
 
-+ (void)showAlertWithMessage:(NSString *)message;
++ (void)showHUDWithMessage:(NSString *)message;
 
 + (NSURL *)urlWithString:(NSString *)string;
 

WXDownloadingKit/Downloading/Other/WXCOUtility.m

@@ -7,21 +7,12 @@
 //
 
 #import "WXCOUtility.h"
-#import "SVProgressHUD.h"
 #import <UIKit/UIKit.h>
+#import <YYKit/YYKit.h>
+#import <MBProgressHUD/MBProgressHUD.h>
 
 @implementation WXCOUtility
 
-+ (void)initialize {
-    [SVProgressHUD setDefaultMaskType:SVProgressHUDMaskTypeClear];// 整个后面的背景选择
-    [SVProgressHUD setBackgroundColor:[UIColor colorWithRed:0 green:0 blue:0 alpha:0.6]];// 弹出框颜色
-    [SVProgressHUD setForegroundColor:[UIColor whiteColor]];// 弹出框内容颜色
-    [SVProgressHUD setFont:[UIFont systemFontOfSize:13]];//字体
-    [SVProgressHUD setMinimumDismissTimeInterval:1.5];
-    [SVProgressHUD setMaximumDismissTimeInterval:3.0];
-    [SVProgressHUD setDefaultAnimationType:SVProgressHUDAnimationTypeNative];
-}
-
 + (NSString *)getTimeNow {
     NSDate *date = [NSDate date];
     return [self getTimeString:date];
@@ -71,9 +62,23 @@
     return currentVC;
 }
 
-+ (void)showAlertWithMessage:(NSString *)message {
-    [SVProgressHUD setCornerRadius:20.0f];
-    [SVProgressHUD showImage:nil status:message];
++ (void)showHUDWithMessage:(NSString *)message {
+    if (!message || [message isKindOfClass:[NSNull class]] || message.length == 0) {
+        return;
+    }
+    
+    [self performOptionOnMainQueue:^{
+        MBProgressHUD *hud = [MBProgressHUD showHUDAddedTo:[UIApplication sharedApplication].keyWindow animated:YES];
+        hud.userInteractionEnabled = NO;
+        hud.mode = MBProgressHUDModeText;
+        hud.detailsLabel.text = message;
+        hud.contentColor = [UIColor whiteColor];
+        hud.bezelView.color = [UIColor colorWithWhite:0 alpha:0.9f];
+        hud.detailsLabel.font = [UIFont systemFontOfSize:15.0f];
+        hud.margin = 10.0f;
+        hud.removeFromSuperViewOnHide = YES;
+        [hud hideAnimated:YES afterDelay:2.0f];
+    }];
 }
 
 + (NSURL *)urlWithString:(NSString *)string {
@@ -90,4 +95,20 @@
     return timestamp;
 }
 
+#pragma mark - Main Queue
+
++ (void)performOptionOnMainQueue:(void (^)(void))block {
+    if ([NSThread isMainThread]) {
+        if (block) {
+            block();
+        }
+    } else {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            if (block) {
+                block();
+            }
+        });
+    }
+}
+
 @end

WXDownloadingKit/Downloading/Tool/CODownloadManager+ByURL.m

@@ -55,14 +55,14 @@
 
 - (void)co_pauseURLDownload:(NSString *)downloadURL {
     if (WXCOIsNilOrNull(downloadURL) || downloadURL.length <= 0) {
-        [WXCOUtility showAlertWithMessage:@"抱歉，没有找到下载数据"];
+        [WXCOUtility showHUDWithMessage:@"抱歉，没有找到下载数据"];
         return;
     }
     
     downloadURL = [WXCOUtility urlWithString:downloadURL].absoluteString; // 编码处理
     CODownloadObject *object = [self co_getDownloadObjectByUrl:downloadURL];
     if (WXCOIsNilOrNull(object) == YES) {
-        [WXCOUtility showAlertWithMessage:@"抱歉，没有找到下载数据"];
+        [WXCOUtility showHUDWithMessage:@"抱歉，没有找到下载数据"];
         return;
     }
     [self co_pauseDownload:[NSMutableArray arrayWithObjects:object, nil]];
@@ -72,14 +72,14 @@
                       userID:(NSString *)userID
           withViewController:(UIViewController *)presentVC {
     if (WXCOIsNilOrNull(downloadURL) || downloadURL.length <= 0) {
-        [WXCOUtility showAlertWithMessage:@"抱歉，没有找到下载数据"];
+        [WXCOUtility showHUDWithMessage:@"抱歉，没有找到下载数据"];
         return;
     }
     
     downloadURL = [WXCOUtility urlWithString:downloadURL].absoluteString; // 编码处理
     CODownloadObject *object = [self co_getDownloadObjectByUrl:downloadURL];
     if (WXCOIsNilOrNull(object) == YES) { // 没发现可以删除的对象
-        [WXCOUtility showAlertWithMessage:@"抱歉，没有找到下载数据"];
+        [WXCOUtility showHUDWithMessage:@"抱歉，没有找到下载数据"];
         return;
     }
     

WXDownloadingKit/Downloading/Tool/CODownloadManager+Paper.m

@@ -57,7 +57,7 @@
                         userID:(NSString *)userID
                    cancelBlock:(nullable void(^)(BOOL cancel))block {
     if (paperArray == nil || paperArray.count <= 0) { // 没发现可以删除的对象
-        [WXCOUtility showAlertWithMessage:@"此次操作中没有发现可删除的文件"];
+        [WXCOUtility showHUDWithMessage:@"此次操作中没有发现可删除的文件"];
         
         if (WXCOIsNilOrNull(block) == NO) {
             block(YES);

WXDownloadingKit/Downloading/Tool/CODownloadManager+Reject.m

@@ -20,7 +20,7 @@
 - (void)showNormalDownloadRejectInfo:(NSMutableArray<CODownloadRejectModel *> *)rejectArray
                 withPriorityDownlaod:(BOOL)isPriority {
     if (rejectArray == nil || rejectArray.count <= 0) {
-        [WXCOUtility showAlertWithMessage:(isPriority == YES ? @"已优先下载" : @"已添加到下载队列，请前往缓存下载查看")];
+        [WXCOUtility showHUDWithMessage:(isPriority == YES ? @"已优先下载" : @"已添加到下载队列，请前往缓存下载查看")];
         return;
     }
     
@@ -29,7 +29,7 @@
         if (model.reason == DownloadRejectReasonEmptyList ||
             model.reason == DownloadRejectReasonNoNetwork ||
             model.reason == DownloadRejectReasonWWANNetwork) {
-            [WXCOUtility showAlertWithMessage:model.description];
+            [WXCOUtility showHUDWithMessage:model.description];
             message = nil;
             break;
         } else if (model.reason == DownloadRejectReasonEmptyURL ||
@@ -46,7 +46,7 @@
     }
     
     if (WXCOStringIsEmpty(message) == NO) {
-        [WXCOUtility showAlertWithMessage:message];
+        [WXCOUtility showHUDWithMessage:message];
     }
 }
 

WXDownloadingKit/Downloading/Tool/CODownloadManager.m

@@ -224,7 +224,7 @@ static CODownloadManager *instance=nil;
 
 - (void)co_pauseDownload:(NSMutableArray <CODownloadObject *>*)objectArray {
     if (objectArray == nil || objectArray.count <= 0) { // 没发现可以暂停的对象
-        [WXCOUtility showAlertWithMessage:@"未发现可暂停的下载"];
+        [WXCOUtility showHUDWithMessage:@"未发现可暂停的下载"];
         return;
     }
     
@@ -239,14 +239,14 @@ static CODownloadManager *instance=nil;
     }
     // 如果需要提示
     if (toastTip == YES) {
-        [WXCOUtility showAlertWithMessage:@"已暂停下载"];
+        [WXCOUtility showHUDWithMessage:@"已暂停下载"];
     }
     [self co_processDownloadQueue]; // 推动下载队列继续前进，如果有空闲的下载通道，则可以有新的下载进入
 }
 
 - (void)co_deleteDownload:(NSMutableArray <CODownloadObject *>*)objectArray userID:(NSString *)userID {
     if (objectArray == nil || objectArray.count <= 0) { // 没发现可以删除的对象
-        [WXCOUtility showAlertWithMessage:@"未发现可删除的下载"];
+        [WXCOUtility showHUDWithMessage:@"未发现可删除的下载"];
         return;
     }
     
@@ -264,7 +264,7 @@ static CODownloadManager *instance=nil;
     
     // 如果需要提示
     if (toastTip == YES) {
-        [WXCOUtility showAlertWithMessage:@"操作成功"];
+        [WXCOUtility showHUDWithMessage:@"操作成功"];
     }
     [self co_processDownloadQueue]; // 推动下载队列继续前进，如果有空闲的下载通道，则可以有新的下载进入
     [[NSNotificationCenter defaultCenter] postNotificationName:NotiUpdateDownloadInfo object:nil];

WXDownloadingKit/SVProgressHUD/SVIndefiniteAnimatedView.h

-//
-//  SVIndefiniteAnimatedView.h
-//  SVProgressHUD, https://github.com/SVProgressHUD/SVProgressHUD
-//
-//  Copyright (c) 2014-2018 Guillaume Campagna. All rights reserved.
-//
-
-#import <UIKit/UIKit.h>
-
-@interface SVIndefiniteAnimatedView : UIView
-
-@property (nonatomic, assign) CGFloat strokeThickness;
-@property (nonatomic, assign) CGFloat radius;
-@property (nonatomic, strong) UIColor *strokeColor;
-
-@end
-

WXDownloadingKit/SVProgressHUD/SVIndefiniteAnimatedView.m

-//
-//  SVIndefiniteAnimatedView.m
-//  SVProgressHUD, https://github.com/SVProgressHUD/SVProgressHUD
-//
-//  Copyright (c) 2014-2018 Guillaume Campagna. All rights reserved.
-//
-
-#import "SVIndefiniteAnimatedView.h"
-#import "SVProgressHUD.h"
-
-@interface SVIndefiniteAnimatedView ()
-
-@property (nonatomic, strong) CAShapeLayer *indefiniteAnimatedLayer;
-
-@end
-
-@implementation SVIndefiniteAnimatedView
-
-- (void)willMoveToSuperview:(UIView*)newSuperview {
-    if (newSuperview) {
-        [self layoutAnimatedLayer];
-    } else {
-        [_indefiniteAnimatedLayer removeFromSuperlayer];
-        _indefiniteAnimatedLayer = nil;
-    }
-}
-
-- (void)layoutAnimatedLayer {
-    CALayer *layer = self.indefiniteAnimatedLayer;
-    [self.layer addSublayer:layer];
-    
-    CGFloat widthDiff = CGRectGetWidth(self.bounds) - CGRectGetWidth(layer.bounds);
-    CGFloat heightDiff = CGRectGetHeight(self.bounds) - CGRectGetHeight(layer.bounds);
-    layer.position = CGPointMake(CGRectGetWidth(self.bounds) - CGRectGetWidth(layer.bounds) / 2 - widthDiff / 2, CGRectGetHeight(self.bounds) - CGRectGetHeight(layer.bounds) / 2 - heightDiff / 2);
-}
-
-- (CAShapeLayer*)indefiniteAnimatedLayer {
-    if(!_indefiniteAnimatedLayer) {
-        CGPoint arcCenter = CGPointMake(self.radius+self.strokeThickness/2+5, self.radius+self.strokeThickness/2+5);
-        UIBezierPath* smoothedPath = [UIBezierPath bezierPathWithArcCenter:arcCenter radius:self.radius startAngle:(CGFloat) (M_PI*3/2) endAngle:(CGFloat) (M_PI/2+M_PI*5) clockwise:YES];
-        
-        _indefiniteAnimatedLayer = [CAShapeLayer layer];
-        _indefiniteAnimatedLayer.contentsScale = [[UIScreen mainScreen] scale];
-        _indefiniteAnimatedLayer.frame = CGRectMake(0.0f, 0.0f, arcCenter.x*2, arcCenter.y*2);
-        _indefiniteAnimatedLayer.fillColor = [UIColor clearColor].CGColor;
-        _indefiniteAnimatedLayer.strokeColor = self.strokeColor.CGColor;
-        _indefiniteAnimatedLayer.lineWidth = self.strokeThickness;
-        _indefiniteAnimatedLayer.lineCap = kCALineCapRound;
-        _indefiniteAnimatedLayer.lineJoin = kCALineJoinBevel;
-        _indefiniteAnimatedLayer.path = smoothedPath.CGPath;
-        
-        CALayer *maskLayer = [CALayer layer];
-        
-        NSBundle *bundle = [NSBundle bundleForClass:[SVProgressHUD class]];
-        NSURL *url = [bundle URLForResource:@"SVProgressHUD" withExtension:@"bundle"];
-        NSBundle *imageBundle = [NSBundle bundleWithURL:url];
-        
-        NSString *path = [imageBundle pathForResource:@"angle-mask" ofType:@"png"];
-        
-        maskLayer.contents = (__bridge id)[[UIImage imageWithContentsOfFile:path] CGImage];
-        maskLayer.frame = _indefiniteAnimatedLayer.bounds;
-        _indefiniteAnimatedLayer.mask = maskLayer;
-        
-        NSTimeInterval animationDuration = 1;
-        CAMediaTimingFunction *linearCurve = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionLinear];
-        
-        CABasicAnimation *animation = [CABasicAnimation animationWithKeyPath:@"transform.rotation"];
-        animation.fromValue = (id) 0;
-        animation.toValue = @(M_PI*2);
-        animation.duration = animationDuration;
-        animation.timingFunction = linearCurve;
-        animation.removedOnCompletion = NO;
-        animation.repeatCount = INFINITY;
-        animation.fillMode = kCAFillModeForwards;
-        animation.autoreverses = NO;
-        [_indefiniteAnimatedLayer.mask addAnimation:animation forKey:@"rotate"];
-        
-        CAAnimationGroup *animationGroup = [CAAnimationGroup animation];
-        animationGroup.duration = animationDuration;
-        animationGroup.repeatCount = INFINITY;
-        animationGroup.removedOnCompletion = NO;
-        animationGroup.timingFunction = linearCurve;
-        
-        CABasicAnimation *strokeStartAnimation = [CABasicAnimation animationWithKeyPath:@"strokeStart"];
-        strokeStartAnimation.fromValue = @0.015;
-        strokeStartAnimation.toValue = @0.515;
-        
-        CABasicAnimation *strokeEndAnimation = [CABasicAnimation animationWithKeyPath:@"strokeEnd"];
-        strokeEndAnimation.fromValue = @0.485;
-        strokeEndAnimation.toValue = @0.985;
-        
-        animationGroup.animations = @[strokeStartAnimation, strokeEndAnimation];
-        [_indefiniteAnimatedLayer addAnimation:animationGroup forKey:@"progress"];
-        
-    }
-    return _indefiniteAnimatedLayer;
-}
-
-- (void)setFrame:(CGRect)frame {
-    if(!CGRectEqualToRect(frame, super.frame)) {
-        [super setFrame:frame];
-        
-        if(self.superview) {
-            [self layoutAnimatedLayer];
-        }
-    }
-    
-}
-
-- (void)setRadius:(CGFloat)radius {
-    if(radius != _radius) {
-        _radius = radius;
-        
-        [_indefiniteAnimatedLayer removeFromSuperlayer];
-        _indefiniteAnimatedLayer = nil;
-        
-        if(self.superview) {
-            [self layoutAnimatedLayer];
-        }
-    }
-}
-
-- (void)setStrokeColor:(UIColor*)strokeColor {
-    _strokeColor = strokeColor;
-    _indefiniteAnimatedLayer.strokeColor = strokeColor.CGColor;
-}
-
-- (void)setStrokeThickness:(CGFloat)strokeThickness {
-    _strokeThickness = strokeThickness;
-    _indefiniteAnimatedLayer.lineWidth = _strokeThickness;
-}
-
-- (CGSize)sizeThatFits:(CGSize)size {
-    return CGSizeMake((self.radius+self.strokeThickness/2+5)*2, (self.radius+self.strokeThickness/2+5)*2);
-}
-
-@end

WXDownloadingKit/SVProgressHUD/SVProgressAnimatedView.h

-//
-//  SVProgressAnimatedView.h
-//  SVProgressHUD, https://github.com/SVProgressHUD/SVProgressHUD
-//
-//  Copyright (c) 2017-2018 Tobias Tiemerding. All rights reserved.
-//
-
-#import <UIKit/UIKit.h>
-
-@interface SVProgressAnimatedView : UIView
-
-@property (nonatomic, assign) CGFloat radius;
-@property (nonatomic, assign) CGFloat strokeThickness;
-@property (nonatomic, strong) UIColor *strokeColor;
-@property (nonatomic, assign) CGFloat strokeEnd;
-
-@end

WXDownloadingKit/SVProgressHUD/SVProgressAnimatedView.m

-//
-//  SVProgressAnimatedView.m
-//  SVProgressHUD, https://github.com/SVProgressHUD/SVProgressHUD
-//
-//  Copyright (c) 2017-2018 Tobias Tiemerding. All rights reserved.
-//
-
-#import "SVProgressAnimatedView.h"
-
-@interface SVProgressAnimatedView ()
-
-@property (nonatomic, strong) CAShapeLayer *ringAnimatedLayer;
-
-@end
-
-@implementation SVProgressAnimatedView
-
-- (void)willMoveToSuperview:(UIView*)newSuperview {
-    if (newSuperview) {
-        [self layoutAnimatedLayer];
-    } else {
-        [_ringAnimatedLayer removeFromSuperlayer];
-        _ringAnimatedLayer = nil;
-    }
-}
-
-- (void)layoutAnimatedLayer {
-    CALayer *layer = self.ringAnimatedLayer;
-    [self.layer addSublayer:layer];
-    
-    CGFloat widthDiff = CGRectGetWidth(self.bounds) - CGRectGetWidth(layer.bounds);
-    CGFloat heightDiff = CGRectGetHeight(self.bounds) - CGRectGetHeight(layer.bounds);
-    layer.position = CGPointMake(CGRectGetWidth(self.bounds) - CGRectGetWidth(layer.bounds) / 2 - widthDiff / 2, CGRectGetHeight(self.bounds) - CGRectGetHeight(layer.bounds) / 2 - heightDiff / 2);
-}
-
-- (CAShapeLayer*)ringAnimatedLayer {
-    if(!_ringAnimatedLayer) {
-        CGPoint arcCenter = CGPointMake(self.radius+self.strokeThickness/2+5, self.radius+self.strokeThickness/2+5);
-        UIBezierPath* smoothedPath = [UIBezierPath bezierPathWithArcCenter:arcCenter radius:self.radius startAngle:(CGFloat)-M_PI_2 endAngle:(CGFloat) (M_PI + M_PI_2) clockwise:YES];
-        
-        _ringAnimatedLayer = [CAShapeLayer layer];
-        _ringAnimatedLayer.contentsScale = [[UIScreen mainScreen] scale];
-        _ringAnimatedLayer.frame = CGRectMake(0.0f, 0.0f, arcCenter.x*2, arcCenter.y*2);
-        _ringAnimatedLayer.fillColor = [UIColor clearColor].CGColor;
-        _ringAnimatedLayer.strokeColor = self.strokeColor.CGColor;
-        _ringAnimatedLayer.lineWidth = self.strokeThickness;
-        _ringAnimatedLayer.lineCap = kCALineCapRound;
-        _ringAnimatedLayer.lineJoin = kCALineJoinBevel;
-        _ringAnimatedLayer.path = smoothedPath.CGPath;
-    }
-    return _ringAnimatedLayer;
-}
-
-- (void)setFrame:(CGRect)frame {
-    if(!CGRectEqualToRect(frame, super.frame)) {
-        [super setFrame:frame];
-        
-        if(self.superview) {
-            [self layoutAnimatedLayer];
-        }
-    }
-}
-
-- (void)setRadius:(CGFloat)radius {
-    if(radius != _radius) {
-        _radius = radius;
-        
-        [_ringAnimatedLayer removeFromSuperlayer];
-        _ringAnimatedLayer = nil;
-        
-        if(self.superview) {
-            [self layoutAnimatedLayer];
-        }
-    }
-}
-
-- (void)setStrokeColor:(UIColor*)strokeColor {
-    _strokeColor = strokeColor;
-    _ringAnimatedLayer.strokeColor = strokeColor.CGColor;
-}
-
-- (void)setStrokeThickness:(CGFloat)strokeThickness {
-    _strokeThickness = strokeThickness;
-    _ringAnimatedLayer.lineWidth = _strokeThickness;
-}
-
-- (void)setStrokeEnd:(CGFloat)strokeEnd {
-    _strokeEnd = strokeEnd;
-    _ringAnimatedLayer.strokeEnd = _strokeEnd;
-}
-
-- (CGSize)sizeThatFits:(CGSize)size {
-    return CGSizeMake((self.radius+self.strokeThickness/2+5)*2, (self.radius+self.strokeThickness/2+5)*2);
-}
-
-@end

WXDownloadingKit/SVProgressHUD/SVProgressHUD.h

-//
-//  SVProgressHUD.h
-//  SVProgressHUD, https://github.com/SVProgressHUD/SVProgressHUD
-//
-//  Copyright (c) 2011-2018 Sam Vermette and contributors. All rights reserved.
-//
-
-#import <UIKit/UIKit.h>
-#import <AvailabilityMacros.h>
-
-extern NSString * _Nonnull const SVProgressHUDDidReceiveTouchEventNotification;
-extern NSString * _Nonnull const SVProgressHUDDidTouchDownInsideNotification;
-extern NSString * _Nonnull const SVProgressHUDWillDisappearNotification;
-extern NSString * _Nonnull const SVProgressHUDDidDisappearNotification;
-extern NSString * _Nonnull const SVProgressHUDWillAppearNotification;
-extern NSString * _Nonnull const SVProgressHUDDidAppearNotification;
-
-extern NSString * _Nonnull const SVProgressHUDStatusUserInfoKey;
-
-typedef NS_ENUM(NSInteger, SVProgressHUDStyle) {
-    SVProgressHUDStyleLight,        // default style, white HUD with black text, HUD background will be blurred
-    SVProgressHUDStyleDark,         // black HUD and white text, HUD background will be blurred
-    SVProgressHUDStyleCustom        // uses the fore- and background color properties
-};
-
-typedef NS_ENUM(NSUInteger, SVProgressHUDMaskType) {
-    SVProgressHUDMaskTypeNone = 1,  // default mask type, allow user interactions while HUD is displayed
-    SVProgressHUDMaskTypeClear,     // don't allow user interactions with background objects
-    SVProgressHUDMaskTypeBlack,     // don't allow user interactions with background objects and dim the UI in the back of the HUD (as seen in iOS 7 and above)
-    SVProgressHUDMaskTypeGradient,  // don't allow user interactions with background objects and dim the UI with a a-la UIAlertView background gradient (as seen in iOS 6)
-    SVProgressHUDMaskTypeCustom     // don't allow user interactions with background objects and dim the UI in the back of the HUD with a custom color
-};
-
-typedef NS_ENUM(NSUInteger, SVProgressHUDAnimationType) {
-    SVProgressHUDAnimationTypeFlat,     // default animation type, custom flat animation (indefinite animated ring)
-    SVProgressHUDAnimationTypeNative    // iOS native UIActivityIndicatorView
-};
-
-typedef void (^SVProgressHUDShowCompletion)(void);
-typedef void (^SVProgressHUDDismissCompletion)(void);
-
-@interface SVProgressHUD : UIView
-
-#pragma mark - Customization
-
-@property (assign, nonatomic) SVProgressHUDStyle defaultStyle UI_APPEARANCE_SELECTOR;                   // default is SVProgressHUDStyleLight
-@property (assign, nonatomic) SVProgressHUDMaskType defaultMaskType UI_APPEARANCE_SELECTOR;             // default is SVProgressHUDMaskTypeNone
-@property (assign, nonatomic) SVProgressHUDAnimationType defaultAnimationType UI_APPEARANCE_SELECTOR;   // default is SVProgressHUDAnimationTypeFlat
-@property (strong, nonatomic, nullable) UIView *containerView;                              // if nil then use default window level
-@property (assign, nonatomic) CGSize minimumSize UI_APPEARANCE_SELECTOR;                    // default is CGSizeZero, can be used to avoid resizing for a larger message
-@property (assign, nonatomic) CGFloat ringThickness UI_APPEARANCE_SELECTOR;                 // default is 2 pt
-@property (assign, nonatomic) CGFloat ringRadius UI_APPEARANCE_SELECTOR;                    // default is 18 pt
-@property (assign, nonatomic) CGFloat ringNoTextRadius UI_APPEARANCE_SELECTOR;              // default is 24 pt
-@property (assign, nonatomic) CGFloat cornerRadius UI_APPEARANCE_SELECTOR;                  // default is 14 pt
-@property (strong, nonatomic, nonnull) UIFont *font UI_APPEARANCE_SELECTOR;                 // default is [UIFont preferredFontForTextStyle:UIFontTextStyleSubheadline]
-@property (strong, nonatomic, nonnull) UIColor *backgroundColor UI_APPEARANCE_SELECTOR;     // default is [UIColor whiteColor]
-@property (strong, nonatomic, nonnull) UIColor *foregroundColor UI_APPEARANCE_SELECTOR;     // default is [UIColor blackColor]
-@property (strong, nonatomic, nonnull) UIColor *backgroundLayerColor UI_APPEARANCE_SELECTOR;// default is [UIColor colorWithWhite:0 alpha:0.4]
-@property (assign, nonatomic) CGSize imageViewSize UI_APPEARANCE_SELECTOR;                  // default is 28x28 pt
-@property (assign, nonatomic) BOOL shouldTintImages UI_APPEARANCE_SELECTOR;                 // default is YES
-@property (strong, nonatomic, nonnull) UIImage *infoImage UI_APPEARANCE_SELECTOR;           // default is the bundled info image provided by Freepik
-@property (strong, nonatomic, nonnull) UIImage *successImage UI_APPEARANCE_SELECTOR;        // default is the bundled success image provided by Freepik
-@property (strong, nonatomic, nonnull) UIImage *errorImage UI_APPEARANCE_SELECTOR;          // default is the bundled error image provided by Freepik
-@property (strong, nonatomic, nonnull) UIView *viewForExtension UI_APPEARANCE_SELECTOR;     // default is nil, only used if #define SV_APP_EXTENSIONS is set
-@property (assign, nonatomic) NSTimeInterval graceTimeInterval;                             // default is 0 seconds
-@property (assign, nonatomic) NSTimeInterval minimumDismissTimeInterval;                    // default is 5.0 seconds
-@property (assign, nonatomic) NSTimeInterval maximumDismissTimeInterval;                    // default is CGFLOAT_MAX
-
-@property (assign, nonatomic) UIOffset offsetFromCenter UI_APPEARANCE_SELECTOR; // default is 0, 0
-
-@property (assign, nonatomic) NSTimeInterval fadeInAnimationDuration UI_APPEARANCE_SELECTOR;    // default is 0.15
-@property (assign, nonatomic) NSTimeInterval fadeOutAnimationDuration UI_APPEARANCE_SELECTOR;   // default is 0.15
-
-@property (assign, nonatomic) UIWindowLevel maxSupportedWindowLevel; // default is UIWindowLevelNormal
-
-@property (assign, nonatomic) BOOL hapticsEnabled;	// default is NO
-
-+ (void)setDefaultStyle:(SVProgressHUDStyle)style;                  // default is SVProgressHUDStyleLight
-+ (void)setDefaultMaskType:(SVProgressHUDMaskType)maskType;         // default is SVProgressHUDMaskTypeNone
-+ (void)setDefaultAnimationType:(SVProgressHUDAnimationType)type;   // default is SVProgressHUDAnimationTypeFlat
-+ (void)setContainerView:(nullable UIView*)containerView;           // default is window level
-+ (void)setMinimumSize:(CGSize)minimumSize;                         // default is CGSizeZero, can be used to avoid resizing for a larger message
-+ (void)setRingThickness:(CGFloat)ringThickness;                    // default is 2 pt
-+ (void)setRingRadius:(CGFloat)radius;                              // default is 18 pt
-+ (void)setRingNoTextRadius:(CGFloat)radius;                        // default is 24 pt
-+ (void)setCornerRadius:(CGFloat)cornerRadius;                      // default is 14 pt
-+ (void)setBorderColor:(nonnull UIColor*)color;                     // default is nil
-+ (void)setBorderWidth:(CGFloat)width;                              // default is 0
-+ (void)setFont:(nonnull UIFont*)font;                              // default is [UIFont preferredFontForTextStyle:UIFontTextStyleSubheadline]
-+ (void)setForegroundColor:(nonnull UIColor*)color;                 // default is [UIColor blackColor], only used for SVProgressHUDStyleCustom
-+ (void)setBackgroundColor:(nonnull UIColor*)color;                 // default is [UIColor whiteColor], only used for SVProgressHUDStyleCustom
-+ (void)setBackgroundLayerColor:(nonnull UIColor*)color;            // default is [UIColor colorWithWhite:0 alpha:0.5], only used for SVProgressHUDMaskTypeCustom
-+ (void)setImageViewSize:(CGSize)size;                              // default is 28x28 pt
-+ (void)setShouldTintImages:(BOOL)shouldTintImages;                 // default is YES
-+ (void)setInfoImage:(nonnull UIImage*)image;                       // default is the bundled info image provided by Freepik
-+ (void)setSuccessImage:(nonnull UIImage*)image;                    // default is the bundled success image provided by Freepik
-+ (void)setErrorImage:(nonnull UIImage*)image;                      // default is the bundled error image provided by Freepik
-+ (void)setViewForExtension:(nonnull UIView*)view;                  // default is nil, only used if #define SV_APP_EXTENSIONS is set
-+ (void)setGraceTimeInterval:(NSTimeInterval)interval;              // default is 0 seconds
-+ (void)setMinimumDismissTimeInterval:(NSTimeInterval)interval;     // default is 5.0 seconds
-+ (void)setMaximumDismissTimeInterval:(NSTimeInterval)interval;     // default is infinite
-+ (void)setFadeInAnimationDuration:(NSTimeInterval)duration;        // default is 0.15 seconds
-+ (void)setFadeOutAnimationDuration:(NSTimeInterval)duration;       // default is 0.15 seconds
-+ (void)setMaxSupportedWindowLevel:(UIWindowLevel)windowLevel;      // default is UIWindowLevelNormal
-+ (void)setHapticsEnabled:(BOOL)hapticsEnabled;						// default is NO
-
-#pragma mark - Show Methods
-
-+ (void)show;
-+ (void)showWithMaskType:(SVProgressHUDMaskType)maskType __attribute__((deprecated("Use show and setDefaultMaskType: instead.")));
-+ (void)showWithStatus:(nullable NSString*)status;
-+ (void)showWithStatus:(nullable NSString*)status maskType:(SVProgressHUDMaskType)maskType __attribute__((deprecated("Use showWithStatus: and setDefaultMaskType: instead.")));
-
-+ (void)showProgress:(float)progress;
-+ (void)showProgress:(float)progress maskType:(SVProgressHUDMaskType)maskType __attribute__((deprecated("Use showProgress: and setDefaultMaskType: instead.")));
-+ (void)showProgress:(float)progress status:(nullable NSString*)status;
-+ (void)showProgress:(float)progress status:(nullable NSString*)status maskType:(SVProgressHUDMaskType)maskType __attribute__((deprecated("Use showProgress:status: and setDefaultMaskType: instead.")));
-
-+ (void)setStatus:(nullable NSString*)status; // change the HUD loading status while it's showing
-
-// stops the activity indicator, shows a glyph + status, and dismisses the HUD a little bit later
-+ (void)showInfoWithStatus:(nullable NSString*)status;
-+ (void)showInfoWithStatus:(nullable NSString*)status maskType:(SVProgressHUDMaskType)maskType __attribute__((deprecated("Use showInfoWithStatus: and setDefaultMaskType: instead.")));
-+ (void)showSuccessWithStatus:(nullable NSString*)status;
-+ (void)showSuccessWithStatus:(nullable NSString*)status maskType:(SVProgressHUDMaskType)maskType __attribute__((deprecated("Use showSuccessWithStatus: and setDefaultMaskType: instead.")));
-+ (void)showErrorWithStatus:(nullable NSString*)status;
-+ (void)showErrorWithStatus:(nullable NSString*)status maskType:(SVProgressHUDMaskType)maskType __attribute__((deprecated("Use showErrorWithStatus: and setDefaultMaskType: instead.")));
-
-// shows a image + status, use white PNGs with the imageViewSize (default is 28x28 pt)
-+ (void)showImage:(nonnull UIImage*)image status:(nullable NSString*)status;
-+ (void)showImage:(nonnull UIImage*)image status:(nullable NSString*)status maskType:(SVProgressHUDMaskType)maskType __attribute__((deprecated("Use showImage:status: and setDefaultMaskType: instead.")));
-
-+ (void)setOffsetFromCenter:(UIOffset)offset;
-+ (void)resetOffsetFromCenter;
-
-+ (void)popActivity; // decrease activity count, if activity count == 0 the HUD is dismissed
-+ (void)dismiss;
-+ (void)dismissWithCompletion:(nullable SVProgressHUDDismissCompletion)completion;
-+ (void)dismissWithDelay:(NSTimeInterval)delay;
-+ (void)dismissWithDelay:(NSTimeInterval)delay completion:(nullable SVProgressHUDDismissCompletion)completion;
-
-+ (BOOL)isVisible;
-
-+ (NSTimeInterval)displayDurationForString:(nullable NSString*)string;
-
-@end
-

WXDownloadingKit/SVProgressHUD/SVProgressHUD.m

-//
-//  SVProgressHUD.h
-//  SVProgressHUD, https://github.com/SVProgressHUD/SVProgressHUD
-//
-//  Copyright (c) 2011-2018 Sam Vermette and contributors. All rights reserved.
-//
-
-#if !__has_feature(objc_arc)
-#error SVProgressHUD is ARC only. Either turn on ARC for the project or use -fobjc-arc flag
-#endif
-
-#import "SVProgressHUD.h"
-#import "SVIndefiniteAnimatedView.h"
-#import "SVProgressAnimatedView.h"
-#import "SVRadialGradientLayer.h"
-
-NSString * const SVProgressHUDDidReceiveTouchEventNotification = @"SVProgressHUDDidReceiveTouchEventNotification";
-NSString * const SVProgressHUDDidTouchDownInsideNotification = @"SVProgressHUDDidTouchDownInsideNotification";
-NSString * const SVProgressHUDWillDisappearNotification = @"SVProgressHUDWillDisappearNotification";
-NSString * const SVProgressHUDDidDisappearNotification = @"SVProgressHUDDidDisappearNotification";
-NSString * const SVProgressHUDWillAppearNotification = @"SVProgressHUDWillAppearNotification";
-NSString * const SVProgressHUDDidAppearNotification = @"SVProgressHUDDidAppearNotification";
-
-NSString * const SVProgressHUDStatusUserInfoKey = @"SVProgressHUDStatusUserInfoKey";
-
-static const CGFloat SVProgressHUDParallaxDepthPoints = 10.0f;
-static const CGFloat SVProgressHUDUndefinedProgress = -1;
-static const CGFloat SVProgressHUDDefaultAnimationDuration = 0.15f;
-static const CGFloat SVProgressHUDVerticalSpacing = 12.0f;
-static const CGFloat SVProgressHUDHorizontalSpacing = 12.0f;
-static const CGFloat SVProgressHUDLabelSpacing = 8.0f;
-
-
-@interface SVProgressHUD ()
-
-@property (nonatomic, strong) NSTimer *graceTimer;
-@property (nonatomic, strong) NSTimer *fadeOutTimer;
-
-@property (nonatomic, strong) UIControl *controlView;
-@property (nonatomic, strong) UIView *backgroundView;
-@property (nonatomic, strong) SVRadialGradientLayer *backgroundRadialGradientLayer;
-@property (nonatomic, strong) UIVisualEffectView *hudView;
-@property (nonatomic, strong) UILabel *statusLabel;
-@property (nonatomic, strong) UIImageView *imageView;
-
-@property (nonatomic, strong) UIView *indefiniteAnimatedView;
-@property (nonatomic, strong) SVProgressAnimatedView *ringView;
-@property (nonatomic, strong) SVProgressAnimatedView *backgroundRingView;
-
-@property (nonatomic, readwrite) CGFloat progress;
-@property (nonatomic, readwrite) NSUInteger activityCount;
-
-@property (nonatomic, readonly) CGFloat visibleKeyboardHeight;
-@property (nonatomic, readonly) UIWindow *frontWindow;
-
-#if TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
-@property (nonatomic, strong) UINotificationFeedbackGenerator *hapticGenerator NS_AVAILABLE_IOS(10_0);
-#endif
-
-@end
-
-@implementation SVProgressHUD {
-    BOOL _isInitializing;
-}
-
-+ (SVProgressHUD*)sharedView {
-    static dispatch_once_t once;
-    
-    static SVProgressHUD *sharedView;
-#if !defined(SV_APP_EXTENSIONS)
-    dispatch_once(&once, ^{ sharedView = [[self alloc] initWithFrame:[[[UIApplication sharedApplication] delegate] window].bounds]; });
-#else
-    dispatch_once(&once, ^{ sharedView = [[self alloc] initWithFrame:[[UIScreen mainScreen] bounds]]; });
-#endif
-    return sharedView;
-}
-
-
-#pragma mark - Setters
-
-+ (void)setStatus:(NSString*)status {
-    [[self sharedView] setStatus:status];
-}
-
-+ (void)setDefaultStyle:(SVProgressHUDStyle)style {
-    [self sharedView].defaultStyle = style;
-}
-
-+ (void)setDefaultMaskType:(SVProgressHUDMaskType)maskType {
-    [self sharedView].defaultMaskType = maskType;
-}
-
-+ (void)setDefaultAnimationType:(SVProgressHUDAnimationType)type {
-    [self sharedView].defaultAnimationType = type;
-}
-
-+ (void)setContainerView:(nullable UIView*)containerView {
-    [self sharedView].containerView = containerView;
-}
-
-+ (void)setMinimumSize:(CGSize)minimumSize {
-    [self sharedView].minimumSize = minimumSize;
-}
-
-+ (void)setRingThickness:(CGFloat)ringThickness {
-    [self sharedView].ringThickness = ringThickness;
-}
-
-+ (void)setRingRadius:(CGFloat)radius {
-    [self sharedView].ringRadius = radius;
-}
-
-+ (void)setRingNoTextRadius:(CGFloat)radius {
-    [self sharedView].ringNoTextRadius = radius;
-}
-
-+ (void)setCornerRadius:(CGFloat)cornerRadius {
-    [self sharedView].cornerRadius = cornerRadius;
-}
-
-+ (void)setBorderColor:(nonnull UIColor*)color {
-    [self sharedView].hudView.layer.borderColor = color.CGColor;
-}
-
-+ (void)setBorderWidth:(CGFloat)width {
-    [self sharedView].hudView.layer.borderWidth = width;
-}
-
-+ (void)setFont:(UIFont*)font {
-    [self sharedView].font = font;
-}
-
-+ (void)setForegroundColor:(UIColor*)color {
-    [self sharedView].foregroundColor = color;
-    [self setDefaultStyle:SVProgressHUDStyleCustom];
-}
-
-+ (void)setBackgroundColor:(UIColor*)color {
-    [self sharedView].backgroundColor = color;
-    [self setDefaultStyle:SVProgressHUDStyleCustom];
-}
-
-+ (void)setBackgroundLayerColor:(UIColor*)color {
-    [self sharedView].backgroundLayerColor = color;
-}
-
-+ (void)setImageViewSize:(CGSize)size {
-    [self sharedView].imageViewSize = size;
-}
-
-+ (void)setShouldTintImages:(BOOL)shouldTintImages {
-    [self sharedView].shouldTintImages = shouldTintImages;
-}
-
-+ (void)setInfoImage:(UIImage*)image {
-    [self sharedView].infoImage = image;
-}
-
-+ (void)setSuccessImage:(UIImage*)image {
-    [self sharedView].successImage = image;
-}
-
-+ (void)setErrorImage:(UIImage*)image {
-    [self sharedView].errorImage = image;
-}
-
-+ (void)setViewForExtension:(UIView*)view {
-    [self sharedView].viewForExtension = view;
-}
-
-+ (void)setGraceTimeInterval:(NSTimeInterval)interval {
-    [self sharedView].graceTimeInterval = interval;
-}
-
-+ (void)setMinimumDismissTimeInterval:(NSTimeInterval)interval {
-    [self sharedView].minimumDismissTimeInterval = interval;
-}
-
-+ (void)setMaximumDismissTimeInterval:(NSTimeInterval)interval {
-    [self sharedView].maximumDismissTimeInterval = interval;
-}
-
-+ (void)setFadeInAnimationDuration:(NSTimeInterval)duration {
-    [self sharedView].fadeInAnimationDuration = duration;
-}
-
-+ (void)setFadeOutAnimationDuration:(NSTimeInterval)duration {
-    [self sharedView].fadeOutAnimationDuration = duration;
-}
-
-+ (void)setMaxSupportedWindowLevel:(UIWindowLevel)windowLevel {
-    [self sharedView].maxSupportedWindowLevel = windowLevel;
-}
-
-+ (void)setHapticsEnabled:(BOOL)hapticsEnabled {
-    [self sharedView].hapticsEnabled = hapticsEnabled;
-}
-
-#pragma mark - Show Methods
-
-+ (void)show {
-    [self showWithStatus:nil];
-}
-
-+ (void)showWithMaskType:(SVProgressHUDMaskType)maskType {
-    SVProgressHUDMaskType existingMaskType = [self sharedView].defaultMaskType;
-    [self setDefaultMaskType:maskType];
-    [self show];
-    [self setDefaultMaskType:existingMaskType];
-}
-
-+ (void)showWithStatus:(NSString*)status {
-    [self showProgress:SVProgressHUDUndefinedProgress status:status];
-}
-
-+ (void)showWithStatus:(NSString*)status maskType:(SVProgressHUDMaskType)maskType {
-    SVProgressHUDMaskType existingMaskType = [self sharedView].defaultMaskType;
-    [self setDefaultMaskType:maskType];
-    [self showWithStatus:status];
-    [self setDefaultMaskType:existingMaskType];
-}
-
-+ (void)showProgress:(float)progress {
-    [self showProgress:progress status:nil];
-}
-
-+ (void)showProgress:(float)progress maskType:(SVProgressHUDMaskType)maskType {
-    SVProgressHUDMaskType existingMaskType = [self sharedView].defaultMaskType;
-    [self setDefaultMaskType:maskType];
-    [self showProgress:progress];
-    [self setDefaultMaskType:existingMaskType];
-}
-
-+ (void)showProgress:(float)progress status:(NSString*)status {
-    [[self sharedView] showProgress:progress status:status];
-}
-
-+ (void)showProgress:(float)progress status:(NSString*)status maskType:(SVProgressHUDMaskType)maskType {
-    SVProgressHUDMaskType existingMaskType = [self sharedView].defaultMaskType;
-    [self setDefaultMaskType:maskType];
-    [self showProgress:progress status:status];
-    [self setDefaultMaskType:existingMaskType];
-}
-
-
-#pragma mark - Show, then automatically dismiss methods
-
-+ (void)showInfoWithStatus:(NSString*)status {
-    [self showImage:[self sharedView].infoImage status:status];
-    
-#if TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
-    if (@available(iOS 10.0, *)) {
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [[self sharedView].hapticGenerator notificationOccurred:UINotificationFeedbackTypeWarning];
-        });
-    }
-#endif
-}
-
-+ (void)showInfoWithStatus:(NSString*)status maskType:(SVProgressHUDMaskType)maskType {
-    SVProgressHUDMaskType existingMaskType = [self sharedView].defaultMaskType;
-    [self setDefaultMaskType:maskType];
-    [self showInfoWithStatus:status];
-    [self setDefaultMaskType:existingMaskType];
-}
-
-+ (void)showSuccessWithStatus:(NSString*)status {
-    [self showImage:[self sharedView].successImage status:status];
-
-#if TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
-    if (@available(iOS 10, *)) {
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [[self sharedView].hapticGenerator notificationOccurred:UINotificationFeedbackTypeSuccess];
-        });
-    }
-#endif
-}
-
-+ (void)showSuccessWithStatus:(NSString*)status maskType:(SVProgressHUDMaskType)maskType {
-    SVProgressHUDMaskType existingMaskType = [self sharedView].defaultMaskType;
-    [self setDefaultMaskType:maskType];
-    [self showSuccessWithStatus:status];
-    [self setDefaultMaskType:existingMaskType];
-    
-#if TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
-    if (@available(iOS 10.0, *)) {
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [[self sharedView].hapticGenerator notificationOccurred:UINotificationFeedbackTypeSuccess];
-        });
-    }
-#endif
-}
-
-+ (void)showErrorWithStatus:(NSString*)status {
-    [self showImage:[self sharedView].errorImage status:status];
-    
-#if TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
-    if (@available(iOS 10.0, *)) {
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [[self sharedView].hapticGenerator notificationOccurred:UINotificationFeedbackTypeError];
-        });
-    }
-#endif
-}
-
-+ (void)showErrorWithStatus:(NSString*)status maskType:(SVProgressHUDMaskType)maskType {
-    SVProgressHUDMaskType existingMaskType = [self sharedView].defaultMaskType;
-    [self setDefaultMaskType:maskType];
-    [self showErrorWithStatus:status];
-    [self setDefaultMaskType:existingMaskType];
-    
-#if TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
-    if (@available(iOS 10.0, *)) {
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [[self sharedView].hapticGenerator notificationOccurred:UINotificationFeedbackTypeError];
-        });
-    }
-#endif
-}
-
-+ (void)showImage:(UIImage*)image status:(NSString*)status {
-    NSTimeInterval displayInterval = [self displayDurationForString:status];
-    [[self sharedView] showImage:image status:status duration:displayInterval];
-}
-
-+ (void)showImage:(UIImage*)image status:(NSString*)status maskType:(SVProgressHUDMaskType)maskType {
-    SVProgressHUDMaskType existingMaskType = [self sharedView].defaultMaskType;
-    [self setDefaultMaskType:maskType];
-    [self showImage:image status:status];
-    [self setDefaultMaskType:existingMaskType];
-}
-
-
-#pragma mark - Dismiss Methods
-
-+ (void)popActivity {
-    if([self sharedView].activityCount > 0) {
-        [self sharedView].activityCount--;
-    }
-    if([self sharedView].activityCount == 0) {
-        [[self sharedView] dismiss];
-    }
-}
-
-+ (void)dismiss {
-    [self dismissWithDelay:0.0 completion:nil];
-}
-
-+ (void)dismissWithCompletion:(SVProgressHUDDismissCompletion)completion {
-    [self dismissWithDelay:0.0 completion:completion];
-}
-
-+ (void)dismissWithDelay:(NSTimeInterval)delay {
-    [self dismissWithDelay:delay completion:nil];
-}
-
-+ (void)dismissWithDelay:(NSTimeInterval)delay completion:(SVProgressHUDDismissCompletion)completion {
-    [[self sharedView] dismissWithDelay:delay completion:completion];
-}
-
-
-#pragma mark - Offset
-
-+ (void)setOffsetFromCenter:(UIOffset)offset {
-    [self sharedView].offsetFromCenter = offset;
-}
-
-+ (void)resetOffsetFromCenter {
-    [self setOffsetFromCenter:UIOffsetZero];
-}
-
-
-#pragma mark - Instance Methods
-
-- (instancetype)initWithFrame:(CGRect)frame {
-    if((self = [super initWithFrame:frame])) {
-        _isInitializing = YES;
-        
-        self.userInteractionEnabled = NO;
-        self.activityCount = 0;
-        
-        self.backgroundView.alpha = 0.0f;
-        self.imageView.alpha = 0.0f;
-        self.statusLabel.alpha = 0.0f;
-        self.indefiniteAnimatedView.alpha = 0.0f;
-        self.ringView.alpha = self.backgroundRingView.alpha = 0.0f;
-        
-
-        _backgroundColor = [UIColor whiteColor];
-        _foregroundColor = [UIColor blackColor];
-        _backgroundLayerColor = [UIColor colorWithWhite:0 alpha:0.4];
-        
-        // Set default values
-        _defaultMaskType = SVProgressHUDMaskTypeNone;
-        _defaultStyle = SVProgressHUDStyleLight;
-        _defaultAnimationType = SVProgressHUDAnimationTypeFlat;
-        _minimumSize = CGSizeZero;
-        _font = [UIFont preferredFontForTextStyle:UIFontTextStyleSubheadline];
-        
-        _imageViewSize = CGSizeMake(28.0f, 28.0f);
-        _shouldTintImages = YES;
-        
-        NSBundle *bundle = [NSBundle bundleForClass:[SVProgressHUD class]];
-        NSURL *url = [bundle URLForResource:@"SVProgressHUD" withExtension:@"bundle"];
-        NSBundle *imageBundle = [NSBundle bundleWithURL:url];
-        
-        _infoImage = [UIImage imageWithContentsOfFile:[imageBundle pathForResource:@"info" ofType:@"png"]];
-        _successImage = [UIImage imageWithContentsOfFile:[imageBundle pathForResource:@"success" ofType:@"png"]];
-        _errorImage = [UIImage imageWithContentsOfFile:[imageBundle pathForResource:@"error" ofType:@"png"]];
-
-        _ringThickness = 2.0f;
-        _ringRadius = 18.0f;
-        _ringNoTextRadius = 24.0f;
-        
-        _cornerRadius = 14.0f;
-		
-        _graceTimeInterval = 0.0f;
-        _minimumDismissTimeInterval = 5.0;
-        _maximumDismissTimeInterval = CGFLOAT_MAX;
-
-        _fadeInAnimationDuration = SVProgressHUDDefaultAnimationDuration;
-        _fadeOutAnimationDuration = SVProgressHUDDefaultAnimationDuration;
-        
-        _maxSupportedWindowLevel = UIWindowLevelNormal;
-        
-        _hapticsEnabled = NO;
-        
-        // Accessibility support
-        self.accessibilityIdentifier = @"SVProgressHUD";
-        self.isAccessibilityElement = YES;
-        
-        _isInitializing = NO;
-    }
-    return self;
-}
-
-- (void)updateHUDFrame {
-    // Check if an image or progress ring is displayed
-    BOOL imageUsed = (self.imageView.image) && !(self.imageView.hidden);
-    BOOL progressUsed = self.imageView.hidden;
-    
-    // Calculate size of string
-    CGRect labelRect = CGRectZero;
-    CGFloat labelHeight = 0.0f;
-    CGFloat labelWidth = 0.0f;
-    
-    if(self.statusLabel.text) {
-        CGSize constraintSize = CGSizeMake(200.0f, 300.0f);
-        labelRect = [self.statusLabel.text boundingRectWithSize:constraintSize
-                                                        options:(NSStringDrawingOptions)(NSStringDrawingUsesFontLeading | NSStringDrawingTruncatesLastVisibleLine | NSStringDrawingUsesLineFragmentOrigin)
-                                                     attributes:@{NSFontAttributeName: self.statusLabel.font}
-                                                        context:NULL];
-        labelHeight = ceilf(CGRectGetHeight(labelRect));
-        labelWidth = ceilf(CGRectGetWidth(labelRect));
-    }
-    
-    // Calculate hud size based on content
-    // For the beginning use default values, these
-    // might get update if string is too large etc.
-    CGFloat hudWidth;
-    CGFloat hudHeight;
-    
-    CGFloat contentWidth = 0.0f;
-    CGFloat contentHeight = 0.0f;
-    
-    if(imageUsed || progressUsed) {
-        contentWidth = CGRectGetWidth(imageUsed ? self.imageView.frame : self.indefiniteAnimatedView.frame);
-        contentHeight = CGRectGetHeight(imageUsed ? self.imageView.frame : self.indefiniteAnimatedView.frame);
-    }
-    
-    // |-spacing-content-spacing-|
-    hudWidth = SVProgressHUDHorizontalSpacing + MAX(labelWidth, contentWidth) + SVProgressHUDHorizontalSpacing;
-    
-    // |-spacing-content-(labelSpacing-label-)spacing-|
-    hudHeight = SVProgressHUDVerticalSpacing + labelHeight + contentHeight + SVProgressHUDVerticalSpacing;
-    if(self.statusLabel.text && (imageUsed || progressUsed)){
-        // Add spacing if both content and label are used
-        hudHeight += SVProgressHUDLabelSpacing;
-    }
-    
-    // Update values on subviews
-    self.hudView.bounds = CGRectMake(0.0f, 0.0f, MAX(self.minimumSize.width, hudWidth), MAX(self.minimumSize.height, hudHeight));
-    
-    // Animate value update
-    [CATransaction begin];
-    [CATransaction setDisableActions:YES];
-    
-    // Spinner and image view
-    CGFloat centerY;
-    if(self.statusLabel.text) {
-        CGFloat yOffset = MAX(SVProgressHUDVerticalSpacing, (self.minimumSize.height - contentHeight - SVProgressHUDLabelSpacing - labelHeight) / 2.0f);
-        centerY = yOffset + contentHeight / 2.0f;
-    } else {
-        centerY = CGRectGetMidY(self.hudView.bounds);
-    }
-    self.indefiniteAnimatedView.center = CGPointMake(CGRectGetMidX(self.hudView.bounds), centerY);
-    if(self.progress != SVProgressHUDUndefinedProgress) {
-        self.backgroundRingView.center = self.ringView.center = CGPointMake(CGRectGetMidX(self.hudView.bounds), centerY);
-    }
-    self.imageView.center = CGPointMake(CGRectGetMidX(self.hudView.bounds), centerY);
-
-    // Label
-    if(imageUsed || progressUsed) {
-        centerY = CGRectGetMaxY(imageUsed ? self.imageView.frame : self.indefiniteAnimatedView.frame) + SVProgressHUDLabelSpacing + labelHeight / 2.0f;
-    } else {
-        centerY = CGRectGetMidY(self.hudView.bounds);
-    }
-    self.statusLabel.frame = labelRect;
-    self.statusLabel.center = CGPointMake(CGRectGetMidX(self.hudView.bounds), centerY);
-    
-    [CATransaction commit];
-}
-
-#if TARGET_OS_IOS
-- (void)updateMotionEffectForOrientation:(UIInterfaceOrientation)orientation {
-    UIInterpolatingMotionEffectType xMotionEffectType = UIInterfaceOrientationIsPortrait(orientation) ? UIInterpolatingMotionEffectTypeTiltAlongHorizontalAxis : UIInterpolatingMotionEffectTypeTiltAlongVerticalAxis;
-    UIInterpolatingMotionEffectType yMotionEffectType = UIInterfaceOrientationIsPortrait(orientation) ? UIInterpolatingMotionEffectTypeTiltAlongVerticalAxis : UIInterpolatingMotionEffectTypeTiltAlongHorizontalAxis;
-    [self updateMotionEffectForXMotionEffectType:xMotionEffectType yMotionEffectType:yMotionEffectType];
-}
-#endif
-
-- (void)updateMotionEffectForXMotionEffectType:(UIInterpolatingMotionEffectType)xMotionEffectType yMotionEffectType:(UIInterpolatingMotionEffectType)yMotionEffectType {
-    UIInterpolatingMotionEffect *effectX = [[UIInterpolatingMotionEffect alloc] initWithKeyPath:@"center.x" type:xMotionEffectType];
-    effectX.minimumRelativeValue = @(-SVProgressHUDParallaxDepthPoints);
-    effectX.maximumRelativeValue = @(SVProgressHUDParallaxDepthPoints);
-    
-    UIInterpolatingMotionEffect *effectY = [[UIInterpolatingMotionEffect alloc] initWithKeyPath:@"center.y" type:yMotionEffectType];
-    effectY.minimumRelativeValue = @(-SVProgressHUDParallaxDepthPoints);
-    effectY.maximumRelativeValue = @(SVProgressHUDParallaxDepthPoints);
-    
-    UIMotionEffectGroup *effectGroup = [UIMotionEffectGroup new];
-    effectGroup.motionEffects = @[effectX, effectY];
-    
-    // Clear old motion effect, then add new motion effects
-    self.hudView.motionEffects = @[];
-    [self.hudView addMotionEffect:effectGroup];
-}
-
-- (void)updateViewHierarchy {
-    // Add the overlay to the application window if necessary
-    if(!self.controlView.superview) {
-        if(self.containerView){
-            [self.containerView addSubview:self.controlView];
-        } else {
-#if !defined(SV_APP_EXTENSIONS)
-            [self.frontWindow addSubview:self.controlView];
-#else
-            // If SVProgressHUD is used inside an app extension add it to the given view
-            if(self.viewForExtension) {
-                [self.viewForExtension addSubview:self.controlView];
-            }
-#endif
-        }
-    } else {
-        // The HUD is already on screen, but maybe not in front. Therefore
-        // ensure that overlay will be on top of rootViewController (which may
-        // be changed during runtime).
-        [self.controlView.superview bringSubviewToFront:self.controlView];
-    }
-    
-    // Add self to the overlay view
-    if(!self.superview) {
-        [self.controlView addSubview:self];
-    }
-}
-
-- (void)setStatus:(NSString*)status {
-    self.statusLabel.text = status;
-    self.statusLabel.hidden = status.length == 0;
-    [self updateHUDFrame];
-}
-
-- (void)setGraceTimer:(NSTimer*)timer {
-    if(_graceTimer) {
-        [_graceTimer invalidate];
-        _graceTimer = nil;
-    }
-    if(timer) {
-        _graceTimer = timer;
-    }
-}
-
-- (void)setFadeOutTimer:(NSTimer*)timer {
-    if(_fadeOutTimer) {
-        [_fadeOutTimer invalidate];
-        _fadeOutTimer = nil;
-    }
-    if(timer) {
-        _fadeOutTimer = timer;
-    }
-}
-
-
-#pragma mark - Notifications and their handling
-
-- (void)registerNotifications {
-#if TARGET_OS_IOS
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(positionHUD:)
-                                                 name:UIApplicationDidChangeStatusBarOrientationNotification
-                                               object:nil];
-    
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(positionHUD:)
-                                                 name:UIKeyboardWillHideNotification
-                                               object:nil];
-    
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(positionHUD:)
-                                                 name:UIKeyboardDidHideNotification
-                                               object:nil];
-    
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(positionHUD:)
-                                                 name:UIKeyboardWillShowNotification
-                                               object:nil];
-    
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(positionHUD:)
-                                                 name:UIKeyboardDidShowNotification
-                                               object:nil];
-#endif
-    [[NSNotificationCenter defaultCenter] addObserver:self
-                                             selector:@selector(positionHUD:)
-                                                 name:UIApplicationDidBecomeActiveNotification
-                                               object:nil];
-}
-
-- (NSDictionary*)notificationUserInfo {
-    return (self.statusLabel.text ? @{SVProgressHUDStatusUserInfoKey : self.statusLabel.text} : nil);
-}
-
-- (void)positionHUD:(NSNotification*)notification {
-    CGFloat keyboardHeight = 0.0f;
-    double animationDuration = 0.0;
-
-#if !defined(SV_APP_EXTENSIONS) && TARGET_OS_IOS
-    self.frame = [[[UIApplication sharedApplication] delegate] window].bounds;
-    UIInterfaceOrientation orientation = UIApplication.sharedApplication.statusBarOrientation;
-#elif !defined(SV_APP_EXTENSIONS) && !TARGET_OS_IOS
-    self.frame= [UIApplication sharedApplication].keyWindow.bounds;
-#else
-    if (self.viewForExtension) {
-        self.frame = self.viewForExtension.frame;
-    } else {
-        self.frame = UIScreen.mainScreen.bounds;
-    }
-#if TARGET_OS_IOS
-    UIInterfaceOrientation orientation = CGRectGetWidth(self.frame) > CGRectGetHeight(self.frame) ? UIInterfaceOrientationLandscapeLeft : UIInterfaceOrientationPortrait;
-#endif
-#endif
-    
-#if TARGET_OS_IOS
-    // Get keyboardHeight in regard to current state
-    if(notification) {
-        NSDictionary* keyboardInfo = [notification userInfo];
-        CGRect keyboardFrame = [keyboardInfo[UIKeyboardFrameBeginUserInfoKey] CGRectValue];
-        animationDuration = [keyboardInfo[UIKeyboardAnimationDurationUserInfoKey] doubleValue];
-        
-        if(notification.name == UIKeyboardWillShowNotification || notification.name == UIKeyboardDidShowNotification) {
-            keyboardHeight = CGRectGetWidth(keyboardFrame);
-            
-            if(UIInterfaceOrientationIsPortrait(orientation)) {
-                keyboardHeight = CGRectGetHeight(keyboardFrame);
-            }
-        }
-    } else {
-        keyboardHeight = self.visibleKeyboardHeight;
-    }
-#endif
-    
-    // Get the currently active frame of the display (depends on orientation)
-    CGRect orientationFrame = self.bounds;
-
-#if !defined(SV_APP_EXTENSIONS) && TARGET_OS_IOS
-    CGRect statusBarFrame = UIApplication.sharedApplication.statusBarFrame;
-#else
-    CGRect statusBarFrame = CGRectZero;
-#endif
-    
-#if TARGET_OS_IOS
-    // Update the motion effects in regard to orientation
-    [self updateMotionEffectForOrientation:orientation];
-#else
-    [self updateMotionEffectForXMotionEffectType:UIInterpolatingMotionEffectTypeTiltAlongHorizontalAxis yMotionEffectType:UIInterpolatingMotionEffectTypeTiltAlongHorizontalAxis];
-#endif
-    
-    // Calculate available height for display
-    CGFloat activeHeight = CGRectGetHeight(orientationFrame);
-    if(keyboardHeight > 0) {
-        activeHeight += CGRectGetHeight(statusBarFrame) * 2;
-    }
-    activeHeight -= keyboardHeight;
-    
-    CGFloat posX = CGRectGetMidX(orientationFrame);
-    CGFloat posY = floorf(activeHeight*0.45f);
-
-    CGFloat rotateAngle = 0.0;
-    CGPoint newCenter = CGPointMake(posX, posY);
-    
-    if(notification) {
-        // Animate update if notification was present
-        [UIView animateWithDuration:animationDuration
-                              delay:0
-                            options:(UIViewAnimationOptions) (UIViewAnimationOptionAllowUserInteraction | UIViewAnimationOptionBeginFromCurrentState)
-                         animations:^{
-                             [self moveToPoint:newCenter rotateAngle:rotateAngle];
-                             [self.hudView setNeedsDisplay];
-                         } completion:nil];
-    } else {
-        [self moveToPoint:newCenter rotateAngle:rotateAngle];
-    }
-}
-
-- (void)moveToPoint:(CGPoint)newCenter rotateAngle:(CGFloat)angle {
-    self.hudView.transform = CGAffineTransformMakeRotation(angle);
-    if (self.containerView) {
-        self.hudView.center = CGPointMake(self.containerView.center.x + self.offsetFromCenter.horizontal, self.containerView.center.y + self.offsetFromCenter.vertical);
-    } else {
-        self.hudView.center = CGPointMake(newCenter.x + self.offsetFromCenter.horizontal, newCenter.y + self.offsetFromCenter.vertical);
-    }
-    //不管上方代码，为了实现我们的需求，设置hudView的center在屏幕上部
-    if (self.progress == 0) {
-        self.hudView.center = CGPointMake([UIScreen mainScreen].bounds.size.width/2, -80);
-        
-        [UIView animateWithDuration:0.2 animations:^{
-            self.hudView.center = CGPointMake([UIScreen mainScreen].bounds.size.width/2, 80);
-        } completion:^(BOOL finished) {
-//            [self earthquake:self.hudView];//抖动效果(取消)
-        }];
-    }
-    
-}
-
--(void)earthquake:(UIView*)itemView
-{
-    CGFloat t = 2.0;
-    
-    CGAffineTransform startQuake  =CGAffineTransformTranslate(CGAffineTransformIdentity, 0,-t);
-    CGAffineTransform endQuake =CGAffineTransformTranslate(CGAffineTransformIdentity, 0, t);
-    
-    itemView.transform = startQuake;
-    
-    [UIView beginAnimations:@"earthquake" context:(__bridge void * _Nullable)(itemView)];
-    [UIView setAnimationRepeatAutoreverses:YES];
-    [UIView setAnimationRepeatCount:1];
-    [UIView setAnimationDuration:0.1];
-    [UIView setAnimationDelegate:self];
-    [UIView setAnimationDidStopSelector:@selector(earthquakeEnded:finished:context:)];
-    
-    itemView.transform = endQuake;
-    
-    [UIView commitAnimations];
-}
-
--(void)earthquakeEnded:(NSString*)animationID finished:(NSNumber*)finished context:(void*)context
-{
-    if([finished boolValue])
-    {
-        UIView* item =(__bridge UIView*)context;
-        item.transform =CGAffineTransformIdentity;
-    }
-}
-
-#pragma mark - Event handling
-
-- (void)controlViewDidReceiveTouchEvent:(id)sender forEvent:(UIEvent*)event {
-    [[NSNotificationCenter defaultCenter] postNotificationName:SVProgressHUDDidReceiveTouchEventNotification
-                                                        object:self
-                                                      userInfo:[self notificationUserInfo]];
-    
-    UITouch *touch = event.allTouches.anyObject;
-    CGPoint touchLocation = [touch locationInView:self];
-    
-    if(CGRectContainsPoint(self.hudView.frame, touchLocation)) {
-        [[NSNotificationCenter defaultCenter] postNotificationName:SVProgressHUDDidTouchDownInsideNotification
-                                                            object:self
-                                                          userInfo:[self notificationUserInfo]];
-    }
-}
-
-
-#pragma mark - Master show/dismiss methods
-
-- (void)showProgress:(float)progress status:(NSString*)status {
-    __weak SVProgressHUD *weakSelf = self;
-    [[NSOperationQueue mainQueue] addOperationWithBlock:^{
-        __strong SVProgressHUD *strongSelf = weakSelf;
-        if(strongSelf){
-            if(strongSelf.fadeOutTimer) {
-                strongSelf.activityCount = 0;
-            }
-            
-            // Stop timer
-            strongSelf.fadeOutTimer = nil;
-            strongSelf.graceTimer = nil;
-            
-            // Update / Check view hierarchy to ensure the HUD is visible
-            [strongSelf updateViewHierarchy];
-            
-            // Reset imageView and fadeout timer if an image is currently displayed
-            strongSelf.imageView.hidden = YES;
-            strongSelf.imageView.image = nil;
-            
-            // Update text and set progress to the given value
-            strongSelf.statusLabel.hidden = status.length == 0;
-            strongSelf.statusLabel.text = status;
-            strongSelf.progress = progress;
-            
-            // Choose the "right" indicator depending on the progress
-            if(progress >= 0) {
-                // Cancel the indefiniteAnimatedView, then show the ringLayer
-                [strongSelf cancelIndefiniteAnimatedViewAnimation];
-                
-                // Add ring to HUD
-                if(!strongSelf.ringView.superview){
-                    [strongSelf.hudView.contentView addSubview:strongSelf.ringView];
-                }
-                if(!strongSelf.backgroundRingView.superview){
-                    [strongSelf.hudView.contentView addSubview:strongSelf.backgroundRingView];
-                }
-                
-                // Set progress animated
-                [CATransaction begin];
-                [CATransaction setDisableActions:YES];
-                strongSelf.ringView.strokeEnd = progress;
-                [CATransaction commit];
-                
-                // Update the activity count
-                if(progress == 0) {
-                    strongSelf.activityCount++;
-                }
-            } else {
-                // Cancel the ringLayer animation, then show the indefiniteAnimatedView
-                [strongSelf cancelRingLayerAnimation];
-                
-                // Add indefiniteAnimatedView to HUD
-                [strongSelf.hudView.contentView addSubview:strongSelf.indefiniteAnimatedView];
-                if([strongSelf.indefiniteAnimatedView respondsToSelector:@selector(startAnimating)]) {
-                    [(id)strongSelf.indefiniteAnimatedView startAnimating];
-                }
-                
-                // Update the activity count
-                strongSelf.activityCount++;
-            }
-            
-            // Fade in delayed if a grace time is set
-            if (self.graceTimeInterval > 0.0 && self.backgroundView.alpha == 0.0f) {
-                strongSelf.graceTimer = [NSTimer timerWithTimeInterval:self.graceTimeInterval target:strongSelf selector:@selector(fadeIn:) userInfo:nil repeats:NO];
-                [[NSRunLoop mainRunLoop] addTimer:strongSelf.graceTimer forMode:NSRunLoopCommonModes];
-            } else {
-                [strongSelf fadeIn:nil];
-            }
-            
-            // Tell the Haptics Generator to prepare for feedback, which may come soon
-#if TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
-            if (@available(iOS 10.0, *)) {
-                [strongSelf.hapticGenerator prepare];
-            }
-#endif
-        }
-    }];
-}
-
-- (void)showImage:(UIImage*)image status:(NSString*)status duration:(NSTimeInterval)duration {
-    __weak SVProgressHUD *weakSelf = self;
-    [[NSOperationQueue mainQueue] addOperationWithBlock:^{
-        __strong SVProgressHUD *strongSelf = weakSelf;
-        if(strongSelf){
-            // Stop timer
-            strongSelf.fadeOutTimer = nil;
-            strongSelf.graceTimer = nil;
-            
-            // Update / Check view hierarchy to ensure the HUD is visible
-            [strongSelf updateViewHierarchy];
-            
-            // Reset progress and cancel any running animation
-            strongSelf.progress = image?SVProgressHUDUndefinedProgress:0;
-            [strongSelf cancelRingLayerAnimation];
-            [strongSelf cancelIndefiniteAnimatedViewAnimation];
-            
-            // Update imageView
-            if (self.shouldTintImages) {
-                if (image.renderingMode != UIImageRenderingModeAlwaysTemplate) {
-                    strongSelf.imageView.image = [image imageWithRenderingMode:UIImageRenderingModeAlwaysTemplate];
-                }
-                strongSelf.imageView.tintColor = strongSelf.foregroundColorForStyle;;
-            } else {
-                strongSelf.imageView.image = image;
-            }
-            strongSelf.imageView.hidden = NO;
-            
-            // Update text
-            strongSelf.statusLabel.hidden = status.length == 0;
-            strongSelf.statusLabel.text = status;
-            
-            // Fade in delayed if a grace time is set
-            // An image will be dismissed automatically. Thus pass the duration as userInfo.
-            if (self.graceTimeInterval > 0.0 && self.backgroundView.alpha == 0.0f) {
-                strongSelf.graceTimer = [NSTimer timerWithTimeInterval:self.graceTimeInterval target:strongSelf selector:@selector(fadeIn:) userInfo:@(duration) repeats:NO];
-                [[NSRunLoop mainRunLoop] addTimer:strongSelf.graceTimer forMode:NSRunLoopCommonModes];
-            } else {
-                [strongSelf fadeIn:@(duration)];
-            }
-        }
-    }];
-}
-
-- (void)fadeIn:(id)data {
-    // Update the HUDs frame to the new content and position HUD
-    [self updateHUDFrame];
-    [self positionHUD:nil];
-    
-    // Update accessibility as well as user interaction
-    if(self.defaultMaskType != SVProgressHUDMaskTypeNone) {
-        self.controlView.userInteractionEnabled = YES;
-        self.accessibilityLabel = self.statusLabel.text ?: NSLocalizedString(@"Loading", nil);
-        self.isAccessibilityElement = YES;
-    } else {
-        self.controlView.userInteractionEnabled = NO;
-        self.hudView.accessibilityLabel = self.statusLabel.text ?: NSLocalizedString(@"Loading", nil);
-        self.hudView.isAccessibilityElement = YES;
-    }
-    
-    // Get duration
-    id duration = [data isKindOfClass:[NSTimer class]] ? ((NSTimer *)data).userInfo : data;
-    
-    // Show if not already visible
-    if(self.backgroundView.alpha != 1.0f) {
-        // Post notification to inform user
-        [[NSNotificationCenter defaultCenter] postNotificationName:SVProgressHUDWillAppearNotification
-                                                            object:self
-                                                          userInfo:[self notificationUserInfo]];
-        
-        // Shrink HUD to to make a nice appear / pop up animation
-        self.hudView.transform = self.hudView.transform = CGAffineTransformScale(self.hudView.transform, 1/1.5f, 1/1.5f);
-        
-        __block void (^animationsBlock)(void) = ^{
-            // Zoom HUD a little to make a nice appear / pop up animation
-            self.hudView.transform = CGAffineTransformIdentity;
-            
-            // Fade in all effects (colors, blur, etc.)
-            [self fadeInEffects];
-        };
-        
-        __block void (^completionBlock)(void) = ^{
-            // Check if we really achieved to show the HUD (<=> alpha)
-            // and the change of these values has not been cancelled in between e.g. due to a dismissal
-            if(self.backgroundView.alpha == 1.0f){
-                // Register observer <=> we now have to handle orientation changes etc.
-                [self registerNotifications];
-                
-                // Post notification to inform user
-                [[NSNotificationCenter defaultCenter] postNotificationName:SVProgressHUDDidAppearNotification
-                                                                    object:self
-                                                                  userInfo:[self notificationUserInfo]];
-                
-                // Update accessibility
-                UIAccessibilityPostNotification(UIAccessibilityScreenChangedNotification, nil);
-                UIAccessibilityPostNotification(UIAccessibilityAnnouncementNotification, self.statusLabel.text);
-                
-                // Dismiss automatically if a duration was passed as userInfo. We start a timer
-                // which then will call dismiss after the predefined duration
-                if(duration){
-                    self.fadeOutTimer = [NSTimer timerWithTimeInterval:[(NSNumber *)duration doubleValue] target:self selector:@selector(dismiss) userInfo:nil repeats:NO];
-                    [[NSRunLoop mainRunLoop] addTimer:self.fadeOutTimer forMode:NSRunLoopCommonModes];
-                }
-            }
-        };
-        
-        // Animate appearance
-        if (self.fadeInAnimationDuration > 0) {
-            // Animate appearance
-            [UIView animateWithDuration:self.fadeInAnimationDuration
-                                  delay:0
-                                options:(UIViewAnimationOptions) (UIViewAnimationOptionAllowUserInteraction | UIViewAnimationCurveEaseIn | UIViewAnimationOptionBeginFromCurrentState)
-                             animations:^{
-                                 animationsBlock();
-                             } completion:^(BOOL finished) {
-                                 completionBlock();
-                             }];
-        } else {
-            animationsBlock();
-            completionBlock();
-        }
-        
-        // Inform iOS to redraw the view hierarchy
-        [self setNeedsDisplay];
-    } else {
-        // Update accessibility
-        UIAccessibilityPostNotification(UIAccessibilityScreenChangedNotification, nil);
-        UIAccessibilityPostNotification(UIAccessibilityAnnouncementNotification, self.statusLabel.text);
-        
-        // Dismiss automatically if a duration was passed as userInfo. We start a timer
-        // which then will call dismiss after the predefined duration
-        if(duration){
-            self.fadeOutTimer = [NSTimer timerWithTimeInterval:[(NSNumber *)duration doubleValue] target:self selector:@selector(dismiss) userInfo:nil repeats:NO];
-            [[NSRunLoop mainRunLoop] addTimer:self.fadeOutTimer forMode:NSRunLoopCommonModes];
-        }
-    }
-}
-
-- (void)dismiss {
-    [self dismissWithDelay:0.0 completion:nil];
-}
-
-- (void)dismissWithDelay:(NSTimeInterval)delay completion:(SVProgressHUDDismissCompletion)completion {
-    __weak SVProgressHUD *weakSelf = self;
-    [[NSOperationQueue mainQueue] addOperationWithBlock:^{
-        __strong SVProgressHUD *strongSelf = weakSelf;
-        if(strongSelf){
-            // Stop timer
-            strongSelf.graceTimer = nil;
-            
-            // Post notification to inform user
-            [[NSNotificationCenter defaultCenter] postNotificationName:SVProgressHUDWillDisappearNotification
-                                                                object:nil
-                                                              userInfo:[strongSelf notificationUserInfo]];
-            
-            // Reset activity count
-            strongSelf.activityCount = 0;
-            
-            __block void (^animationsBlock)(void) = ^{
-                // Shrink HUD a little to make a nice disappear animation
-                strongSelf.hudView.transform = CGAffineTransformScale(strongSelf.hudView.transform, 1/1.3f, 1/1.3f);
-                
-                // Fade out all effects (colors, blur, etc.)
-                [strongSelf fadeOutEffects];
-            };
-            
-            __block void (^completionBlock)(void) = ^{
-                // Check if we really achieved to dismiss the HUD (<=> alpha values are applied)
-                // and the change of these values has not been cancelled in between e.g. due to a new show
-                if(self.backgroundView.alpha == 0.0f){
-                    // Clean up view hierarchy (overlays)
-                    [strongSelf.controlView removeFromSuperview];
-                    [strongSelf.backgroundView removeFromSuperview];
-                    [strongSelf.hudView removeFromSuperview];
-                    [strongSelf removeFromSuperview];
-                    
-                    // Reset progress and cancel any running animation
-                    strongSelf.progress = SVProgressHUDUndefinedProgress;
-                    [strongSelf cancelRingLayerAnimation];
-                    [strongSelf cancelIndefiniteAnimatedViewAnimation];
-                    
-                    // Remove observer <=> we do not have to handle orientation changes etc.
-                    [[NSNotificationCenter defaultCenter] removeObserver:strongSelf];
-                    
-                    // Post notification to inform user
-                    [[NSNotificationCenter defaultCenter] postNotificationName:SVProgressHUDDidDisappearNotification
-                                                                        object:strongSelf
-                                                                      userInfo:[strongSelf notificationUserInfo]];
-                    
-                    // Tell the rootViewController to update the StatusBar appearance
-#if !defined(SV_APP_EXTENSIONS) && TARGET_OS_IOS
-                    UIViewController *rootController = [[UIApplication sharedApplication] keyWindow].rootViewController;
-                    [rootController setNeedsStatusBarAppearanceUpdate];
-#endif
-                    
-                    // Run an (optional) completionHandler
-                    if (completion) {
-                        completion();
-                    }
-                }
-            };
-            
-            // UIViewAnimationOptionBeginFromCurrentState AND a delay doesn't always work as expected
-            // When UIViewAnimationOptionBeginFromCurrentState is set, animateWithDuration: evaluates the current
-            // values to check if an animation is necessary. The evaluation happens at function call time and not
-            // after the delay => the animation is sometimes skipped. Therefore we delay using dispatch_after.
-            
-            dispatch_time_t dipatchTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC));
-            dispatch_after(dipatchTime, dispatch_get_main_queue(), ^{
-                if (strongSelf.fadeOutAnimationDuration > 0) {
-                    // Animate appearance
-                    [UIView animateWithDuration:strongSelf.fadeOutAnimationDuration
-                                          delay:0
-                                        options:(UIViewAnimationOptions) (UIViewAnimationOptionAllowUserInteraction | UIViewAnimationCurveEaseOut | UIViewAnimationOptionBeginFromCurrentState)
-                                     animations:^{
-                                         animationsBlock();
-                                     } completion:^(BOOL finished) {
-                                         completionBlock();
-                                     }];
-                } else {
-                    animationsBlock();
-                    completionBlock();
-                }
-            });
-            
-            // Inform iOS to redraw the view hierarchy
-            [strongSelf setNeedsDisplay];
-        }
-    }];
-}
-
-
-#pragma mark - Ring progress animation
-
-- (UIView*)indefiniteAnimatedView {
-    // Get the correct spinner for defaultAnimationType
-    if(self.defaultAnimationType == SVProgressHUDAnimationTypeFlat){
-        // Check if spinner exists and is an object of different class
-        if(_indefiniteAnimatedView && ![_indefiniteAnimatedView isKindOfClass:[SVIndefiniteAnimatedView class]]){
-            [_indefiniteAnimatedView removeFromSuperview];
-            _indefiniteAnimatedView = nil;
-        }
-        
-        if(!_indefiniteAnimatedView){
-            _indefiniteAnimatedView = [[SVIndefiniteAnimatedView alloc] initWithFrame:CGRectZero];
-        }
-        
-        // Update styling
-        SVIndefiniteAnimatedView *indefiniteAnimatedView = (SVIndefiniteAnimatedView*)_indefiniteAnimatedView;
-        indefiniteAnimatedView.strokeColor = self.foregroundColorForStyle;
-        indefiniteAnimatedView.strokeThickness = self.ringThickness;
-        indefiniteAnimatedView.radius = self.statusLabel.text ? self.ringRadius : self.ringNoTextRadius;
-    } else {
-        // Check if spinner exists and is an object of different class
-        if(_indefiniteAnimatedView && ![_indefiniteAnimatedView isKindOfClass:[UIActivityIndicatorView class]]){
-            [_indefiniteAnimatedView removeFromSuperview];
-            _indefiniteAnimatedView = nil;
-        }
-        
-        if(!_indefiniteAnimatedView){
-            _indefiniteAnimatedView = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];
-        }
-        
-        // Update styling
-        UIActivityIndicatorView *activityIndicatorView = (UIActivityIndicatorView*)_indefiniteAnimatedView;
-        activityIndicatorView.color = self.foregroundColorForStyle;
-    }
-    [_indefiniteAnimatedView sizeToFit];
-    
-    return _indefiniteAnimatedView;
-}
-
-- (SVProgressAnimatedView*)ringView {
-    if(!_ringView) {
-        _ringView = [[SVProgressAnimatedView alloc] initWithFrame:CGRectZero];
-    }
-    
-    // Update styling
-    _ringView.strokeColor = self.foregroundColorForStyle;
-    _ringView.strokeThickness = self.ringThickness;
-    _ringView.radius = self.statusLabel.text ? self.ringRadius : self.ringNoTextRadius;
-    
-    return _ringView;
-}
-
-- (SVProgressAnimatedView*)backgroundRingView {
-    if(!_backgroundRingView) {
-        _backgroundRingView = [[SVProgressAnimatedView alloc] initWithFrame:CGRectZero];
-        _backgroundRingView.strokeEnd = 1.0f;
-    }
-    
-    // Update styling
-    _backgroundRingView.strokeColor = [self.foregroundColorForStyle colorWithAlphaComponent:0.1f];
-    _backgroundRingView.strokeThickness = self.ringThickness;
-    _backgroundRingView.radius = self.statusLabel.text ? self.ringRadius : self.ringNoTextRadius;
-    
-    return _backgroundRingView;
-}
-
-- (void)cancelRingLayerAnimation {
-    // Animate value update, stop animation
-    [CATransaction begin];
-    [CATransaction setDisableActions:YES];
-    
-    [self.hudView.layer removeAllAnimations];
-    self.ringView.strokeEnd = 0.0f;
-    
-    [CATransaction commit];
-    
-    // Remove from view
-    [self.ringView removeFromSuperview];
-    [self.backgroundRingView removeFromSuperview];
-}
-
-- (void)cancelIndefiniteAnimatedViewAnimation {
-    // Stop animation
-    if([self.indefiniteAnimatedView respondsToSelector:@selector(stopAnimating)]) {
-        [(id)self.indefiniteAnimatedView stopAnimating];
-    }
-    // Remove from view
-    [self.indefiniteAnimatedView removeFromSuperview];
-}
-
-
-#pragma mark - Utilities
-
-+ (BOOL)isVisible {
-    // Checking one alpha value is sufficient as they are all the same
-    return [self sharedView].backgroundView.alpha > 0.0f;
-}
-
-
-#pragma mark - Getters
-
-+ (NSTimeInterval)displayDurationForString:(NSString*)string {
-    CGFloat minimum = MAX((CGFloat)string.length * 0.06 + 0.5, [self sharedView].minimumDismissTimeInterval);
-    return MIN(minimum, [self sharedView].maximumDismissTimeInterval);
-}
-
-- (UIColor*)foregroundColorForStyle {
-    if(self.defaultStyle == SVProgressHUDStyleLight) {
-        return [UIColor blackColor];
-    } else if(self.defaultStyle == SVProgressHUDStyleDark) {
-        return [UIColor whiteColor];
-    } else {
-        return self.foregroundColor;
-    }
-}
-
-- (UIColor*)backgroundColorForStyle {
-    if(self.defaultStyle == SVProgressHUDStyleLight) {
-        return [UIColor whiteColor];
-    } else if(self.defaultStyle == SVProgressHUDStyleDark) {
-        return [UIColor blackColor];
-    } else {
-        return self.backgroundColor;
-    }
-}
-
-- (UIControl*)controlView {
-    if(!_controlView) {
-        _controlView = [UIControl new];
-        _controlView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-        _controlView.backgroundColor = [UIColor clearColor];
-        _controlView.userInteractionEnabled = YES;
-        [_controlView addTarget:self action:@selector(controlViewDidReceiveTouchEvent:forEvent:) forControlEvents:UIControlEventTouchDown];
-    }
-    
-    // Update frames
-#if !defined(SV_APP_EXTENSIONS)
-    CGRect windowBounds = [[[UIApplication sharedApplication] delegate] window].bounds;
-    _controlView.frame = windowBounds;
-#else
-    _controlView.frame = [UIScreen mainScreen].bounds;
-#endif
-    
-    return _controlView;
-}
-
--(UIView *)backgroundView {
-    if(!_backgroundView){
-        _backgroundView = [UIView new];
-        _backgroundView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
-    }
-    if(!_backgroundView.superview){
-        [self insertSubview:_backgroundView belowSubview:self.hudView];
-    }
-    
-    // Update styling
-    if(self.defaultMaskType == SVProgressHUDMaskTypeGradient){
-        if(!_backgroundRadialGradientLayer){
-            _backgroundRadialGradientLayer = [SVRadialGradientLayer layer];
-        }
-        if(!_backgroundRadialGradientLayer.superlayer){
-            [_backgroundView.layer insertSublayer:_backgroundRadialGradientLayer atIndex:0];
-        }
-        _backgroundView.backgroundColor = [UIColor clearColor];
-    } else {
-        if(_backgroundRadialGradientLayer && _backgroundRadialGradientLayer.superlayer){
-            [_backgroundRadialGradientLayer removeFromSuperlayer];
-        }
-        if(self.defaultMaskType == SVProgressHUDMaskTypeBlack){
-            _backgroundView.backgroundColor = [UIColor colorWithWhite:0 alpha:0.4];
-        } else if(self.defaultMaskType == SVProgressHUDMaskTypeCustom){
-            _backgroundView.backgroundColor = self.backgroundLayerColor;
-        } else {
-            _backgroundView.backgroundColor = [UIColor clearColor];
-        }
-    }
-
-    // Update frame
-    if(_backgroundView){
-        _backgroundView.frame = self.bounds;
-    }
-    if(_backgroundRadialGradientLayer){
-        _backgroundRadialGradientLayer.frame = self.bounds;
-        
-        // Calculate the new center of the gradient, it may change if keyboard is visible
-        CGPoint gradientCenter = self.center;
-        gradientCenter.y = (self.bounds.size.height - self.visibleKeyboardHeight)/2;
-        _backgroundRadialGradientLayer.gradientCenter = gradientCenter;
-        [_backgroundRadialGradientLayer setNeedsDisplay];
-    }
-    
-    return _backgroundView;
-}
-- (UIVisualEffectView*)hudView {
-    if(!_hudView) {
-        _hudView = [UIVisualEffectView new];
-        _hudView.layer.masksToBounds = YES;
-        _hudView.autoresizingMask = UIViewAutoresizingFlexibleBottomMargin | UIViewAutoresizingFlexibleTopMargin | UIViewAutoresizingFlexibleRightMargin | UIViewAutoresizingFlexibleLeftMargin;
-    }
-    if(!_hudView.superview) {
-        [self addSubview:_hudView];
-    }
-    
-    // Update styling
-    _hudView.layer.cornerRadius = self.cornerRadius;
-    
-    return _hudView;
-}
-
-- (UILabel*)statusLabel {
-    if(!_statusLabel) {
-        _statusLabel = [[UILabel alloc] initWithFrame:CGRectZero];
-        _statusLabel.backgroundColor = [UIColor clearColor];
-        _statusLabel.adjustsFontSizeToFitWidth = YES;
-        _statusLabel.textAlignment = NSTextAlignmentCenter;
-        _statusLabel.baselineAdjustment = UIBaselineAdjustmentAlignCenters;
-        _statusLabel.numberOfLines = 0;
-    }
-    if(!_statusLabel.superview) {
-      [self.hudView.contentView addSubview:_statusLabel];
-    }
-    
-    // Update styling
-    _statusLabel.textColor = self.foregroundColorForStyle;
-    _statusLabel.font = self.font;
-
-    return _statusLabel;
-}
-
-- (UIImageView*)imageView {
-    if(_imageView && !CGSizeEqualToSize(_imageView.bounds.size, _imageViewSize)) {
-        [_imageView removeFromSuperview];
-        _imageView = nil;
-    }
-    
-    if(!_imageView) {
-        _imageView = [[UIImageView alloc] initWithFrame:CGRectMake(0.0f, 0.0f, _imageViewSize.width, _imageViewSize.height)];
-    }
-    if(!_imageView.superview) {
-        [self.hudView.contentView addSubview:_imageView];
-    }
-    
-    return _imageView;
-}
-
-
-#pragma mark - Helper
-    
-- (CGFloat)visibleKeyboardHeight {
-#if !defined(SV_APP_EXTENSIONS)
-    UIWindow *keyboardWindow = nil;
-    for (UIWindow *testWindow in UIApplication.sharedApplication.windows) {
-        if(![testWindow.class isEqual:UIWindow.class]) {
-            keyboardWindow = testWindow;
-            break;
-        }
-    }
-    
-    for (__strong UIView *possibleKeyboard in keyboardWindow.subviews) {
-        NSString *viewName = NSStringFromClass(possibleKeyboard.class);
-        if([viewName hasPrefix:@"UI"]){
-            if([viewName hasSuffix:@"PeripheralHostView"] || [viewName hasSuffix:@"Keyboard"]){
-                return CGRectGetHeight(possibleKeyboard.bounds);
-            } else if ([viewName hasSuffix:@"InputSetContainerView"]){
-                for (__strong UIView *possibleKeyboardSubview in possibleKeyboard.subviews) {
-                    viewName = NSStringFromClass(possibleKeyboardSubview.class);
-                    if([viewName hasPrefix:@"UI"] && [viewName hasSuffix:@"InputSetHostView"]) {
-                        CGRect convertedRect = [possibleKeyboard convertRect:possibleKeyboardSubview.frame toView:self];
-                        CGRect intersectedRect = CGRectIntersection(convertedRect, self.bounds);
-                        if (!CGRectIsNull(intersectedRect)) {
-                            return CGRectGetHeight(intersectedRect);
-                        }
-                    }
-                }
-            }
-        }
-    }
-#endif
-    return 0;
-}
-    
-- (UIWindow *)frontWindow {
-#if !defined(SV_APP_EXTENSIONS)
-    NSEnumerator *frontToBackWindows = [UIApplication.sharedApplication.windows reverseObjectEnumerator];
-    for (UIWindow *window in frontToBackWindows) {
-        BOOL windowOnMainScreen = window.screen == UIScreen.mainScreen;
-        BOOL windowIsVisible = !window.hidden && window.alpha > 0;
-        BOOL windowLevelSupported = (window.windowLevel >= UIWindowLevelNormal && window.windowLevel <= self.maxSupportedWindowLevel);
-        BOOL windowKeyWindow = window.isKeyWindow;
-			
-        if(windowOnMainScreen && windowIsVisible && windowLevelSupported && windowKeyWindow) {
-            return window;
-        }
-    }
-#endif
-    return nil;
-}
-    
-- (void)fadeInEffects {
-    if(self.defaultStyle != SVProgressHUDStyleCustom) {
-        // Add blur effect
-        UIBlurEffectStyle blurEffectStyle = self.defaultStyle == SVProgressHUDStyleDark ? UIBlurEffectStyleDark : UIBlurEffectStyleLight;
-        UIBlurEffect *blurEffect = [UIBlurEffect effectWithStyle:blurEffectStyle];
-        self.hudView.effect = blurEffect;
-        
-        // We omit UIVibrancy effect and use a suitable background color as an alternative.
-        // This will make everything more readable. See the following for details:
-        // https://www.omnigroup.com/developer/how-to-make-text-in-a-uivisualeffectview-readable-on-any-background
-        
-        self.hudView.backgroundColor = [self.backgroundColorForStyle colorWithAlphaComponent:0.6f];
-    } else {
-        self.hudView.backgroundColor =  self.backgroundColorForStyle;
-    }
-
-    // Fade in views
-    self.backgroundView.alpha = 1.0f;
-    
-    self.imageView.alpha = 1.0f;
-    self.statusLabel.alpha = 1.0f;
-    self.indefiniteAnimatedView.alpha = 1.0f;
-    self.ringView.alpha = self.backgroundRingView.alpha = 1.0f;
-}
-
-- (void)fadeOutEffects
-{
-    if(self.defaultStyle != SVProgressHUDStyleCustom) {
-        // Remove blur effect
-        self.hudView.effect = nil;
-    }
-
-    // Remove background color
-    self.hudView.backgroundColor = [UIColor clearColor];
-    
-    // Fade out views
-    self.backgroundView.alpha = 0.0f;
-    
-    self.imageView.alpha = 0.0f;
-    self.statusLabel.alpha = 0.0f;
-    self.indefiniteAnimatedView.alpha = 0.0f;
-    self.ringView.alpha = self.backgroundRingView.alpha = 0.0f;
-}
-
-#if TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000
-- (UINotificationFeedbackGenerator *)hapticGenerator NS_AVAILABLE_IOS(10_0) {
-	// Only return if haptics are enabled
-	if(!self.hapticsEnabled) {
-		return nil;
-	}
-	
-	if(!_hapticGenerator) {
-		_hapticGenerator = [[UINotificationFeedbackGenerator alloc] init];
-	}
-	return _hapticGenerator;
-}
-#endif
-
-    
-#pragma mark - UIAppearance Setters
-
-- (void)setDefaultStyle:(SVProgressHUDStyle)style {
-    if (!_isInitializing) _defaultStyle = style;
-}
-
-- (void)setDefaultMaskType:(SVProgressHUDMaskType)maskType {
-    if (!_isInitializing) _defaultMaskType = maskType;
-}
-
-- (void)setDefaultAnimationType:(SVProgressHUDAnimationType)animationType {
-    if (!_isInitializing) _defaultAnimationType = animationType;
-}
-
-- (void)setContainerView:(UIView *)containerView {
-    if (!_isInitializing) _containerView = containerView;
-}
-
-- (void)setMinimumSize:(CGSize)minimumSize {
-    if (!_isInitializing) _minimumSize = minimumSize;
-}
-
-- (void)setRingThickness:(CGFloat)ringThickness {
-    if (!_isInitializing) _ringThickness = ringThickness;
-}
-
-- (void)setRingRadius:(CGFloat)ringRadius {
-    if (!_isInitializing) _ringRadius = ringRadius;
-}
-
-- (void)setRingNoTextRadius:(CGFloat)ringNoTextRadius {
-    if (!_isInitializing) _ringNoTextRadius = ringNoTextRadius;
-}
-
-- (void)setCornerRadius:(CGFloat)cornerRadius {
-    if (!_isInitializing) _cornerRadius = cornerRadius;
-}
-
-- (void)setFont:(UIFont*)font {
-    if (!_isInitializing) _font = font;
-}
-
-- (void)setForegroundColor:(UIColor*)color {
-    if (!_isInitializing) _foregroundColor = color;
-}
-
-- (void)setBackgroundColor:(UIColor*)color {
-    if (!_isInitializing) _backgroundColor = color;
-}
-
-- (void)setBackgroundLayerColor:(UIColor*)color {
-    if (!_isInitializing) _backgroundLayerColor = color;
-}
-
-- (void)setShouldTintImages:(BOOL)shouldTintImages {
-    if (!_isInitializing) _shouldTintImages = shouldTintImages;
-}
-
-- (void)setInfoImage:(UIImage*)image {
-    if (!_isInitializing) _infoImage = image;
-}
-
-- (void)setSuccessImage:(UIImage*)image {
-    if (!_isInitializing) _successImage = image;
-}
-
-- (void)setErrorImage:(UIImage*)image {
-    if (!_isInitializing) _errorImage = image;
-}
-
-- (void)setViewForExtension:(UIView*)view {
-    if (!_isInitializing) _viewForExtension = view;
-}
-
-- (void)setOffsetFromCenter:(UIOffset)offset {
-    if (!_isInitializing) _offsetFromCenter = offset;
-}
-
-- (void)setMinimumDismissTimeInterval:(NSTimeInterval)minimumDismissTimeInterval {
-    if (!_isInitializing) _minimumDismissTimeInterval = minimumDismissTimeInterval;
-}
-
-- (void)setFadeInAnimationDuration:(NSTimeInterval)duration {
-    if (!_isInitializing) _fadeInAnimationDuration = duration;
-}
-
-- (void)setFadeOutAnimationDuration:(NSTimeInterval)duration {
-    if (!_isInitializing) _fadeOutAnimationDuration = duration;
-}
-
-- (void)setMaxSupportedWindowLevel:(UIWindowLevel)maxSupportedWindowLevel {
-    if (!_isInitializing) _maxSupportedWindowLevel = maxSupportedWindowLevel;
-}
-
-@end

WXDownloadingKit/SVProgressHUD/SVRadialGradientLayer.h

-//
-//  SVRadialGradientLayer.h
-//  SVProgressHUD, https://github.com/SVProgressHUD/SVProgressHUD
-//
-//  Copyright (c) 2014-2018 Tobias Tiemerding. All rights reserved.
-//
-
-#import <QuartzCore/QuartzCore.h>
-
-@interface SVRadialGradientLayer : CALayer
-
-@property (nonatomic) CGPoint gradientCenter;
-
-@end

WXDownloadingKit/SVProgressHUD/SVRadialGradientLayer.m

-//
-//  SVRadialGradientLayer.m
-//  SVProgressHUD, https://github.com/SVProgressHUD/SVProgressHUD
-//
-//  Copyright (c) 2014-2018 Tobias Tiemerding. All rights reserved.
-//
-
-#import "SVRadialGradientLayer.h"
-
-@implementation SVRadialGradientLayer
-
-- (void)drawInContext:(CGContextRef)context {
-    size_t locationsCount = 2;
-    CGFloat locations[2] = {0.0f, 1.0f};
-    CGFloat colors[8] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.75f};
-    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
-    CGGradientRef gradient = CGGradientCreateWithColorComponents(colorSpace, colors, locations, locationsCount);
-    CGColorSpaceRelease(colorSpace);
-
-    float radius = MIN(self.bounds.size.width , self.bounds.size.height);
-    CGContextDrawRadialGradient (context, gradient, self.gradientCenter, 0, self.gradientCenter, radius, kCGGradientDrawsAfterEndLocation);
-    CGGradientRelease(gradient);
-}
-
-@end