Update Sparkle to https://github.com/sparkle-project/Sparkle/releases/tag/2.3.0

Sparkle.framework/Versions/B/Headers/SPUStandardUserDriverDelegate.h

@@ -6,17 +6,14 @@
 //  Copyright © 2016 Sparkle Project. All rights reserved.
 //
 
-#if __has_feature(modules)
-#if __has_warning("-Watimport-in-framework-header")
-#pragma clang diagnostic ignored "-Watimport-in-framework-header"
-#endif
-@import Foundation;
-#else
 #import <Foundation/Foundation.h>
-#endif
 #import <Sparkle/SUExport.h>
 
+NS_ASSUME_NONNULL_BEGIN
+
 @protocol SUVersionDisplay;
+@class SUAppcastItem;
+@class SPUUserUpdateState;
 
 /**
  A protocol for Sparkle's standard user driver's delegate
@@ -59,6 +56,117 @@ SU_EXPORT @protocol SPUStandardUserDriverDelegate <NSObject>
  
  @param item The appcast item corresponding to the latest version available.
  */
-- (void)standardUserDriverShowVersionHistoryForAppcastItem:(SUAppcastItem *_Nonnull)item;
+- (void)standardUserDriverShowVersionHistoryForAppcastItem:(SUAppcastItem *)item;
+
+/**
+ Specifies whether or not the download, extraction, and installing status windows allows to be minimized.
+ 
+ By default, the status window showing the current status of the update (download, extraction, ready to install) is allowed to be minimized
+ for regular application bundle updates.
+ 
+ @return @c YES if the status window is allowed to be minimized (default behavior), otherwise @c NO.
+ */
+- (BOOL)standardUserDriverAllowsMinimizableStatusWindow;
+
+/**
+ Declares whether or not gentle scheduled update reminders are supported.
+ 
+ The delegate may implement scheduled update reminders that are presented in a gentle manner by implementing one or both of:
+ `-standardUserDriverWillHandleShowingUpdate:forUpdate:state:` and `-standardUserDriverShouldHandleShowingScheduledUpdate:andInImmediateFocus:`
+ 
+ Visit https://sparkle-project.org/documentation/gentle-reminders for more information and examples.
+ 
+ @return @c YES if gentle scheduled update reminders are implemented by standard user driver delegate, otherwise @c NO (default).
+ */
+@property (nonatomic, readonly) BOOL supportsGentleScheduledUpdateReminders;
+
+/**
+ Specifies if the standard user driver should handle showing a new scheduled update, or if its delegate should handle showing the update instead.
+ 
+ If you implement this method and return @c NO the delegate is then responsible for showing the update,
+ which must be implemented and done in `-standardUserDriverWillHandleShowingUpdate:forUpdate:state:`
+ The motivation for the delegate being responsible for showing updates is to override Sparkle's default behavior
+ and add gentle reminders for new updates.
+ 
+ Returning @c YES is the default behavior and allows the standard user driver to handle showing the update.
+ 
+ If the standard user driver handles showing the update, `immediateFocus` reflects whether or not it will show the update in immediate and utmost focus.
+ The standard user driver may choose to show the update in immediate and utmost focus when the app was launched recently
+ or the system has been idle for some time.
+ 
+ If `immediateFocus` is @c NO the standard user driver may want to defer showing the update until the user comes back to the app.
+ For background running applications, when `immediateFocus` is  @c NO the standard user driver will always want to show
+ the update alert immediately, but behind other running applications or behind the app's own windows if it's currently active.
+ 
+ There should be no side effects made when implementing this method so you should just return @c YES or @c NO
+ You will also want to implement `-standardUserDriverWillHandleShowingUpdate:forUpdate:state:` for adding additional update reminders.
+ 
+ This method is not called for user-initiated update checks. The standard user driver always handles those.
+ 
+ Visit https://sparkle-project.org/documentation/gentle-reminders for more information and examples.
+ 
+ @param update The update the standard user driver should show.
+ @param immediateFocus If @c immediateFocus is @c YES, then the standard user driver proposes to show the update in immediate and utmost focus. See discussion for more details.
+ 
+ @return @c YES if the standard user should handle showing the scheduled update (default behavior), otherwise @c NO if the delegate handles showing it.
+ */
+- (BOOL)standardUserDriverShouldHandleShowingScheduledUpdate:(SUAppcastItem *)update andInImmediateFocus:(BOOL)immediateFocus;
+
+/**
+ Called before an update will be shown to the user.
+ 
+ If the standard user driver handles showing the update, `handleShowingUpdate` will be `YES`.
+ Please see `-standardUserDriverShouldHandleShowingScheduledUpdate:andInImmediateFocus:` for how the standard user driver
+ may handle showing scheduled updates when `handleShowingUpdate` is `YES` and `state.userInitiated` is `NO`.
+ 
+ If the delegate declared it handles showing the update by returning @c NO in `-standardUserDriverShouldHandleShowingScheduledUpdate:andInImmediateFocus:`
+ then the delegate should handle showing update reminders in this method, or at some later point.
+ In this case, `handleShowingUpdate` will be @c NO.
+ To bring the update alert in focus, you may call `-[SPUStandardUpdaterController checkForUpdates:]` or `-[SPUUpdater checkForUpdates]`.
+ You may want to show additional UI indicators in your application that will show this update in focus
+ and want to dismiss additional UI indicators in `-standardUserDriverWillFinishUpdateSession` or `-standardUserDriverDidReceiveUserAttentionForUpdate:`
+  
+ If `state.userInitiated` is @c YES then the standard user driver always handles showing the new update and `handleShowingUpdate` will be @c YES.
+ In this case, it may still be useful for the delegate to intercept this method right before a new update will be shown.
+ 
+ This method is not called when bringing an update that has already been presented back in focus.
+ 
+ Visit https://sparkle-project.org/documentation/gentle-reminders for more information and examples.
+ 
+ @param handleShowingUpdate @c YES if the standard user driver handles showing the update, otherwise @c NO if the delegate handles showing the update.
+ @param update The update that will be shown.
+ @param state The user state of the update which includes if the update check was initiated by the user.
+ */
+- (void)standardUserDriverWillHandleShowingUpdate:(BOOL)handleShowingUpdate forUpdate:(SUAppcastItem *)update state:(SPUUserUpdateState *)state;
+
+/**
+ Called when a new update first receives attention from the user.
+ 
+ This occurs either when the user first brings the update alert in utmost focus or when the user makes a choice to install an update or dismiss/skip it.
+ 
+ This may be useful to intercept for dismissing custom attention-based UI indicators (e.g, user notifications) introduced when implementing
+ `-standardUserDriverWillHandleShowingUpdate:forUpdate:state:`
+ 
+ For custom UI indicators that need to still be on screen after the user has started to install an update, please see `-standardUserDriverWillFinishUpdateSession`.
+ 
+ @param update The new update that the user gave attention to.
+ */
+- (void)standardUserDriverDidReceiveUserAttentionForUpdate:(SUAppcastItem *)update;
+
+/**
+ Called before the standard user driver session will finish its current update session.
+ 
+ This may occur after the user has dismissed / skipped a new update or after an update error has occurred.
+ For updaters updating external/other bundles, this may also be called after an update has been successfully installed.
+ 
+ This may be useful to intercept for dismissing custom UI indicators introduced when implementing
+ `-standardUserDriverWillHandleShowingUpdate:forUpdate:state:`
+ 
+ For UI indicators that need to be dismissed when the user has given attention to a new update alert,
+ please see `-standardUserDriverDidReceiveUserAttentionForUpdate:`
+ */
+- (void)standardUserDriverWillFinishUpdateSession;
 
 @end
+
+NS_ASSUME_NONNULL_END