Managed sessões de sincronização - Swift SDK

@interface MySyncSessionObserver: NSObject
@end
@implementation MySyncSessionObserver
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    if (![object isKindOfClass:RLMSyncSession.class]) {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
        return;
    }
    if (![keyPath isEqualToString:@"connectionState"]) {
        // Not interested in observing this keypath
        return;
    }
    RLMSyncSession *syncSession = (RLMSyncSession *)object;
    RLMSyncConnectionState connectionState = [syncSession connectionState];
    switch (connectionState) {
        case RLMSyncConnectionStateConnecting:
            NSLog(@"Connecting...");
            break;
        case RLMSyncConnectionStateConnected:
            NSLog(@"Connected");
            break;
        case RLMSyncConnectionStateDisconnected:
            NSLog(@"Disconnected");
            break;
    }
}
@end

// Observe connectionState for changes using KVO
MySyncSessionObserver *observer = [[MySyncSessionObserver alloc] init];
[syncSession addObserver:observer
              forKeyPath:@"connectionState"
                 options:NSKeyValueObservingOptionInitial
                 context:nil];
// Later, when done...
[syncSession removeObserver:observer
                 forKeyPath:@"connectionState"
                    context:nil];

// Observe connectionState for changes using KVO
let observer = syncSession.observe(\.connectionState, options: [.initial]) { (syncSession, change) in
    switch syncSession.connectionState {
    case .connecting:
        print("Connecting...")
    case .connected:
        print("Connected")
    case .disconnected:
        print("Disconnected")
    default:
        break
    }
}
// Observe using Combine
let cancellable = syncSession.publisher(for: \.connectionState)
    .sink { connectionState in
        switch connectionState {
        case .connecting:
            print("Connecting...")
        case .connected:
            print("Connected")
        case .disconnected:
            print("Disconnected")
        default:
            break
        }
    }

RLMRealm *syncedRealm = [RLMRealm realmWithConfiguration:configuration error:nil];
RLMSyncSession *syncSession = [syncedRealm syncSession];
// Suspend synchronization
[syncSession suspend];
// Later, resume synchronization
[syncSession resume];

let syncSession = syncedRealm.syncSession!
// Suspend synchronization
syncSession.suspend()
// Later, resume synchronization
syncSession.resume()

// Wait to download all pending changes from Atlas
try await realm.syncSession?.wait(for: .download)
// Add data locally
try realm.write {
    realm.create(Task.self, value: [
        "taskName": "Review proposal",
        "assignee": "Emma",
        "completed": false,
        "progressMinutes": 0,
        "dueDate": date
    ])
}
// Wait for local changes to be uploaded to Atlas
try await realm.syncSession?.wait(for: .upload)

// Wait to download all pending changes from Atlas
realm.syncSession?.wait(for: .download, block: { _ in
    // You can provide a block to execute
    // after waiting for download to complete
})
// Add data locally
do {
    try realm.write {
        realm.create(Task.self, value: [
            "taskName": "Review proposal",
            "assignee": "Emma",
            "completed": false,
            "progressMinutes": 0,
            "dueDate": date
        ])
    }
} catch {
    print("There was an error writing to realm: \(error.localizedDescription)")
}
// Wait for local changes to be uploaded to Atlas
realm.syncSession?.wait(for: .upload, block: { _ in
    // You can provide a block to execute after
    // waiting for upload to complete
})

RLMSyncSession *syncSession = [syncedRealm syncSession];
RLMProgressNotificationToken *token = [syncSession
                                       addSyncProgressNotificationForDirection:RLMSyncProgressDirectionUpload
                                      mode:RLMSyncProgressModeForCurrentlyOutstandingWork
                                     block:^(RLMSyncProgress syncProgress) {
    NSLog(@"Uploaded %fB", (double)syncProgress.progressEstimate);
}];
// Upload something
[syncedRealm transactionWithBlock:^{
    [syncedRealm addObject:[[Task alloc] init]];
}];

let syncSession = realm.syncSession!
let token = syncSession.addProgressNotification(
    for: .upload, mode: .forCurrentlyOutstandingWork) { (progress) in
        
        let progressEstimate = progress.progressEstimate
        let transferPercent = progressEstimate * 100
        
        print("Uploaded (\(transferPercent)%)")
    }