PrismLauncher/launcher/updater/MacSparkleUpdater.mm

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

211 lines
5.7 KiB
Plaintext
Raw Normal View History

// SPDX-License-Identifier: GPL-3.0-only
/*
* PolyMC - Minecraft Launcher
* Copyright (C) 2022 Kenneth Chew <kenneth.c0@protonmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "MacSparkleUpdater.h"
#include "Application.h"
#include <Cocoa/Cocoa.h>
#include <Sparkle/Sparkle.h>
@interface UpdaterObserver : NSObject
@property(nonatomic, readonly) SPUUpdater* updater;
/// A callback to run when the state of `canCheckForUpdates` for the `updater` changes.
@property(nonatomic, copy) void (^callback) (bool);
- (id)initWithUpdater:(SPUUpdater*)updater;
@end
@implementation UpdaterObserver
- (id)initWithUpdater:(SPUUpdater*)updater
{
self = [super init];
_updater = updater;
[self addObserver:self forKeyPath:@"updater.canCheckForUpdates" options:NSKeyValueObservingOptionNew context:nil];
return self;
}
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary<NSKeyValueChangeKey, id> *)change
context:(void *)context
{
if ([keyPath isEqualToString:@"updater.canCheckForUpdates"])
{
bool canCheck = [change[NSKeyValueChangeNewKey] boolValue];
self.callback(canCheck);
}
}
@end
@interface UpdaterDelegate : NSObject <SPUUpdaterDelegate>
@property(nonatomic, copy) NSSet<NSString *> *allowedChannels;
@end
@implementation UpdaterDelegate
- (NSSet<NSString *> *)allowedChannelsForUpdater:(SPUUpdater *)updater
{
return _allowedChannels;
}
@end
class MacSparkleUpdater::Private
{
public:
SPUStandardUpdaterController *updaterController;
UpdaterObserver *updaterObserver;
UpdaterDelegate *updaterDelegate;
NSAutoreleasePool *autoReleasePool;
};
MacSparkleUpdater::MacSparkleUpdater()
{
priv = new MacSparkleUpdater::Private();
// Enable Cocoa's memory management.
NSApplicationLoad();
priv->autoReleasePool = [[NSAutoreleasePool alloc] init];
// Delegate is used for setting/getting allowed update channels.
priv->updaterDelegate = [[UpdaterDelegate alloc] init];
// Controller is the interface for actually doing the updates.
priv->updaterController = [[SPUStandardUpdaterController alloc] initWithStartingUpdater:true
updaterDelegate:priv->updaterDelegate
userDriverDelegate:nil];
priv->updaterObserver = [[UpdaterObserver alloc] initWithUpdater:priv->updaterController.updater];
// Use KVO to run a callback that emits a Qt signal when `canCheckForUpdates` changes, so the UI can respond accordingly.
priv->updaterObserver.callback = ^(bool canCheck) {
emit canCheckForUpdatesChanged(canCheck);
};
}
MacSparkleUpdater::~MacSparkleUpdater()
{
[priv->updaterObserver removeObserver:priv->updaterObserver forKeyPath:@"updater.canCheckForUpdates"];
[priv->updaterController release];
[priv->updaterObserver release];
[priv->updaterDelegate release];
[priv->autoReleasePool release];
delete priv;
}
void MacSparkleUpdater::checkForUpdates()
{
[priv->updaterController checkForUpdates:nil];
}
bool MacSparkleUpdater::getAutomaticallyChecksForUpdates()
{
return priv->updaterController.updater.automaticallyChecksForUpdates;
}
double MacSparkleUpdater::getUpdateCheckInterval()
{
return priv->updaterController.updater.updateCheckInterval;
}
QSet<QString> MacSparkleUpdater::getAllowedChannels()
{
// Convert NSSet<NSString> -> QSet<QString>
__block QSet<QString> channels;
[priv->updaterDelegate.allowedChannels enumerateObjectsUsingBlock:^(NSString *channel, BOOL *stop)
{
channels.insert(QString::fromNSString(channel));
}];
return channels;
}
bool MacSparkleUpdater::getBetaAllowed()
{
return getAllowedChannels().contains("beta");
}
void MacSparkleUpdater::setAutomaticallyChecksForUpdates(bool check)
{
priv->updaterController.updater.automaticallyChecksForUpdates = check ? YES : NO; // make clang-tidy happy
}
void MacSparkleUpdater::setUpdateCheckInterval(double seconds)
{
priv->updaterController.updater.updateCheckInterval = seconds;
}
void MacSparkleUpdater::clearAllowedChannels()
{
priv->updaterDelegate.allowedChannels = [NSSet set];
}
void MacSparkleUpdater::setAllowedChannel(const QString &channel)
{
if (channel.isEmpty())
{
clearAllowedChannels();
return;
}
NSSet<NSString *> *nsChannels = [NSSet setWithObject:channel.toNSString()];
priv->updaterDelegate.allowedChannels = nsChannels;
}
void MacSparkleUpdater::setAllowedChannels(const QSet<QString> &channels)
{
if (channels.isEmpty())
{
clearAllowedChannels();
return;
}
QString channelsConfig = "";
// Convert QSet<QString> -> NSSet<NSString>
NSMutableSet<NSString *> *nsChannels = [NSMutableSet setWithCapacity:channels.count()];
foreach (const QString channel, channels)
{
[nsChannels addObject:channel.toNSString()];
channelsConfig += channel + " ";
}
priv->updaterDelegate.allowedChannels = nsChannels;
}
void MacSparkleUpdater::setBetaAllowed(bool allowed)
{
if (allowed)
{
setAllowedChannel("beta");
}
else
{
clearAllowedChannels();
}
}