Arbeiten mit NSURLSession: Teil 4

German (Deutsch) translation by Federicco Ancie (you can also view the original English article)

Im vorherigen Tutorial haben wir begonnen, einen einfachen Podcast-Client zu erstellen, um das, was wir über NSURLSession gelernt haben, in die Praxis umzusetzen. Bisher kann unser Podcast-Client die iTunes-Such-API abfragen, einen Podcast-Feed herunterladen und eine Liste der Folgen anzeigen. In diesem Tutorial vergrößern wir einen weiteren interessanten Aspekt von NSURLSession, das Herunterladen außerhalb des Prozesses. Lassen Sie mich Ihnen zeigen, wie das funktioniert.

Einführung

In diesem vierten und letzten Tutorial zu NSURLSession werden wir uns die Aufgaben außerhalb des Prozesses genauer ansehen und insbesondere Aufgaben herunterladen. Unser Podcast-Client kann bereits eine Liste von Episoden anzeigen, kann jedoch derzeit keine einzelnen Episoden herunterladen. Das wird der Schwerpunkt dieses Tutorials sein.

Hintergrund Uploads und Downloads

Das Hinzufügen von Unterstützung für Hintergrund-Uploads und -Downloads ist mit NSURLSession überraschend einfach. Apple bezeichnet sie als nicht prozessbedingte Uploads und Downloads, da die Aufgaben von einem Hintergrunddämon und nicht von Ihrer Anwendung verwaltet werden. Selbst wenn Ihre Anwendung während einer Upload- oder Download-Aufgabe abstürzt, wird die Aufgabe im Hintergrund fortgesetzt.

Überblick

Ich möchte mir einen Moment Zeit nehmen, um mir genauer anzusehen, wie Aufgaben außerhalb des Prozesses funktionieren. Es ist ziemlich einfach, wenn Sie ein vollständiges Bild des Prozesses haben. Das Aktivieren von Hintergrund-Uploads und -Downloads ist nichts anderes als das Umlegen eines Schalters in der Konfiguration Ihrer Sitzung. Mit einem ordnungsgemäß konfigurierten Sitzungsobjekt können Sie Upload- und Download-Aufgaben im Hintergrund planen.

Wenn ein Upload oder Download initiiert wird, entsteht ein Hintergrunddämon. Der Daemon kümmert sich um die Aufgabe und sendet Aktualisierungen über die in der NSURLSession-API deklarierten Delegatenprotokolle an die Anwendung. Wenn Ihre Anwendung aus irgendeinem Grund nicht mehr ausgeführt wird, wird die Aufgabe im Hintergrund fortgesetzt, da es sich um den Daemon handelt, der die Aufgabe verwaltet. Sobald die Aufgabe beendet ist, wird die Anwendung benachrichtigt, die die Aufgabe erstellt hat. Es stellt erneut eine Verbindung mit der Hintergrundsitzung her, die die Aufgabe erstellt hat, und der Daemon, der die Aufgabe verwaltet, informiert die Sitzung über den Abschluss der Aufgabe und übergibt im Fall einer Download-Aufgabe die Datei an die Sitzung. Die Sitzung ruft dann die entsprechenden Delegierungsmethoden auf, um sicherzustellen, dass Ihre Anwendung die entsprechenden Aktionen ausführen kann, z. B. das Verschieben der Datei an einen dauerhafteren Speicherort. Das ist genug Theorie für jetzt. Mal sehen, was wir tun müssen, um Out-of-Process-Downloads in Singlecast zu implementieren.

1. Unterklasse `UITableViewCell`

Schritt 1: Aktualisieren Sie das Haupt-Storyboard

Im Moment verwenden wir Prototypzellen, um die Tabellenansicht zu füllen. Um uns ein bisschen mehr Flexibilität zu geben, müssen wir eine UITableViewCell-Unterklasse erstellen. Öffnen Sie das Haupt-Storyboard, wählen Sie die Tabellenansicht der MTViewController-Instanz aus und setzen Sie die Anzahl der Prototypzellen auf 0.

Schritt 2: Unterklasse erstellen

Öffnen Sie das Menü Datei von Xcode und wählen Sie Neu > Datei.... Erstellen Sie eine neue Objective-C-Klasse, nennen Sie sie MTEpisodeCell und stellen Sie sicher, dass sie von UITableViewCell erbt. Teilen Sie Xcode mit, wo Sie die Klassendateien speichern möchten, und klicken Sie auf Erstellen.

Schritt 3: Aktualisieren Sie die Klassenschnittstelle

Die Oberfläche von MTEpisodeCell ist einfach, wie Sie im folgenden Codeausschnitt sehen können. Wir deklarieren lediglich einen Eigenschaft progress vom Typ float. Wir werden dies verwenden, um den Fortschritt der Download-Aufgabe zu aktualisieren und anzuzeigen, die wir zum Herunterladen einer Episode verwenden.

#import <UIKit/UIKit.h>

@interface MTEpisodeCell : UITableViewCell

@property (assign, nonatomic) float progress;

@end

Schritt 4: Implementierung der Klasse

Die Implementierung von MTEpisodeCell ist etwas komplizierter, aber nicht kompliziert. Anstatt eine Instanz von UIProgressView zu verwenden, füllen wir die Inhaltsansicht der Zelle mit einer Volltonfarbe, um den Fortschritt der Download-Aufgabe anzuzeigen. Dazu fügen wir der Inhaltsansicht der Zelle eine Unteransicht hinzu und aktualisieren ihre Breite, wenn sich die progress eigenschaft der Zelle ändert. Beginnen Sie mit der Deklaration einer progressiView für private Eigenschaften vom Typ UIView.

#import "MTEpisodeCell.h"

@interface MTEpisodeCell ()

@property (strong, nonatomic) UIView *progressView;

@end

Wir überschreiben den von der Klasse festgelegten Initialisierer wie unten gezeigt. Beachten Sie, wie wir das Argument style ignorieren und UITableViewCellStyleSubtitle an den festgelegten Initialisierer der Oberklasse übergeben. Dies ist wichtig, da die Tabellenansicht UITableViewCellStyleDefault als Stil der Zelle übergibt, wenn wir nach einer neuen Zelle fragen.

Im Initialisierer setzen wir die Hintergrundfarbe der Text- und Detailtextbeschriftungen auf [UIColor clearColor] und erstellen die Fortschrittsansicht. Zwei Details sind besonders wichtig. Zuerst fügen wir die Fortschrittsansicht als Unteransicht der Inhaltsansicht der Zelle bei Index 0 ein, um sicherzustellen, dass sie unter den Textbeschriftungen eingefügt wird. Zweitens rufen wir updateView auf, um sicherzustellen, dass der Rahmen der Fortschrittsansicht aktualisiert wird, um den Wert des progress widerzuspiegeln, der während der Initialisierung der Zelle auf 0 gesetzt wird.

- (id)initWithStyle:(UITableViewCellStyle)style reuseIdentifier:(NSString *)reuseIdentifier {
    self = [super initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:reuseIdentifier];

    if (self) {
        // Helpers
        CGSize size = self.contentView.bounds.size;

        // Configure Labels
        [self.textLabel setBackgroundColor:[UIColor clearColor]];
        [self.detailTextLabel setBackgroundColor:[UIColor clearColor]];

        // Initialize Progress View
        self.progressView = [[UIView alloc] initWithFrame:CGRectMake(0.0, 0.0, size.width, size.height)];

        // Configure Progress View
        [self.progressView setAutoresizingMask:(UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleWidth)];
        [self.progressView setBackgroundColor:[UIColor colorWithRed:0.678 green:0.886 blue:0.557 alpha:1.0]];
        [self.contentView insertSubview:self.progressView atIndex:0];

        // Update View
        [self updateView];
    }

    return self;
}

Bevor wir uns die Implementierung von updateView ansehen, müssen wir die Setter-Methode der progress-Eigenschaft überschreiben. Die einzige Änderung, die wir an der Standardimplementierung von setProgress vornehmen, ist der Aufruf von updateView, wenn die Instanzvariable _progress aktualisiert wird. Dadurch wird sichergestellt, dass die Fortschrittsansicht jedes Mal aktualisiert wird, wenn die progress eigenschaft der Zelle aktualisiert wird.

- (void)setProgress:(CGFloat)progress {
    if (_progress != progress) {
        _progress = progress;

        // Update View
        [self updateView];
    }
}

In updateView berechnen wir die neue Breite der Fortschrittsansicht basierend auf dem Wert der progress eigenschaft der Zelle.

- (void)updateView {
    // Helpers
    CGSize size = self.contentView.bounds.size;

    // Update Frame Progress View
    CGRect frame = self.progressView.frame;
    frame.size.width = size.width * self.progress;
    self.progressView.frame = frame;
}

Schritt 5: Verwenden Sie `MTEpisodeCell`

Um die MTEpisodeCell nutzen zu können, müssen wir einige Änderungen in der MTViewController-Klasse vornehmen. Fügen Sie zunächst eine Importanweisung für MTEpisodeCell hinzu.

#import "MTViewController.h"

#import "MWFeedParser.h"
#import "SVProgressHUD.h"
#import "MTEpisodeCell.h"

@interface MTViewController () <MWFeedParserDelegate>

@property (strong, nonatomic) NSDictionary *podcast;
@property (strong, nonatomic) NSMutableArray *episodes;
@property (strong, nonatomic) MWFeedParser *feedParser;

@end

Rufen Sie in der viewDidLoad-Methode des View-Controllers setupView auf, eine Hilfsmethode, die wir als Nächstes implementieren.

- (void)viewDidLoad {
    [super viewDidLoad];

    // Setup View
    [self setupView];

    // Load Podcast
    [self loadPodcast];

    // Add Observer
    [[NSUserDefaults standardUserDefaults] addObserver:self forKeyPath:@"MTPodcast" options:NSKeyValueObservingOptionNew context:NULL];
}

In setupView rufen wir setupTableView auf, eine weitere Hilfsmethode, mit der wir der Tabellenansicht mitteilen, dass sie die MTEpisodeCell-Klasse verwenden soll, wenn sie eine Zelle mit der Wiederverwendungskennung von EpisodeCell benötigt.

1	- (void)setupView {
2	// Setup Table View
3	[self setupTableView];
4	}

1	- (void)setupTableView {
2	// Register Class for Cell Reuse
3	[self.tableView registerClass:[MTEpisodeCell class] forCellReuseIdentifier:EpisodeCell];
4	}

Bevor wir das Projekt erstellen und die Anwendung ausführen, müssen wir unsere Implementierung von tableView:cellForRowAtIndexPath: wie unten gezeigt aktualisieren.

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    MTEpisodeCell *cell = (MTEpisodeCell *)[tableView dequeueReusableCellWithIdentifier:EpisodeCell forIndexPath:indexPath];

    // Fetch Feed Item
    MWFeedItem *feedItem = [self.episodes objectAtIndex:indexPath.row];

    // Configure Table View Cell
    [cell.textLabel setText:feedItem.title];
    [cell.detailTextLabel setText:[NSString stringWithFormat:@"%@", feedItem.date]];

    return cell;
}

Schritt 6: Erstellen und ausführen

Führen Sie Ihre Anwendung im iOS-Simulator oder auf einem Testgerät aus, um das Ergebnis anzuzeigen. Wenn sich nichts geändert hat, haben Sie die Schritte korrekt ausgeführt. Bisher haben wir lediglich die Prototypzellen durch Instanzen von MTEpisodeCell ersetzt.

2. Erstellen Sie eine Hintergrundsitzung

Um Out-of-Process-Downloads zu ermöglichen, benötigen wir eine Sitzung, die so konfiguriert ist, dass sie Out-of-Process-Downloads unterstützt. Dies ist mit der NSURLSession-API überraschend einfach. Es gibt allerdings ein paar Fallstricke.

Schritt 1: `session` eigenschaft erstellen

Deklarieren Sie zunächst eine neue session-Eigenschaft vom Typ NSURLSession in der MTViewController-Klasse und stellen Sie sicher, dass die Klasse den Protokollen NSURLSessionDelegate und NSURLSessionDownloadDelegate entspricht.

#import "MTViewController.h"

#import "MWFeedParser.h"
#import "SVProgressHUD.h"
#import "MTEpisodeCell.h"

@interface MTViewController () <NSURLSessionDelegate, NSURLSessionDownloadDelegate, MWFeedParserDelegate>

@property (strong, nonatomic) NSDictionary *podcast;
@property (strong, nonatomic) NSMutableArray *episodes;
@property (strong, nonatomic) MWFeedParser *feedParser;

@property (strong, nonatomic) NSURLSession *session;

@end

In viewDidLoad legen wir die session-Eigenschaft fest, indem wir backgroundSession auf der View Controller-Instanz aufrufen. Dies ist eine der Fallstricke, über die ich gesprochen habe.

- (void)viewDidLoad {
    [super viewDidLoad];

    // Setup View
    [self setupView];

    // Initialize Session
    [self setSession:[self backgroundSession]];

    // Load Podcast
    [self loadPodcast];

    // Add Observer
    [[NSUserDefaults standardUserDefaults] addObserver:self forKeyPath:@"MTPodcast" options:NSKeyValueObservingOptionNew context:NULL];
}

Werfen wir einen Blick auf die Implementierung von backgroundSession. In backgroundSession deklarieren wir statisch eine session-Variable und verwenden dispatch_once (Grand Central Dispatch), um die Hintergrundsitzung zu instanziieren. Dies ist zwar nicht unbedingt erforderlich, unterstreicht jedoch die Tatsache, dass wir jeweils nur eine Hintergrundsitzung benötigen. Dies ist eine bewährte Methode, die auch in der WWDC-Sitzung zur NSURLSession-API erwähnt wird.

Im Block dispatch_once erstellen wir zunächst ein NSURLSessionConfiguration-Objekt, indem wir backgroundSessionConfiguration: aufrufen und eine Zeichenfolge als Bezeichner übergeben. Der Bezeichner, den wir übergeben, identifiziert die Hintergrundsitzung eindeutig. Dies ist der Schlüssel, wie wir später sehen werden. Anschließend erstellen wir eine Sitzungsinstanz, indem wir sessionWithConfiguration:delegate:delegateQueue: aufrufen und das Sitzungskonfigurationsobjekt übergeben, die delegate-Eigenschaft der Sitzung festlegen und nil als drittes Argument übergeben.

- (NSURLSession *)backgroundSession {
    static NSURLSession *session = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // Session Configuration
        NSURLSessionConfiguration *sessionConfiguration = [NSURLSessionConfiguration backgroundSessionConfiguration:@"com.mobiletuts.Singlecast.BackgroundSession"];

        // Initialize Session
        session = [NSURLSession sessionWithConfiguration:sessionConfiguration delegate:self delegateQueue:nil];
    });

    return session;
}

Durch Übergeben von nil als drittes Argument von sessionWithConfiguration:delegate:delegateQueue: erstellt die Sitzung eine Warteschlange für serielle Operationen für uns. Diese Operationswarteschlange wird zum Ausführen der Aufrufe der Delegatenmethode und der Aufrufe des Abschlusshandlers verwendet.

3. Episode herunterladen

Schritt 1: Download-Aufgabe erstellen

Es ist Zeit, die von uns erstellte Hintergrundsitzung zu nutzen und die MTEpisodeCell zu verwenden. Beginnen wir mit der Implementierung von tableView: didSelectRowAtIndexPath:, einer Methode des UITableViewDelegate-Protokolls. Die Implementierung ist unkompliziert, wie Sie unten sehen können. Wir rufen die richtige MWFeedItem-Instanz aus dem episodes-Array ab und übergeben sie an downloadEpisodeWithFeedItem:.

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    [tableView deselectRowAtIndexPath:indexPath animated:YES];

    // Fetch Feed Item
    MWFeedItem *feedItem = [self.episodes objectAtIndex:indexPath.row];

    // Download Episode with Feed Item
    [self downloadEpisodeWithFeedItem:feedItem];
}

In downloadEpisodeWithFeedItem: extrahieren wir die Remote-URL aus dem Feed-Element, indem wir urlForFeedItem: aufrufen. Erstellen Sie eine Download-Aufgabe, indem Sie downloadTaskWithURL: in der Hintergrundsitzung aufrufen, und senden Sie eine Nachricht mit dem resume, um die Download-Aufgabe zu starten.

- (void)downloadEpisodeWithFeedItem:(MWFeedItem *)feedItem {
    // Extract URL for Feed Item
    NSURL *URL = [self urlForFeedItem:feedItem];

    if (URL) {
        // Schedule Download Task
        [[self.session downloadTaskWithURL:URL] resume];
    }
}

Wie Sie vielleicht erraten haben, ist urlForFeedItem: eine bequeme Methode, die wir verwenden. Wir werden es in diesem Projekt noch einige Male verwenden. Wir erhalten einen Verweis auf das enclosures-Array des Feed-Elements, extrahieren das erste Gehäuse und ziehen das Objekt für den url-Schlüssel heraus. Wir erstellen eine NSURL-Instanz und geben sie zurück.

- (NSURL *)urlForFeedItem:(MWFeedItem *)feedItem {
    NSURL *result = nil;

    // Extract Enclosures
    NSArray *enclosures = [feedItem enclosures];
    if (!enclosures || !enclosures.count) return result;

    NSDictionary *enclosure = [enclosures objectAtIndex:0];
    NSString *urlString = [enclosure objectForKey:@"url"];
    result = [NSURL URLWithString:urlString];

    return result;
}

Wir sind noch nicht fertig. Gibt Ihnen der Compiler drei Warnungen? Dies ist nicht überraschend, da wir die erforderlichen Methoden der Protokolle NSURLSessionDelegate und NSURLSessionDownloadDelegate noch nicht implementiert haben. Wir müssen diese Methoden auch implementieren, wenn wir den Fortschritt der Download-Aufgaben anzeigen möchten.

Schritt 2: Implementieren von Protokollen

Die erste Methode, die wir implementieren müssen, ist URLSession:downloadTask:didResumeAtOffset:. Diese Methode wird aufgerufen, wenn eine Download-Aufgabe fortgesetzt wird. Da dies in diesem Lernprogramm nicht behandelt wird, protokollieren wir einfach eine Nachricht in der Xcode-Konsole.

- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask didResumeAtOffset:(int64_t)fileOffset expectedTotalBytes:(int64_t)expectedTotalBytes {

    NSLog(@"%s", __PRETTY_FUNCTION__);

Interessanter ist die Implementierung von URLSession:downloadTask:didWriteData:totalBytesWritten:totalBytesExpectedToWrite:. Diese Methode wird jedes Mal aufgerufen, wenn einige Bytes von der Sitzung heruntergeladen wurden. Bei dieser Delegatmethode berechnen wir den Fortschritt, rufen die richtige Zelle ab und aktualisieren die Fortschrittseigenschaft der Zelle, wodurch wiederum die Fortschrittsansicht der Zelle aktualisiert wird. Haben Sie den Aufruf dispatch_async entdeckt? Es gibt keine Garantie dafür, dass die Delegate-Methode im Hauptthread aufgerufen wird. Da wir die Benutzeroberfläche aktualisieren, indem wir den Fortschritt der Zelle festlegen, müssen wir die progress-Eigenschaft der Zelle im Hauptthread aktualisieren.

- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask didWriteData:(int64_t)bytesWritten totalBytesWritten:(int64_t)totalBytesWritten totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite {
    // Calculate Progress
    double progress = (double)totalBytesWritten / (double)totalBytesExpectedToWrite;

    // Update Table View Cell
    MTEpisodeCell *cell = [self cellForForDownloadTask:downloadTask];

    dispatch_async(dispatch_get_main_queue(), ^{
        [cell setProgress:progress];
    });
}

Die Implementierung von cellForForDownloadTask: ist unkompliziert. Wir ziehen die Remote-URL mithilfe ihrer originalRequest-Eigenschaft aus der Download-Aufgabe und durchlaufen die Feed-Elemente im episodes-Array, bis eine Übereinstimmung vorliegt. Wenn wir eine Übereinstimmung gefunden haben, fragen wir die Tabellenansicht nach der entsprechenden Zelle und geben sie zurück.

- (MTEpisodeCell *)cellForForDownloadTask:(NSURLSessionDownloadTask *)downloadTask {
    // Helpers
    MTEpisodeCell *cell = nil;
    NSURL *URL = [[downloadTask originalRequest] URL];

    for (MWFeedItem *feedItem in self.episodes) {
        NSURL *feedItemURL = [self urlForFeedItem:feedItem];

        if ([URL isEqual:feedItemURL]) {
            NSUInteger index = [self.episodes indexOfObject:feedItem];
            cell = (MTEpisodeCell *)[self.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:index inSection:0]];
            break;
        }
    }

    return cell;
}

Die dritte Delegatmethode des NSURLSessionDownloadDelegate-Protokolls, die wir implementieren müssen, ist URLSession:downloadTask:didFinishDownloadingToURL:. Wie bereits in den vorherigen Tutorials erwähnt, besteht einer der Vorteile der NSURLSession-API darin, dass Downloads sofort auf die Festplatte geschrieben werden. Das Ergebnis ist, dass uns eine lokale URL in URLSession:downloadTask:didFinishDownloadingToURL: übergeben wird. Die lokale URL, die wir erhalten, verweist jedoch auf eine temporäre Datei. Es liegt in unserer Verantwortung, die Datei an einen dauerhafteren Speicherort zu verschieben, und genau das tun wir in URLSession:downloadTask:didFinishDownloadingToURL:.

1	- (void)URLSession:(NSURLSession )session downloadTask:(NSURLSessionDownloadTask )downloadTask didFinishDownloadingToURL:(NSURL *)location {
2	// Write File to Disk
3	[self moveFileWithURL:location downloadTask:downloadTask];
4	}

In moveFileWithURL:downloadTask: extrahieren wir den Dateinamen der Episode aus der Download-Aufgabe und erstellen eine URL im Verzeichnis Documents der Anwendung, indem wir URLForEpisodeWithName: aufrufen. Wenn die temporäre Datei, die wir von der Hintergrundsitzung erhalten haben, auf eine gültige Datei verweist, verschieben wir diese Datei in ihre neue Heimat im Verzeichnis "Dokumente" der Anwendung.

- (void)moveFileWithURL:(NSURL *)URL downloadTask:(NSURLSessionDownloadTask *)downloadTask {
    // Filename
    NSString *fileName = [[[downloadTask originalRequest] URL] lastPathComponent];

    // Local URL
    NSURL *localURL = [self URLForEpisodeWithName:fileName];

    NSFileManager *fm = [NSFileManager defaultManager];

    if ([fm fileExistsAtPath:[URL path]]) {
        NSError *error = nil;
        [fm moveItemAtURL:URL toURL:localURL error:&error];

        if (error) {
            NSLog(@"Unable to move temporary file to destination. %@, %@", error, error.userInfo);
        }
    }
}

Ich verwende in meinen iOS-Projekten viele Hilfsmethoden, da dies zu DRY-Code führt. Es ist auch eine gute Praxis, Methoden zu erstellen, die nur eines tun. Das Testen wird auf diese Weise viel einfacher.

URLForEpisodeWithName: ist eine weitere Hilfsmethode, die episodesDirectory aufruft. In URLForEpisodeWithName: hängen wir das Argument name an das Episodes-Verzeichnis an, das sich im Documents-Verzeichnis der Anwendung befindet.

1	- (NSURL )URLForEpisodeWithName:(NSString )name {
2	if (!name) return nil;
3	return [self.episodesDirectory URLByAppendingPathComponent:name];
4	}

In episodesDirectory erstellen wir die URL für das Episodenverzeichnis und erstellen das Verzeichnis, falls es noch nicht vorhanden ist.

- (NSURL *)episodesDirectory {
    NSURL *documents = [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
    NSURL *episodes = [documents URLByAppendingPathComponent:@"Episodes"];

    NSFileManager *fm = [NSFileManager defaultManager];

    if (![fm fileExistsAtPath:[episodes path]]) {
        NSError *error = nil;
        [fm createDirectoryAtURL:episodes withIntermediateDirectories:YES attributes:nil error:&error];

        if (error) {
            NSLog(@"Unable to create episodes directory. %@, %@", error, error.userInfo);
        }
    }

    return episodes;
}

Schritt 3: Erstellen und ausführen

Führen Sie die Anwendung aus und testen Sie das Ergebnis, indem Sie eine Episode aus der Liste der Episoden herunterladen. Sie sollten sehen, wie der Fortschritt der Tabellenansichtszelle von links nach rechts den Fortschritt der Download-Aufgabe widerspiegelt. Es gibt jedoch einige Probleme. Haben Sie versucht, durch die Tabellenansicht zu scrollen? Das sieht nicht richtig aus. Lassen Sie uns das beheben.

4. Erstellen Sie einen Fortschrittspuffer

Da in der Tabellenansicht Zellen so oft wie möglich wiederverwendet werden, müssen wir sicherstellen, dass jede Zelle den Download-Status der Episode, die sie darstellt, korrekt wiedergibt. Wir können dies auf verschiedene Arten beheben. Ein Ansatz besteht darin, ein Objekt zu verwenden, das den Fortschritt jeder Download-Aufgabe verfolgt, einschließlich der bereits abgeschlossenen Download-Aufgaben.

Schritt 1: Deklarieren Sie eine Eigenschaft

Beginnen wir damit, einen neuen progressBuffer für private Eigenschaften vom Typ NSMutableDictionary in der MTViewController-Klasse zu deklarieren.

#import "MTViewController.h"

#import "MWFeedParser.h"
#import "SVProgressHUD.h"
#import "MTEpisodeCell.h"

@interface MTViewController () <NSURLSessionDelegate, NSURLSessionDownloadDelegate, MWFeedParserDelegate>

@property (strong, nonatomic) NSDictionary *podcast;
@property (strong, nonatomic) NSMutableArray *episodes;
@property (strong, nonatomic) MWFeedParser *feedParser;

@property (strong, nonatomic) NSURLSession *session;
@property (strong, nonatomic) NSMutableDictionary *progressBuffer;

@end

Schritt 2: Puffer initialisieren

In viewDidLoad initialisieren wir den Fortschrittspuffer wie unten gezeigt.

- (void)viewDidLoad {
    [super viewDidLoad];

    // Setup View
    [self setupView];

    // Initialize Session
    [self setSession:[self backgroundSession]];

    // Initialize Progress Buffer
    [self setProgressBuffer:[NSMutableDictionary dictionary]];

    // Load Podcast
    [self loadPodcast];

    // Add Observer
    [[NSUserDefaults standardUserDefaults] addObserver:self forKeyPath:@"MTPodcast" options:NSKeyValueObservingOptionNew context:NULL];
}

Schritt 3: Aktualisieren der Tabellenansichtszellen

Der Schlüssel, den wir im Wörterbuch verwenden, ist die Remote-URL des entsprechenden Feed-Elements. In diesem Sinne können wir die tableView:cellForRowAtIndexPath: -Methode wie unten gezeigt aktualisieren. Wir ziehen die Remote-URL aus dem Feed-Element und fragen progressBuffer nach dem Wert für den Schlüssel, der der Remote-URL entspricht. Wenn der Wert nicht nil ist, setzen wir die progress eigenschaft der Zelle auf diesen Wert, andernfalls setzen wir die progress eigenschaft der Zelle auf 0.0, wodurch die Fortschrittsansicht ausgeblendet wird, indem ihre Breite auf 0.0 gesetzt wird.

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    MTEpisodeCell *cell = (MTEpisodeCell *)[tableView dequeueReusableCellWithIdentifier:EpisodeCell forIndexPath:indexPath];

    // Fetch Feed Item
    MWFeedItem *feedItem = [self.episodes objectAtIndex:indexPath.row];
    NSURL *URL = [self urlForFeedItem:feedItem];

    // Configure Table View Cell
    [cell.textLabel setText:feedItem.title];
    [cell.detailTextLabel setText:[NSString stringWithFormat:@"%@", feedItem.date]];

    NSNumber *progress = [self.progressBuffer objectForKey:[URL absoluteString]];
    if (!progress) progress = @(0.0);

    [cell setProgress:[progress floatValue]];

    return cell;
}

Schritt 4: Vermeiden Sie Duplikate

Wir können den Fortschrittspuffer auch verwenden, um zu verhindern, dass Benutzer dieselbe Episode zweimal herunterladen. Schauen Sie sich die aktualisierte Implementierung von tableView:didSelectRowAtIndexPath:. Wir machen die gleichen Schritte wie in tableView:cellForRowAtIndexPath: um den Fortschrittswert aus dem Fortschrittspuffer zu extrahieren. Erst wenn der Fortschrittswert nil ist, laden wir die Episode herunter.

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
    [tableView deselectRowAtIndexPath:indexPath animated:YES];

    // Fetch Feed Item
    MWFeedItem *feedItem = [self.episodes objectAtIndex:indexPath.row];

    // URL for Feed Item
    NSURL *URL = [self urlForFeedItem:feedItem];

    if (![self.progressBuffer objectForKey:[URL absoluteString]]) {
        // Download Episode with Feed Item
        [self downloadEpisodeWithFeedItem:feedItem];
    }
}

Schritt 5: Puffer aktualisieren

Der Fortschrittspuffer funktioniert in seiner aktuellen Implementierung nur, wenn wir ihn auf dem neuesten Stand halten. Dies bedeutet, dass wir auch die URLSession:downloadTask:didWriteData:totalBytesWritten:totalBytesExpectedToWrite:-Methode aktualisieren müssen. Wir speichern lediglich den neuen Fortschrittswert im Fortschrittspuffer.

- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask didWriteData:(int64_t)bytesWritten totalBytesWritten:(int64_t)totalBytesWritten totalBytesExpectedToWrite:(int64_t)totalBytesExpectedToWrite {
    // Calculate Progress
    double progress = (double)totalBytesWritten / (double)totalBytesExpectedToWrite;

    // Update Progress Buffer
    NSURL *URL = [[downloadTask originalRequest] URL];
    [self.progressBuffer setObject:@(progress) forKey:[URL absoluteString]];

    // Update Table View Cell
    MTEpisodeCell *cell = [self cellForForDownloadTask:downloadTask];

    dispatch_async(dispatch_get_main_queue(), ^{
        [cell setProgress:progress];
    });
}

In downloadEpisodeWithFeedItem: setzen wir den Fortschrittswert beim Start der Download-Aufgabe auf 0.0.

- (void)downloadEpisodeWithFeedItem:(MWFeedItem *)feedItem {
    // Extract URL for Feed Item
    NSURL *URL = [self urlForFeedItem:feedItem];

    if (URL) {
        // Schedule Download Task
        [[self.session downloadTaskWithURL:URL] resume];

        // Update Progress Buffer
        [self.progressBuffer setObject:@(0.0) forKey:[URL absoluteString]];
    }
}

Der Sitzungsdelegierte wird benachrichtigt, wenn eine Download-Aufgabe abgeschlossen ist. In URLSession:downloadTask:didFinishDownloadingToURL: setzen wir den Fortschrittswert auf 1.0.

- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask didFinishDownloadingToURL:(NSURL *)location {
    // Write File to Disk
    [self moveFileWithURL:location downloadTask:downloadTask];

    // Update Progress Buffer
    NSURL *URL = [[downloadTask originalRequest] URL];
    [self.progressBuffer setObject:@(1.0) forKey:[URL absoluteString]];
}

Schritt 6: Puffer wiederherstellen

Im Moment wird der Fortschrittspuffer nur im Speicher gespeichert, was bedeutet, dass er zwischen den Starts der Anwendung gelöscht wird. Wir könnten den Inhalt auf die Festplatte schreiben, aber um diese Anwendung einfach zu halten, werden wir den Puffer wiederherstellen oder neu erstellen, indem wir überprüfen, welche Episoden bereits heruntergeladen wurden. Die feedParser:didParseFeedItem:-Methode, die Teil des MWFeedParserDelegate-Protokolls ist, wird für jedes Element im Feed aufgerufen. Bei dieser Methode ziehen wir die Remote-URL aus dem Feed-Element, erstellen die entsprechende lokale URL und prüfen, ob die Datei vorhanden ist. Wenn dies der Fall ist, setzen wir den entsprechenden Fortschrittswert für dieses Feedelement auf 1.0, um anzuzeigen, dass es bereits heruntergeladen wurde.

- (void)feedParser:(MWFeedParser *)parser didParseFeedItem:(MWFeedItem *)item {
    if (!self.episodes) {
        self.episodes = [NSMutableArray array];
    }

    [self.episodes addObject:item];

    // Update Progress Buffer
    NSURL *URL = [self urlForFeedItem:item];
    NSURL *localURL = [self URLForEpisodeWithName:[URL lastPathComponent]];

    if ([[NSFileManager defaultManager] fileExistsAtPath:[localURL path]]) {
        [self.progressBuffer setObject:@(1.0) forKey:[URL absoluteString]];
    }
}

Schritt 7: Spülen und wiederholen

Führen Sie die Anwendung noch einmal aus, um festzustellen, ob die Probleme mit der Tabellenansicht behoben sind. Die Anwendung sollte sich nun auch merken, welche Folgen bereits heruntergeladen wurden.

5. Ein guter Bürger sein

Es ist wichtig, dass unsere Anwendung ein guter Bürger ist, indem sie nicht mehr CPU-Zyklen verschwendet oder mehr Batteriestrom verbraucht als benötigt. Was bedeutet das für unseren Podcast-Client? Wenn eine Download-Aufgabe von unserer Anwendung gestartet wird und die Anwendung in den Hintergrund wechselt, benachrichtigt der Hintergrund-Daemon, der die Download-Aufgabe unserer Anwendung verwaltet, unsere Anwendung über die Hintergrundsitzung, dass die Download-Aufgabe beendet wurde. Bei Bedarf startet der Hintergrunddämon unsere Anwendung, damit er auf diese Benachrichtigungen reagieren und die heruntergeladene Datei verarbeiten kann.

In unserem Beispiel müssen wir nichts Besonderes tun, um sicherzustellen, dass unsere Anwendung wieder eine Verbindung zur ursprünglichen Hintergrundsitzung herstellt. Dies wird von der MTViewController-Instanz erledigt. Wir müssen das Betriebssystem jedoch benachrichtigen, wenn unsere Anwendung die Verarbeitung der Downloads abgeschlossen hat, indem wir einen Hintergrundabschluss-Handler aufrufen.

Wenn unsere Anwendung vom Betriebssystem geweckt wird, um auf die Benachrichtigungen der Hintergrundsitzung zu antworten, wird dem Anwendungsdelegierten eine Nachricht der gesendet application:handleEventsForBackgroundURLSession:finishHandler:. Bei dieser Methode können wir bei Bedarf erneut eine Verbindung zur Hintergrundsitzung herstellen und den an uns übergebenen Abschlusshandler aufrufen. Durch das Aufrufen des Completion-Handlers weiß das Betriebssystem, dass unsere Anwendung nicht mehr im Hintergrund ausgeführt werden muss. Dies ist wichtig für die Optimierung der Batterielebensdauer. Wie machen wir das in der Praxis?

Schritt 1: Deklarieren Sie eine Eigenschaft

Wir müssen zuerst eine Eigenschaft für die MTAppDelegate-Klasse deklarieren, um einen Verweis auf den Completion-Handler beizubehalten, den wir von der erhalten application:handleEventsForBackgroundURLSession:CompletionHandler:. Die Immobilie muss öffentlich sein. Der Grund dafür wird gleich klar.

#import <UIKit/UIKit.h>

@interface MTAppDelegate : UIResponder <UIApplicationDelegate>

@property (strong, nonatomic) UIWindow *window;
@property (copy, nonatomic) void (^backgroundSessionCompletionHandler)();

@end

Schritt 2: Rückruf implementieren

In der application:handleEventsForBackgroundURLSession:finishHandler: speichern wir den Completion-Handler in backgroundSessionCompletionHandler, das wir vor einem Moment deklariert haben.

- (void)application:(UIApplication *)application handleEventsForBackgroundURLSession:(NSString *)identifier completionHandler:(void (^)())completionHandler {

    [self setBackgroundSessionCompletionHandler:completionHandler];

Schritt 3: Rufen Sie den Handler für die Hintergrundvervollständigung auf

In der MTViewController-Klasse fügen wir zunächst eine Importanweisung für die MTAppDelegate-Klasse hinzu.

#import "MTViewController.h"

#import "MWFeedParser.h"
#import "MTAppDelegate.h"
#import "SVProgressHUD.h"
#import "MTEpisodeCell.h"

@interface MTViewController () <NSURLSessionDelegate, NSURLSessionDownloadDelegate, MWFeedParserDelegate>

@property (strong, nonatomic) NSDictionary *podcast;
@property (strong, nonatomic) NSMutableArray *episodes;
@property (strong, nonatomic) MWFeedParser *feedParser;

@property (strong, nonatomic) NSURLSession *session;
@property (strong, nonatomic) NSMutableDictionary *progressBuffer;

@end

Anschließend implementieren wir eine andere Hilfsmethode, invokeBackgroundSessionCompletionHandler, die den Hintergrundabschluss-Handler aufruft, der in der backgroundSessionCompletionHandler-Eigenschaft des Anwendungsdelegierten gespeichert ist. Bei dieser Methode fragen wir die Hintergrundsitzung nach allen laufenden Aufgaben. Wenn keine Aufgaben ausgeführt werden, erhalten wir einen Verweis auf den Hintergrundabschluss-Handler des Anwendungsdelegierten. Wenn dies nicht nil ist, rufen wir ihn auf und setzen ihn auf nil.

- (void)invokeBackgroundSessionCompletionHandler {
    [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
        NSUInteger count = [dataTasks count] + [uploadTasks count] + [downloadTasks count];

        if (!count) {
            MTAppDelegate *applicationDelegate = (MTAppDelegate *)[[UIApplication sharedApplication] delegate];
            void (^backgroundSessionCompletionHandler)() = [applicationDelegate backgroundSessionCompletionHandler];

            if (backgroundSessionCompletionHandler) {
                [applicationDelegate setBackgroundSessionCompletionHandler:nil];
                backgroundSessionCompletionHandler();
            }
        }
    }];
}

Warte eine Minute. Wann rufen wir invokeBackgroundSessionCompletionHandler auf? Wir tun dies jedes Mal, wenn eine Download-Aufgabe abgeschlossen ist. Mit anderen Worten, wir rufen diese Methode in URLSession:downloadTask:didFinishDownloadingToURL: wie unten gezeigt.

- (void)URLSession:(NSURLSession *)session downloadTask:(NSURLSessionDownloadTask *)downloadTask didFinishDownloadingToURL:(NSURL *)location {
    // Write File to Disk
    [self moveFileWithURL:location downloadTask:downloadTask];

    // Update Progress Buffer
    NSURL *URL = [[downloadTask originalRequest] URL];
    [self.progressBuffer setObject:@(1.0) forKey:[URL absoluteString]];

    // Invoke Background Completion Handler
    [self invokeBackgroundSessionCompletionHandler];
}

6. Einpacken

Ich hoffe, Sie stimmen zu, dass unser Podcast-Client noch nicht für den App Store bereit ist, da eine der wichtigsten Funktionen, das Abspielen von Podcasts, noch fehlt. Wie ich im vorherigen Tutorial erwähnt habe, lag der Schwerpunkt dieses Projekts nicht auf der Erstellung eines Podcast-Clients mit vollem Funktionsumfang. Das Ziel dieses Projekts war es, zu veranschaulichen, wie die NSURLSession-API genutzt werden kann, um die iTunes-Such-API zu durchsuchen und Podcast-Episoden mithilfe von Daten- bzw. Out-of-Process-Download-Aufgaben herunterzuladen. Sie sollten nun ein grundlegendes Verständnis der NSURLSession-API sowie der Aufgaben außerhalb des Prozesses haben.

Abschluss

Durch die Erstellung eines einfachen Podcast-Clients haben wir uns die Daten und Download-Aufgaben genau angesehen. Wir haben auch gelernt, wie einfach es ist, Download-Aufgaben im Hintergrund zu planen. Die NSURLSession-API ist sowohl für iOS als auch für OS X ein wichtiger Schritt nach vorne. Ich empfehle Ihnen, diese benutzerfreundliche und flexible Klassensuite zu nutzen. In der letzten Folge dieser Serie werde ich mir AFNetworking 2.0 ansehen. Warum ist es ein Meilenstein? Wann sollten Sie es verwenden? Und wie ist der Vergleich mit der NSURLSession-API?

Arbeiten mit NSURLSession: Teil 4

Einführung

Hintergrund Uploads und Downloads

Überblick

1. Unterklasse UITableViewCell

Schritt 1: Aktualisieren Sie das Haupt-Storyboard

Schritt 2: Unterklasse erstellen

Schritt 3: Aktualisieren Sie die Klassenschnittstelle

Schritt 4: Implementierung der Klasse

Schritt 5: Verwenden Sie MTEpisodeCell

Schritt 6: Erstellen und ausführen

2. Erstellen Sie eine Hintergrundsitzung

Schritt 1: session eigenschaft erstellen

3. Episode herunterladen

Schritt 1: Download-Aufgabe erstellen

Schritt 2: Implementieren von Protokollen

Schritt 3: Erstellen und ausführen

4. Erstellen Sie einen Fortschrittspuffer

Schritt 1: Deklarieren Sie eine Eigenschaft

Schritt 2: Puffer initialisieren

Schritt 3: Aktualisieren der Tabellenansichtszellen

Schritt 4: Vermeiden Sie Duplikate

Schritt 5: Puffer aktualisieren

Schritt 6: Puffer wiederherstellen

Schritt 7: Spülen und wiederholen

5. Ein guter Bürger sein

Schritt 1: Deklarieren Sie eine Eigenschaft

Schritt 2: Rückruf implementieren

Schritt 3: Rufen Sie den Handler für die Hintergrundvervollständigung auf

6. Einpacken

Abschluss

1. Unterklasse `UITableViewCell`

Schritt 5: Verwenden Sie `MTEpisodeCell`

Schritt 1: `session` eigenschaft erstellen