Sparkle

https://sparkle-project.org/documentation
Admin
Sparkle is a macOS software update framework that handles automatic updates, delta updates, code...
Tokens:63,009
Snippets:792
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Handle Update Installation Start

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Invoked before an update is installed.

```Objective-C
- (void)updater:(nonnull SUUpdater *)updater
    willInstallUpdate:(nonnull SUAppcastItem *)item;
```

```Swift
optional func updater(_ updater: SUUpdater, willInstallUpdate item: SUAppcastItem)
```

--------------------------------

### Prompt for installation and relaunch

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Requests user confirmation to install the update and relaunch the application.

```Objective-C
- (void)showReadyToInstallAndRelaunch:
    (nonnull void (^)(SPUUserUpdateChoice))reply;
```

```Swift
func showReadyToInstallAndRelaunch() async -> SPUUserUpdateChoice
```

--------------------------------

### startUpdater()

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUStandardUpdaterController.html

Starts the updater process if it has not already been started.

```APIDOC
## startUpdater()

### Description
Starts the updater. This should only be called if you opted out of starting the updater on initialization. Do not call this if instantiating from a nib.
```

--------------------------------

### showReadyToInstallAndRelaunch

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Prompts the user to confirm the installation and relaunch of the application.

```APIDOC
## showReadyToInstallAndRelaunch

### Description
Informs the user that the update is ready to be installed and relaunched, and requests a decision on how to proceed.

### Parameters
- **reply** (SPUUserUpdateChoice) - A callback or return value indicating whether to install, dismiss, or skip the update.

### Signature
Objective-C: `- (void)showReadyToInstallAndRelaunch:(nonnull void (^)(SPUUserUpdateChoice))reply;`
Swift: `func showReadyToInstallAndRelaunch() async -> SPUUserUpdateChoice`
```

--------------------------------

### Access Installation Type

Source: https://sparkle-project.org/documentation/api-reference/Classes/SUAppcastItem.html

Retrieves the installation type, which is either 'application' or 'package'.

```Objective-C
@property (nonatomic, copy, readonly) NSString *_Nonnull installationType;
```

```Swift
var installationType: String { get }
```

--------------------------------

### Show Installing Update (Deprecated)

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Deprecated method for showing installation progress. Use -showInstallingUpdateWithApplicationTerminated:retryTerminatingApplication: instead.

```Objective-C
- (void)showInstallingUpdate __deprecated_msg("Implement -showInstallingUpdateWithApplicationTerminated:retryTerminatingApplication: instead.");
```

```Swift
optional func showInstallingUpdate()
```

--------------------------------

### showDownloadInitiatedWithCancellation:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Notifies the user that the download of the new update has started.

```APIDOC
## showDownloadInitiatedWithCancellation:

### Description
Indicates that the update download has begun and provides a mechanism to cancel the operation.

### Parameters
- **cancellation** (void(^)(void)/() -> Void) - Required - A block to invoke if the user chooses to cancel the download.
```

--------------------------------

### Handle Update Installation on Quit

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Implement this method to intercept silent update installations. Returning YES allows manual control via the immediateInstallHandler, while NO allows Sparkle to manage the update cycle.

```Objective-C
- (BOOL)updater:(nonnull SPUUpdater *)updater
       willInstallUpdateOnQuit:(nonnull SUAppcastItem *)item
    immediateInstallationBlock:(nonnull void (^)(void))immediateInstallHandler;
```

```Swift
optional func updater(_ updater: SPUUpdater, willInstallUpdateOnQuit item: SUAppcastItem, immediateInstallationBlock immediateInstallHandler: @escaping () -> Void) -> Bool
```

--------------------------------

### Start the Updater

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUStandardUpdaterController.html

Starts the updater process if it was not started during initialization.

```Objective-C
- (void)startUpdater;
```

```Swift
func startUpdater()
```

--------------------------------

### Installation Error

Source: https://sparkle-project.org/documentation/api-reference/Enums/SUError.html

Represents an installation error code.

```Objective-C
SUInstallationError = 4005
```

```Swift
case installationError = 4005
```

--------------------------------

### Handle Application Relaunch Start

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Invoked before the application is relaunched.

```Objective-C
- (void)updaterWillRelaunchApplication:(nonnull SUUpdater *)updater;
```

```Swift
optional func updaterWillRelaunchApplication(_ updater: SUUpdater)
```

--------------------------------

### Show Update Installation Finished (Deprecated)

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Deprecated method for signaling the end of installation. Use -showUpdateInstalledAndRelaunched:acknowledgement: instead.

```Objective-C
- (void)showUpdateInstallationDidFinishWithAcknowledgement:(void (^)(void))acknowledgement __deprecated_msg("Implement -showUpdateInstalledAndRelaunched:acknowledgement: instead");
```

```Swift
optional func showUpdateInstallationDidFinish(acknowledgement: @escaping () -> Void)
```

--------------------------------

### updater:willInstallUpdateOnQuit:immediateInstallationBlock:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Notifies the delegate that an update will be installed on quit using a block.

```APIDOC
## updater:willInstallUpdateOnQuit:immediateInstallationBlock:

### Description
Called when an update is scheduled for installation on quit. Deprecated in Sparkle 2.

### Signature
Objective-C: `- (void)updater:(nonnull SUUpdater *)updater willInstallUpdateOnQuit:(nonnull SUAppcastItem *)item immediateInstallationBlock:(nonnull void (^)(void))installationBlock;`
Swift: `optional func updater(_ updater: SUUpdater, willInstallUpdateOnQuit item: SUAppcastItem, immediateInstallationBlock installationBlock: @escaping () -> Void)`
```

--------------------------------

### Example markdown release notes

Source: https://sparkle-project.org/documentation/publishing

A sample markdown structure for release notes that can be parsed and customized programmatically.

```markdown
## Version 1.2

* Update icon

## Version 1.1

* Fix list

## Version 1.0

* Everything is new
```

--------------------------------

### Handle Update Extraction Start

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Invoked before an update is extracted.

```Objective-C
- (void)updater:(nonnull SUUpdater *)updater
    willExtractUpdate:(nonnull SUAppcastItem *)item;
```

```Swift
optional func updater(_ updater: SUUpdater, willExtractUpdate item: SUAppcastItem)
```

--------------------------------

### showInstallingUpdateWithApplicationTerminated

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Notifies the user that the update is currently being installed.

```APIDOC
## showInstallingUpdateWithApplicationTerminated

### Description
Informs the user that the update installation is in progress.

### Parameters
- **applicationTerminated** (BOOL) - Indicates if the application has been terminated.
- **retryTerminatingApplication** (void (^)(void)) - A callback to retry the termination of the application.

### Signature
Objective-C: `- (void)showInstallingUpdateWithApplicationTerminated:(BOOL)applicationTerminated retryTerminatingApplication:(nonnull void (^)(void))retryTerminatingApplication;`
Swift: `func showInstallingUpdate(withApplicationTerminated applicationTerminated: Bool, retryTerminatingApplication: @escaping () -> Void)`
```

--------------------------------

### showUpdateInstalledAndRelaunched:acknowledgement:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Notifies the user that the update installation has finished and the application has been relaunched.

```APIDOC
## showUpdateInstalledAndRelaunched:acknowledgement:

### Description
Displays a notification to the user that the update installation has completed. This method is invoked only if the updater process remains alive.

### Parameters
- **relaunched** (Bool) - Indicates if the update was successfully relaunched.
- **acknowledgement** (void (^)(void)) - A callback to acknowledge that the finished installation notification was shown.
```

--------------------------------

### Background App Setup with Status Bar and Notifications

Source: https://sparkle-project.org/documentation/gentle-reminders

Initializes a background application with a status bar item, sets up notification center delegate, and configures Sparkle for background updates.

```swift
let UPDATE_NOTIFICATION_IDENTIFIER = "UpdateCheck"

@NSApplicationMain
@objc class AppDelegate: NSObject, NSApplicationDelegate, SPUUpdaterDelegate, SPUStandardUserDriverDelegate, UNUserNotificationCenterDelegate {
    // This controller's updaterDelegate and userDriverDelegate outlets are connected to this instance as well
    @IBOutlet var updaterController: SPUStandardUpdaterController!
    // Menu bar item for our background application
    var statusBarItem: NSStatusItem?
    
    func applicationDidFinishLaunching(_ notification: Notification) {
        // Add a status bar item in the menu bar for our app
        do {
            let statusBarItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
            statusBarItem.button?.title = "🌯"
            
            let statusBarMenu = NSMenu()
            statusBarItem.menu = statusBarMenu
            
            let menuItem = NSMenuItem()
            menuItem.title = "Check for Updates…"
            menuItem.target = updaterController
            menuItem.action = #selector(SPUStandardUpdaterController.checkForUpdates(_:))
            
            statusBarMenu.addItem(menuItem)
            
            self.statusBarItem = statusBarItem
        }
        
        // Make the app run in the background
        NSApp.setActivationPolicy(.accessory)
        
        UNUserNotificationCenter.current().delegate = self
    }
    
    // Request for permissions to publish notifications for update alerts
    // This delegate method will be called when Sparkle schedules an update check in the future,
    // which may be a good time to request for update permission. This will be after the user has allowed
    // Sparkle to check for updates automatically. If you need to publish notifications for other reasons,
    // then you may have a more ideal time to request for notification authorization unrelated to update checking.
    func updater(_ updater: SPUUpdater, willScheduleUpdateCheckAfterDelay delay: TimeInterval) {
        UNUserNotificationCenter.current().requestAuthorization(options: [.badge, .alert, .sound]) { granted, error in
            // Examine granted outcome and error if desired...
        }
    }
    
    // Declares that we support gentle scheduled update reminders to Sparkle's standard user driver
    var supportsGentleScheduledUpdateReminders: Bool {
        return true
    }
    
    func standardUserDriverWillHandleShowingUpdate(_ handleShowingUpdate: Bool, forUpdate update: SUAppcastItem, state: SPUUserUpdateState) {
        // When an update alert will be presented, place the app in the foreground
        // We will do this for updates the user initiated themselves too for consistency
        // When we later post a notification, the act of clicking a notification will also change the app
        // to have a regular activation policy. For consistency, we should do this if the user
        // does not click on the notification too.
        NSApp.setActivationPolicy(.regular)
        
        if !state.userInitiated {

```

--------------------------------

### Installation Write No Permission Error

Source: https://sparkle-project.org/documentation/api-reference/Enums/SUError.html

Represents an installation write no permission error code.

```Objective-C
SUInstallationWriteNoPermissionError = 4012
```

```Swift
case installationWriteNoPermissionError = 4012
```

--------------------------------

### startUpdater:

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUUpdater.html

Starts the update cycle. This method validates the configuration, including the feed URL, and begins the update process on the next main runloop cycle.

```APIDOC
## startUpdater:

### Description
Starts the updater. This method checks if Sparkle is configured properly and starts an update cycle in the next main runloop cycle.

### Parameters
- **error** (NSError**) - Optional - The error that is populated if this method fails.
```

--------------------------------

### updater:willInstallUpdateOnQuit:immediateInstallationInvocation:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Notifies the delegate that an update will be installed on quit using an NSInvocation.

```APIDOC
## updater:willInstallUpdateOnQuit:immediateInstallationInvocation:

### Description
Called when an update is scheduled for installation on quit. Deprecated in Sparkle 2.

### Signature
Objective-C: `- (void)updater:(nonnull SUUpdater *)updater willInstallUpdateOnQuit:(nonnull SUAppcastItem *)item immediateInstallationInvocation:(nonnull NSInvocation *)invocation;`
Swift: `optional func updater(_ updater: SUUpdater, willInstallUpdateOnQuit item: SUAppcastItem, immediateInstallationInvocation invocation: NSInvocation)`
```

--------------------------------

### Handle User Update Choice

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Implement this method to respond to user actions like installing, dismissing, or skipping an update.

```Objective-C
- (void)updater:(nonnull SPUUpdater *)updater
    userDidMakeChoice:(SPUUserUpdateChoice)choice
            forUpdate:(nonnull SUAppcastItem *)updateItem
                state:(nonnull SPUUserUpdateState *)state;
```

```Swift
optional func updater(_ updater: SPUUpdater, userDidMake choice: SPUUserUpdateChoice, forUpdate updateItem: SUAppcastItem, state: SPUUserUpdateState)
```

--------------------------------

### Start the Updater

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUUpdater.html

Starts the update cycle. A valid feed URL must be configured before calling this method on the main thread.

```Objective-C
- (BOOL)startUpdater:(NSError *_Nullable *_Nullable)error;
```

```Swift
func start() throws
```

--------------------------------

### Missing Installer Tool Error

Source: https://sparkle-project.org/documentation/api-reference/Enums/SUError.html

Represents a missing installer tool error code.

```Objective-C
SUMissingInstallerToolError = 4003
```

```Swift
case missingInstallerToolError = 4003
```

--------------------------------

### fileURL Property

Source: https://sparkle-project.org/documentation/api-reference/Classes/SUAppcastItem.html

The URL pointing to the update file for installation.

```Objective-C
@property (nonatomic, readonly, nullable) NSURL *fileURL;
```

```Swift
var fileURL: URL? { get }
```

--------------------------------

### Notify installation status

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Informs the user that the update is currently installing, providing a mechanism to retry termination if necessary.

```Objective-C
- (void)
    showInstallingUpdateWithApplicationTerminated:(BOOL)applicationTerminated
                      retryTerminatingApplication:
                          (nonnull void (^)(void))retryTerminatingApplication;
```

```Swift
func showInstallingUpdate(withApplicationTerminated applicationTerminated: Bool, retryTerminatingApplication: @escaping () -> Void)
```

--------------------------------

### Show Update Installed and Relaunched

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Notifies the user that the update installation has finished. This method is only invoked if the updater process remains alive.

```Objective-C
- (void)showUpdateInstalledAndRelaunched:(BOOL)relaunched
                         acknowledgement:
                             (nonnull void (^)(void))acknowledgement;
```

```Swift
func showUpdateInstalledAndRelaunched(_ relaunched: Bool) async
```

--------------------------------

### SPUUpdaterDelegate Methods

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Methods for handling update installation, relaunch logic, and configuration.

```APIDOC
## SPUUpdaterDelegate Methods

### updater:willInstallUpdate:
Called when an update is about to be installed.

### updater:shouldPostponeRelaunchForUpdate:untilInvokingBlock:
Determines if the application relaunch should be delayed to perform additional tasks. Return YES to delay until the installHandler is invoked.

### updaterShouldRelaunchApplication:
Determines if the application should be allowed to relaunch after an update.

### updaterWillRelaunchApplication:
Called immediately before the application is relaunched.

### versionComparatorForUpdater:
Provides a custom version comparator. Note: This is deprecated.

### updater:willScheduleUpdateCheckAfterDelay:
Called when a background update check is scheduled.

### updaterWillNotScheduleUpdateCheck:
Called when no future update checks will be scheduled.

### decryptionPasswordForUpdater:
Returns the password required to extract the update archive.
```

--------------------------------

### standardUserDriverAllowsMinimizableStatusWindow

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUStandardUserDriverDelegate.html

Specifies whether the download, extraction, and installing status windows can be minimized.

```APIDOC
### standardUserDriverAllowsMinimizableStatusWindow

Specifies whether or not the download, extraction, and installing status windows allows to be minimized.

#### Return Value
- **BOOL** - YES if the status window is allowed to be minimized, otherwise NO.
```

--------------------------------

### Update Application via Sparkle CLI

Source: https://sparkle-project.org/documentation/sparkle-cli

Example command to trigger an immediate update check for a specific application bundle.

```bash
./sparkle.app/Contents/MacOS/sparkle --check-immediately /Applications/Hex\ Fiend.app/
```

--------------------------------

### Notify extraction start

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Signals that the update download has finished and extraction has begun.

```Objective-C
- (void)showDownloadDidStartExtractingUpdate;
```

```Swift
func showDownloadDidStartExtractingUpdate()
```

--------------------------------

### Handle Download Initiation

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Notifies the user that the update download has started. The cancellation block allows the user to abort the process before extraction begins.

```Objective-C
- (void)showDownloadInitiatedWithCancellation:
    (nonnull void (^)(void))cancellation;
```

```Swift
func showDownloadInitiated(cancellation: @escaping () -> Void)
```

--------------------------------

### initWithStartingUpdater:updaterDelegate:userDriverDelegate:

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUStandardUpdaterController.html

Initializes a new SPUStandardUpdaterController programmatically with control over whether the updater starts immediately.

```APIDOC
## -initWithStartingUpdater:updaterDelegate:userDriverDelegate:

### Description
Creates a new SPUStandardUpdaterController programmatically, allowing you to specify whether or not to start the updater immediately. If not started, -startUpdater must be invoked later.
```

--------------------------------

### Testing Authorized Installs by Changing Ownership

Source: https://sparkle-project.org/documentation/custom-user-interfaces

To test scenarios where updates require user authorization, you can change the ownership of an application bundle to 'root' using this command. This simulates a situation that might trigger an administrator password prompt during installation.

```bash
sudo chown root path-to-app-bundle
```

--------------------------------

### initWithUpdaterDelegate:userDriverDelegate:

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUStandardUpdaterController.html

Initializes a new SPUStandardUpdaterController programmatically. The updater is started automatically upon initialization.

```APIDOC
## -initWithUpdaterDelegate:userDriverDelegate:

### Description
Creates a new SPUStandardUpdaterController programmatically. The updater is started automatically, and the provided delegates are weakly referenced.

### Signature
- (nonnull instancetype)initWithUpdaterDelegate:(nullable id<SPUUpdaterDelegate>)updaterDelegate userDriverDelegate:(nullable id<SPUStandardUserDriverDelegate>)userDriverDelegate;
```

--------------------------------

### showInstallingUpdateWithApplicationTerminated:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Notifies the user that an update is being installed, indicating whether the application has been terminated. This method is deprecated.

```APIDOC
## showInstallingUpdateWithApplicationTerminated:

### Description
Notifies the user that an update is being installed, indicating whether the application has been terminated. This method is deprecated; use -showInstallingUpdateWithApplicationTerminated:retryTerminatingApplication: instead.

### Signature
Objective-C: `- (void)showInstallingUpdateWithApplicationTerminated:(BOOL)applicationTerminated`
Swift: `optional func showInstallingUpdate(withApplicationTerminated applicationTerminated: Bool)`

### Parameters
- **applicationTerminated** (BOOL) - Indicates if the application has been terminated.
```

--------------------------------

### Declare showInstallingUpdateWithApplicationTerminated

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Defines the method for handling update installation status based on application termination state, marked as deprecated.

```Objective-C
- (void)showInstallingUpdateWithApplicationTerminated:(BOOL)applicationTerminated __deprecated_msg("Implement -showInstallingUpdateWithApplicationTerminated:retryTerminatingApplication: instead.");
```

```Swift
optional func showInstallingUpdate(withApplicationTerminated applicationTerminated: Bool)
```

--------------------------------

### Define an external download link in an update item

Source: https://sparkle-project.org/documentation/publishing

Use this structure to provide a direct download link on a website instead of having Sparkle handle the download and installation automatically.

```xml
<item>
    <title>Version 1.2.4</title>
    <sparkle:version>1.2.4</sparkle:version>
    <sparkle:releaseNotesLink>https://example.com/release_notes_test.html</sparkle:releaseNotesLink>
    <pubDate>Mon, 28 Jan 2013 14:30:00 +0500</pubDate>
    <link>https://myproductwebsite.com</link>
</item>
```

--------------------------------

### Show Update Found Method

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Notifies the user that an update is available and handles their choice to install, dismiss, or skip the update.

```Objective-C
- (void)showUpdateFoundWithAppcastItem:(nonnull SUAppcastItem *)appcastItem
                                 state:(nonnull SPUUserUpdateState *)state
                                 reply:(nonnull void (^)(SPUUserUpdateChoice))
                                           reply;
```

```Swift
func showUpdateFound(with appcastItem: SUAppcastItem, state: SPUUserUpdateState) async -> SPUUserUpdateChoice
```

--------------------------------

### SPUUserUpdateStageInstalling Declaration

Source: https://sparkle-project.org/documentation/api-reference/Enums/SPUUserUpdateStage.html

Represents the state where an update is currently installing in the background.

```Objective-C
SPUUserUpdateStageInstalling
```

```Swift
case installing = 2
```

--------------------------------

### updater:didCancelInstallUpdateOnQuit:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Notifies the delegate that an update installation on quit was cancelled.

```APIDOC
## updater:didCancelInstallUpdateOnQuit:

### Description
Called when an update installation on quit is cancelled. Deprecated in Sparkle 2.

### Signature
Objective-C: `- (void)updater:(nonnull SUUpdater *)updater didCancelInstallUpdateOnQuit:(nonnull SUAppcastItem *)item;`
Swift: `optional func updater(_ updater: SUUpdater, didCancelInstallUpdateOnQuit item: SUAppcastItem)`
```

--------------------------------

### updater:userDidMakeChoice:forUpdate:state:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Called when the user makes a choice (install, dismiss, or skip) regarding a specific update.

```APIDOC
## updater:userDidMakeChoice:forUpdate:state:

### Description
Notifies the delegate that the user has made a choice for a specific update item.

### Parameters
- **updater** (SPUUpdater) - The updater instance.
- **choice** (SPUUserUpdateChoice) - The choice (install, dismiss, or skip) the user made.
- **updateItem** (SUAppcastItem) - The appcast item corresponding to the update.
- **state** (SPUUserUpdateState) - The current state of the update.
```

--------------------------------

### SPUUserUpdateStageDownloaded Declaration

Source: https://sparkle-project.org/documentation/api-reference/Enums/SPUUserUpdateStage.html

Represents the state where an update is downloaded but installation has not started.

```Objective-C
SPUUserUpdateStageDownloaded
```

```Swift
case downloaded = 1
```

--------------------------------

### Implement updater:willInstallUpdateOnQuit:immediateInstallationBlock:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Notifies the delegate that an update will be installed on quit using a block. Deprecated in Sparkle 2.

```Objective-C
- (void)updater:(nonnull SUUpdater *)updater
       willInstallUpdateOnQuit:(nonnull SUAppcastItem *)item
    immediateInstallationBlock:(nonnull void (^)(void))installationBlock;
```

```Swift
optional func updater(_ updater: SUUpdater, willInstallUpdateOnQuit item: SUAppcastItem, immediateInstallationBlock installationBlock: @escaping () -> Void)
```

--------------------------------

### Dismiss Update Installation

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Stops and tears down all update-related UI elements such as windows, alerts, and progress indicators.

```Objective-C
- (void)dismissUpdateInstallation;
```

```Swift
func dismissUpdateInstallation()
```

--------------------------------

### init(startingUpdater:updaterDelegate:userDriverDelegate:)

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUStandardUpdaterController.html

Initializes a new instance of the SPUStandardUpdaterController with the specified updater and driver delegates.

```APIDOC
## init(startingUpdater:updaterDelegate:userDriverDelegate:)

### Description
Initializes the controller. If `startUpdater` is true, the updater begins immediately.

### Parameters
- **startUpdater** (Bool) - Whether to start the updater upon initialization.
- **updaterDelegate** (SPUUpdaterDelegate?) - Optional delegate for updater events.
- **userDriverDelegate** (SPUStandardUserDriverDelegate?) - Optional delegate for user driver events.
```

--------------------------------

### Initialize and start Sparkle updater in AppKit plug-in

Source: https://sparkle-project.org/documentation/programmatic-setup

Implements the Sparkle updater controller within an AppKit bundle plug-in. Requires the plug-in to be loaded by the Catalyst application via a shared protocol.

```swift
import AppKit
import Foundation
import Sparkle

@objc class AppKitPlugin: NSObject, PlugIn {
    let updaterController: SPUStandardUpdaterController
    
    required override init() {
        // We may want to defer starting the updater later, so we will pass false to startingUpdater
        // This is where you can also pass an updater delegate if you need one
        updaterController = SPUStandardUpdaterController(startingUpdater: false, updaterDelegate: nil, userDriverDelegate: nil)
    }
    
    // Called from the Catalyst app
    func startUpdater() {
        updaterController.startUpdater()
    }
}
```

--------------------------------

### initWithHostBundle:delegate:

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUStandardUserDriver.html

Initializes a new instance of the SPUStandardUserDriver with the specified host bundle and delegate.

```APIDOC
## initWithHostBundle:delegate:

### Description
Initializes a Sparkle standard user driver for user update interactions.

### Declaration
Objective-C:
- (nonnull instancetype)initWithHostBundle:(nonnull NSBundle *)hostBundle delegate:(nullable id<SPUStandardUserDriverDelegate>)delegate;

Swift:
init(hostBundle: Bundle, delegate: (any SPUStandardUserDriverDelegate)?)

### Parameters
- **hostBundle** (NSBundle/Bundle) - Required - The target bundle of the host that is being updated.
- **delegate** (id<SPUStandardUserDriverDelegate>) - Optional - The optional delegate to this user driver. Note the standard user driver weakly references the delegate, so you are responsible for keeping it alive.
```

--------------------------------

### Customize markdown or plain text release notes

Source: https://sparkle-project.org/documentation/publishing

Implement the standardUserDriverWillShowReleaseNotesText delegate method to programmatically modify the appearance of release notes based on the installed version.

```swift
func standardUserDriverWillShowReleaseNotesText(_ releaseNotesAttributedString: NSAttributedString, forUpdate update: SUAppcastItem, withBundleDisplayVersion bundleDisplayVersion: String, bundleVersion: String) -> NSAttributedString? {
    let comparator = SUStandardVersionComparator()
    
    var currentVersionComparison = ComparisonResult.orderedAscending
    let newReleaseNotesAttributedString = NSMutableAttributedString(attributedString: releaseNotesAttributedString)
    
    releaseNotesAttributedString.enumerateAttributes(in: NSMakeRange(0, releaseNotesAttributedString.length)) { attributes, range, stop in
        let text = releaseNotesAttributedString.attributedSubstring(from: range).string
        // Is this a 'Version xx' line?
        if text.hasPrefix("Version ") {
            let components = text.split(separator: " ")
            if components.count == 2 {
                let version = components[1].trimmingCharacters(in: .newlines)
                currentVersionComparison = comparator.compareVersion(bundleDisplayVersion, toVersion: version)
            }
        }
        
        switch currentVersionComparison {
        case .orderedAscending:
            break
        case .orderedSame:
            // Same version as installed version gets light gray color
            newReleaseNotesAttributedString.addAttribute(.foregroundColor, value: NSColor.lightGray, range: range)
        case .orderedDescending:
            // Older versions than installed version will be removed
            newReleaseNotesAttributedString.replaceCharacters(in: NSMakeRange(range.location, newReleaseNotesAttributedString.length - range.location), with: "")
            stop.pointee = true
        }
    }
    return newReleaseNotesAttributedString
}
```

--------------------------------

### Installation Canceled Error

Source: https://sparkle-project.org/documentation/api-reference/Enums/SUError.html

Represents an installation canceled error code.

```Objective-C
SUInstallationCanceledError = 4007
```

```Swift
case installationCanceledError = 4007
```

--------------------------------

### Sparkle CLI Usage Help

Source: https://sparkle-project.org/documentation/sparkle-cli

Displays the command line interface usage and available options for the sparkle utility.

```bash
./sparkle.app/Contents/MacOS/sparkle

Usage: ./sparkle.app/Contents/MacOS/sparkle bundle [--application app-path] [--check-immediately] [--probe] [--channels chan1,chan2,…] [--feed-url feed-url] [--user-agent-name display-name] [--grant-automatic-checks] [--send-profile] [--defer-install] [--interactive] [--allow-major-upgrades] [--verbose]
Description:
  Check if any new updates for a Sparkle supported bundle need to be installed.

  If any new updates need to be installed, the user application
  is terminated and the update is installed immediately unless --defer-install
  is specified. If the application was alive, then it will be relaunched after.

  To check if an update is available without installing, use --probe.

  if no updates are available now, or if the last update check was recently
  (unless --check-immediately is specified) then nothing is done.

  If update permission is requested and --grant-automatic-checks is not
  specified, then checking for updates is aborted.

  Unless --interactive is specified, this tool will not request for escalated
  authorization. Alternatively, this tool can be run as root under an active user login
  session, which will not require (and disallow) interaction.

  If --defer-install is specified, this tool will exit leaving a spawned process
  for finishing the installation after the target application terminates.

  If update installation fails due to not having permission (e.g. from Gatekeeper) to replace the old bundle, an exit status of 8 is returned.
  Please specify --user-agent-name if you intend to use this tool in an automated way.
Options:
 --application
    Path to the application to watch for termination and to relaunch.
    If not provided, this is assumed to be the same as the bundle.
 --check-immediately
    Immediately checks for updates to install.
    Without this, updates are checked only when needed on a scheduled basis.
 --probe
    Probe for updates. Check if any updates are available but do not install.
    An exit status of 0 is returned if a new update is available.
 --allow-major-upgrades
    Allows probing and installing major upgrades. Without passing this, an exit
    status of 2 is returned if a major upgrade is found.
 --channels
    List of allowed Sparkle channels to look for updates in. By default,
    only the default channel is used.
 --feed-url
    URL for appcast feed. This URL will be used for the feed instead of the one
    in the bundle's Info.plist or in the bundle's user defaults.
 --user-agent-name
    Display name that will be included as a part of the User-Agent string.
    We encourage setting this so developers know what is querying their feed.
    Otherwise, this value may be set and inferred automatically.
 --interactive
    Allows prompting the user for an authorization dialog prompt if the
    installer needs elevated privileges.
    Without passing this, an exit status of 3 is returned if an update
    requires user interaction. An exit status of 5 is returned
    if the user cancels the authorization prompt.
 --grant-automatic-checks
    If update permission is requested, this enables automatic update checks.
    Note that this behavior may overwrite the user's defaults for the bundle.
    This option has no effect if --check-immediately is passed, or if the
    user has replied to this request already, or if the developer configured
    to skip it. Without passing this, an exit status of 6 is returned
    if permission is needed.
 --send-profile
    Choose to send system profile information if update permission is requested.
    This option can only take effect if --grant-automatic-checks is passed.
 --defer-install
    Defer installation until after the application terminates on its own. The
    application will not be relaunched unless the installation is resumed later.
 --verbose
    Enable verbose logging.
```

--------------------------------

### Installation Authorize Later Error

Source: https://sparkle-project.org/documentation/api-reference/Enums/SUError.html

Represents an installation authorize later error code.

```Objective-C
SUInstallationAuthorizeLaterError = 4008
```

```Swift
case installationAuthorizeLaterError = 4008
```

--------------------------------

### init

Source: https://sparkle-project.org/documentation/api-reference/Classes/SUStandardVersionComparator.html

Initializes a new instance of the standard version comparator.

```APIDOC
## init

### Description
Initializes a new instance of the standard version comparator.

### Declaration
Objective-C: `- (nonnull instancetype)init;`
Swift: `init()`
```

--------------------------------

### Unavailable init Method

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUStandardUserDriver.html

The default init method is unavailable; use initWithHostBundle:delegate: instead.

```Objective-C
- (nonnull instancetype)init;
```

--------------------------------

### Initialize with Dictionary, URL, and Failure Reason

Source: https://sparkle-project.org/documentation/api-reference/Classes/SUAppcastItem.html

Deprecated initializer that includes a base URL for relative paths.

```Objective-C
- (nullable instancetype)initWithDictionary:(NSDictionary *)dict relativeToURL:(NSURL * _Nullable)appcastURL failureReason:(NSString * _Nullable __autoreleasing *_Nullable)error __deprecated_msg("Properties that depend on the system or application version are not supported when used with this initializer. The designated initializer is available in SUAppcastItem+Private.h. Please first explore other APIs or contact us to describe your use case.");
```

```Swift
init?(dictionary dict: [AnyHashable : Any], relativeTo appcastURL: URL?, failureReason error: AutoreleasingUnsafeMutablePointer<NSString?>?)
```

--------------------------------

### initWithHostBundle:applicationBundle:userDriver:delegate:

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUUpdater.html

Initializes a new SPUUpdater instance. This method creates the updater, but startUpdater: must be called subsequently to begin the update cycle.

```APIDOC
## initWithHostBundle:applicationBundle:userDriver:delegate:

### Description
Initializes a new SPUUpdater instance. This creates an updater, but to start it and schedule update checks, startUpdater: needs to be invoked first.

### Parameters
- **hostBundle** (NSBundle) - Required - The bundle that should be targeted for updating.
- **applicationBundle** (NSBundle) - Required - The application bundle that should be waited for termination and relaunched.
- **userDriver** (id<SPUUserDriver>) - Required - The user driver that Sparkle uses for user update interaction.
- **delegate** (id<SPUUpdaterDelegate>) - Optional - The delegate for SPUUpdater. The updater weakly references the delegate.
```

--------------------------------

### Handle Post-Download Event

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Triggered immediately after an update has been successfully downloaded.

```Objective-C
- (void)updater:(nonnull SPUUpdater *)updater
    didDownloadUpdate:(nonnull SUAppcastItem *)item;
```

```Swift
optional func updater(_ updater: SPUUpdater, didDownloadUpdate item: SUAppcastItem)
```

--------------------------------

### SPUUserUpdateChoiceInstall Declaration

Source: https://sparkle-project.org/documentation/api-reference/Enums/SPUUserUpdateChoice.html

Represents the choice to download and install the update.

```Objective-C
SPUUserUpdateChoiceInstall
```

```Swift
case install = 1
```

--------------------------------

### Initialize SPUUpdaterSettings

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUUpdaterSettings.html

Methods for initializing the settings object.

```Objective-C
- (instancetype)init NS_UNAVAILABLE;
```

```Objective-C
- (instancetype)initWithHostBundle:(NSBundle *)hostBundle;
```

```Swift
init(hostBundle: Bundle)
```

--------------------------------

### Configure Build System Flags

Source: https://sparkle-project.org/documentation/programmatic-setup

Set deployment targets and architectures for macOS applications.

```shell
-mmacosx-version-min=version
```

```shell
-arch arm64 -arch x86_64
```

--------------------------------

### Configure Appcast Item with Versioning

Source: https://sparkle-project.org/documentation/publishing

Use sparkle:version for machine-readable build numbers and sparkle:shortVersionString for human-readable display versions.

```xml
<item>
    <title>Version 1.5.1 (bug fixes)</title>
    <link>https://myproductwebsite.com</link>
    <sparkle:version>1248</sparkle:version>
    <sparkle:shortVersionString>1.5.1</sparkle:shortVersionString>
    <sparkle:releaseNotesLink>
        https://example.com/release_notes/app_2.0.html
    </sparkle:releaseNotesLink>
    <pubDate>Mon, 05 Oct 2015 19:20:11 +0000</pubDate>
    <enclosure url="https://example.com/downloads/app.zip.or.dmg.or.tar.etc"
                sparkle:edSignature="7cLALFUHSwvEJWSkV8aMreoBe4fhRa4FncC5NoThKxwThL6FDR7hTiPJh1fo2uagnPogisnQsgFgq6mGkt2RBw=="
                length="1623481"
                type="application/octet-stream" />
</item>
```

--------------------------------

### Handle Pre-Download Event

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Triggered immediately before an update download begins, providing access to the request object.

```Objective-C
- (void)updater:(nonnull SPUUpdater *)updater
    willDownloadUpdate:(nonnull SUAppcastItem *)item
           withRequest:(nonnull NSMutableURLRequest *)request;
```

```Swift
optional func updater(_ updater: SPUUpdater, willDownloadUpdate item: SUAppcastItem, with request: NSMutableURLRequest)
```

--------------------------------

### Get Feed URL String

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Retrieves the URL string for the appcast feed.

```Objective-C
- (nullable NSString *)feedURLStringForUpdater:(nonnull SUUpdater *)updater;
```

```Swift
optional func feedURLString(for updater: SUUpdater) -> String?
```

--------------------------------

### Initialize SUAppcast

Source: https://sparkle-project.org/documentation/api-reference/Classes/SUAppcast.html

The init method is unavailable for this class.

```Objective-C
- (instancetype)init NS_UNAVAILABLE;
```

--------------------------------

### Access the full release notes URL

Source: https://sparkle-project.org/documentation/api-reference/Classes/SUAppcastItem.html

Retrieves the URL for the product's full changelog.

```Objective-C
@property (nonatomic, readonly, nullable) NSURL *fullReleaseNotesURL;
```

```Swift
var fullReleaseNotesURL: URL? { get }
```

--------------------------------

### Access automaticUpdateDownloading property

Source: https://sparkle-project.org/documentation/api-reference/Classes/SUUpdatePermissionResponse.html

Read-only property indicating if updates should be automatically downloaded and installed.

```Objective-C
@property (nonatomic, readonly, nullable) NSNumber *automaticUpdateDownloading;
```

```Swift
var automaticUpdateDownloading: NSNumber? { get }
```

--------------------------------

### updater:didFinishLoadingAppcast:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Called after Sparkle has downloaded the appcast from the remote server.

```APIDOC
## -updater:didFinishLoadingAppcast:

### Description
Called after Sparkle has downloaded the appcast from the remote server. Implement this for special handling of the appcast data.

### Parameters
- **updater** (SPUUpdater) - The updater instance.
- **appcast** (SUAppcast) - The appcast that was downloaded.
```

--------------------------------

### Implement updater:didCancelInstallUpdateOnQuit:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Notifies the delegate that the installation on quit was cancelled. Deprecated in Sparkle 2.

```Objective-C
- (void)updater:(nonnull SUUpdater *)updater
    didCancelInstallUpdateOnQuit:(nonnull SUAppcastItem *)item;
```

```Swift
optional func updater(_ updater: SUUpdater, didCancelInstallUpdateOnQuit item: SUAppcastItem)
```

--------------------------------

### Configure Carthage for Sparkle

Source: https://sparkle-project.org/documentation

Add the binary dependency to your Cartfile to integrate Sparkle via Carthage.

```text
binary "https://sparkle-project.org/Carthage/Sparkle.json"
```

--------------------------------

### pathToRelaunchForUpdater:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Returns the path to relaunch the application after an update.

```APIDOC
## pathToRelaunchForUpdater:

### Description
Returns the path to relaunch the application. Deprecated in Sparkle 2.

### Signature
Objective-C: `- (nullable NSString *)pathToRelaunchForUpdater:(nonnull SUUpdater *)updater;`
Swift: `optional func pathToRelaunch(for updater: SUUpdater) -> String?`
```

--------------------------------

### Define Sparkle Channel in Appcast

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Example XML snippet for specifying a channel in an appcast item.

```xml
<item>
   <sparkle:version>2.0 Beta 1</sparkle:version>
   <sparkle:channel>beta</sparkle:channel>
</item>
```

--------------------------------

### Initialize Programmatically

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUStandardUpdaterController.html

Programmatic initializer for the controller.

```Objective-C
- (nonnull instancetype)
    initWithUpdaterDelegate:(nullable id<SPUUpdaterDelegate>)updaterDelegate
         userDriverDelegate:
             (nullable id<SPUStandardUserDriverDelegate>)userDriverDelegate;
```

```Swift
init(updaterDelegate: (any SPUUpdaterDelegate)?, userDriverDelegate: (any SPUStandardUserDriverDelegate)?)
```

--------------------------------

### Declare showSendingTerminationSignal

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Defines the method for signaling application termination, now deprecated in favor of newer installation methods.

```Objective-C
- (void)showSendingTerminationSignal __deprecated_msg("Implement -showInstallingUpdateWithApplicationTerminated:retryTerminatingApplication: instead.");
```

```Swift
optional func showSendingTerminationSignal()
```

--------------------------------

### Generate Appcast with Sparkle Tool

Source: https://sparkle-project.org/documentation

Use the `generate_appcast` tool to automatically create an appcast file and delta updates. Specify the path to your update archives folder. The tool can also sign the appcast and release notes if your app opts into SURequireSignedFeed.

```bash
./bin/generate_appcast /path/to/your/updates_folder/
```

--------------------------------

### dismissUpdateInstallation

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Dismisses all active update installation UI elements, including windows, alerts, and progress indicators.

```APIDOC
## dismissUpdateInstallation

### Description
Stops and tears down all update-related UI components. This is typically called by Sparkle when aborting or finishing an update process.
```

--------------------------------

### Define Allowed System Profile Keys

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Returns a list of system profile keys to include in the appcast URL query string, overriding default behavior.

```Objective-C
- (nullable NSArray<NSString *> *)allowedSystemProfileKeysForUpdater:
    (nonnull SPUUpdater *)updater;
```

```Swift
optional func allowedSystemProfileKeys(for updater: SPUUpdater) -> [String]?
```

--------------------------------

### Access Update Stage

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUUserUpdateState.html

Retrieves the current update stage, indicating if data is downloaded or an update is installing.

```Objective-C
@property (nonatomic, readonly) SPUUserUpdateStage stage;
```

```Swift
var stage: SPUUserUpdateStage { get }
```

--------------------------------

### Configure CMake Framework and Info.plist

Source: https://sparkle-project.org/documentation/programmatic-setup

Use CMake commands to manage framework linking and custom Info.plist properties.

```cmake
find_library
```

```cmake
-framework A
```

```cmake
-F<fullPath>
```

```cmake
MACOSX_BUNDLE_INFO_PLIST
```

--------------------------------

### Handle Pre-Extraction Event

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUpdaterDelegate.html

Triggered immediately before the downloaded update is extracted.

```Objective-C
- (void)updater:(nonnull SPUUpdater *)updater
    willExtractUpdate:(nonnull SUAppcastItem *)item;
```

```Swift
optional func updater(_ updater: SPUUpdater, willExtractUpdate item: SUAppcastItem)
```

--------------------------------

### Signature XML Output

Source: https://sparkle-project.org/documentation/publishing

Example XML fragments generated by the sign_update tool for archives and release notes.

```xml
sparkle:edSignature="7cLALFUHSwvEJWSkV8aMreoBe4fhRa4FncC5NoThKxwThL6FDR7hTiPJh1fo2uagnPogisnQsgFgq6mGkt2RBw==" length="1623481"
```

```xml
sparkle:edSignature="4KjvG1GjKwXrxfqXbU1j2CYClEDdkMDp2Ii2ICV+Jgx00MDpHFLpLJ+/2tHy9Mp9bTUk5KlpCG1OWBu4nLKOCw==" sparkle:length="1467"
```

--------------------------------

### Monitor Update Session Status

Source: https://sparkle-project.org/documentation/api-reference/Classes/SPUUpdater.html

Indicates whether an update session is currently in progress, such as downloading an appcast or installer.

```Objective-C
@property (nonatomic, readonly) BOOL sessionInProgress;
```

```Swift
var sessionInProgress: Bool { get }
```

--------------------------------

### Show Update Permission Request

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUUserDriver.html

Requests permission from the user to check for updates, typically called once per installation.

```objective-c
- (void)
    showUpdatePermissionRequest:(nonnull SPUUpdatePermissionRequest *)request
                          reply:(nonnull void (^)(
                                    SUUpdatePermissionResponse *_Nonnull))reply;
```

```swift
func show(_ request: SPUUpdatePermissionRequest) async -> SUUpdatePermissionResponse
```

--------------------------------

### Initialize SUUpdatePermissionResponse with download settings

Source: https://sparkle-project.org/documentation/api-reference/Classes/SUUpdatePermissionResponse.html

Initializes a new update permission response instance including automatic update downloading preferences.

```Objective-C
- (nonnull instancetype)initWithAutomaticUpdateChecks:
                            (BOOL)automaticUpdateChecks
                           automaticUpdateDownloading:
                               (NSNumber *_Nullable)automaticUpdateDownloading
                                    sendSystemProfile:(BOOL)sendSystemProfile;
```

```Swift
init(automaticUpdateChecks: Bool, automaticUpdateDownloading: NSNumber?, sendSystemProfile: Bool)
```

--------------------------------

### Implement the Sparkle Updater Delegate

Source: https://sparkle-project.org/documentation/programmatic-setup

Objective-C++ implementation using KVO to synchronize the QAction enabled state with Sparkle's update availability.

```objective-c++
// File: updater_sparkle.mm
// Description: macOS and Sparkle implementation for the application's updater
// Notes: Compile updater_sparkle.mm with -fobjc-arc because this file assumes Automatic Reference Counting (ARC) is enabled

#include "updater.h"
#include <qaction.h>

#import <Sparkle/Sparkle.h>

// An updater delegate class that mainly takes care of updating the check for updates menu item's state
// This class can also be used to implement other updater delegate methods
@interface AppUpdaterDelegate : NSObject <SPUUpdaterDelegate>

@property (nonatomic) SPUStandardUpdaterController *updaterController;

@end

@implementation AppUpdaterDelegate

- (void)observeCanCheckForUpdatesWithAction:(QAction *)action
{
    [_updaterController.updater addObserver:self forKeyPath:NSStringFromSelector(@selector(canCheckForUpdates)) options:(NSKeyValueObservingOptionInitial | NSKeyValueObservingOptionNew) context:(void *)action];
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary<NSKeyValueChangeKey, id> *)change context:(void *)context
{
    if ([keyPath isEqualToString:NSStringFromSelector(@selector(canCheckForUpdates))]) {
        QAction *menuAction = (QAction *)context;
        menuAction->setEnabled(_updaterController.updater.canCheckForUpdates);
    } else {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
    }
}

- (void)dealloc
{
    @autoreleasepool {
        [_updaterController.updater removeObserver:self forKeyPath:NSStringFromSelector(@selector(canCheckForUpdates))];
    }
}

@end

// Creates and starts the updater. There's nothing else required.
Updater::Updater(QAction *checkForUpdatesAction)
{
    @autoreleasepool {
        _updaterDelegate = [[AppUpdaterDelegate alloc] init];
        _updaterDelegate.updaterController = [[SPUStandardUpdaterController alloc] initWithStartingUpdater:YES updaterDelegate:_updaterDelegate userDriverDelegate:nil];
        
        connect(checkForUpdatesAction, &QAction::triggered, this, &Updater::checkForUpdates);
        
        [_updaterDelegate observeCanCheckForUpdatesWithAction:checkForUpdatesAction];
    }
}

// Called when the user checks for updates
void Updater::checkForUpdates()
{
    @autoreleasepool {
        [_updaterDelegate.updaterController checkForUpdates:nil];
    }
}
```

--------------------------------

### Implement updater:willInstallUpdateOnQuit:immediateInstallationInvocation:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SUUpdaterDelegate.html

Notifies the delegate that an update will be installed on quit using an NSInvocation. Deprecated in Sparkle 2.

```Objective-C
- (void)updater:(nonnull SUUpdater *)updater
            willInstallUpdateOnQuit:(nonnull SUAppcastItem *)item
    immediateInstallationInvocation:(nonnull NSInvocation *)invocation;
```

```Swift
optional func updater(_ updater: SUUpdater, willInstallUpdateOnQuit item: SUAppcastItem, immediateInstallationInvocation invocation: NSInvocation)
```

--------------------------------

### Initialize with Dictionary

Source: https://sparkle-project.org/documentation/api-reference/Classes/SUAppcastItem.html

Deprecated initializer for creating an item from a dictionary.

```Objective-C
- (nullable instancetype)initWithDictionary:(NSDictionary *)dict __deprecated_msg("Properties that depend on the system or application version are not supported when used with this initializer. The designated initializer is available in SUAppcastItem+Private.h. Please first explore other APIs or contact us to describe your use case.");
```

```Swift
init?(dictionary dict: [AnyHashable : Any])
```

--------------------------------

### standardUserDriverShowVersionHistoryForAppcastItem:

Source: https://sparkle-project.org/documentation/api-reference/Protocols/SPUStandardUserDriverDelegate.html

Handles showing the full release notes to the user, allowing for custom in-app or offline implementations.

```APIDOC
### standardUserDriverShowVersionHistoryForAppcastItem:

Handles showing the full release notes to the user. If not implemented, Sparkle will open the release notes link in the user's web browser.

#### Parameters
- **item** (SUAppcastItem) - The appcast item corresponding to the latest version available.
```
Tokens:
Raw